diff --git a/src/Playwright/Core/APIRequest.cs b/src/Playwright/Core/APIRequest.cs
index a5d7797fa5..342f067df9 100644
--- a/src/Playwright/Core/APIRequest.cs
+++ b/src/Playwright/Core/APIRequest.cs
@@ -22,7 +22,12 @@
  * SOFTWARE.
  */
 
+using System.Collections.Generic;
+using System.IO;
+using System.Text.Json;
 using System.Threading.Tasks;
+using Microsoft.Playwright.Helpers;
+using Microsoft.Playwright.Transport.Channels;
 
 namespace Microsoft.Playwright.Core;
 
@@ -37,17 +42,34 @@ public APIRequest(PlaywrightImpl playwright)
 
     async Task<IAPIRequestContext> IAPIRequest.NewContextAsync(APIRequestNewContextOptions options)
     {
-        var context = await _playwright._channel.NewRequestAsync(
-            options?.BaseURL,
-            options?.UserAgent,
-            options?.IgnoreHTTPSErrors,
-            options?.ExtraHTTPHeaders,
-            options?.HttpCredentials,
-            options?.Proxy,
-            options?.Timeout,
-            options?.StorageState,
-            options?.StorageStatePath)
-        .ConfigureAwait(false);
+        var args = new Dictionary<string, object>()
+        {
+            ["baseURL"] = options?.BaseURL,
+            ["userAgent"] = options?.UserAgent,
+            ["ignoreHTTPSErrors"] = options?.IgnoreHTTPSErrors,
+            ["extraHTTPHeaders"] = options?.ExtraHTTPHeaders?.ToProtocol(),
+            ["httpCredentials"] = options?.HttpCredentials,
+            ["proxy"] = options?.Proxy,
+            ["timeout"] = options?.Timeout,
+        };
+        string storageState = options?.StorageState;
+        if (!string.IsNullOrEmpty(options?.StorageStatePath))
+        {
+            if (!File.Exists(options?.StorageStatePath))
+            {
+                throw new PlaywrightException($"The specified storage state file does not exist: {options?.StorageStatePath}");
+            }
+
+            storageState = File.ReadAllText(options?.StorageStatePath);
+        }
+        if (!string.IsNullOrEmpty(storageState))
+        {
+            args.Add("storageState", JsonSerializer.Deserialize<StorageState>(storageState, Helpers.JsonExtensions.DefaultJsonSerializerOptions));
+        }
+
+        var context = (await _playwright.SendMessageToServerAsync<APIRequestContextChannel>(
+            "newRequest",
+            args).ConfigureAwait(false)).Object;
         context._request = this;
         return context;
     }
diff --git a/src/Playwright/Core/APIRequestContext.cs b/src/Playwright/Core/APIRequestContext.cs
index 3a60651a38..90feac8490 100644
--- a/src/Playwright/Core/APIRequestContext.cs
+++ b/src/Playwright/Core/APIRequestContext.cs
@@ -54,7 +54,7 @@ public APIRequestContext(IChannelOwner parent, string guid, APIRequestContextIni
     IChannel<APIRequestContext> IChannelOwner<APIRequestContext>.Channel => _channel;
 
     [MethodImpl(MethodImplOptions.NoInlining)]
-    public ValueTask DisposeAsync() => new(_channel.DisposeAsync());
+    public ValueTask DisposeAsync() => new(SendMessageToServerAsync("dispose"));
 
     [MethodImpl(MethodImplOptions.NoInlining)]
     public Task<IAPIResponse> FetchAsync(IRequest request, APIRequestContextOptions options = null)
@@ -121,19 +121,24 @@ public async Task<IAPIResponse> FetchAsync(string url, APIRequestContextOptions
             jsonData = JsonSerializer.Serialize(options.DataObject, _connection.DefaultJsonSerializerOptionsKeepNulls);
         }
 
-        return await _channel.FetchAsync(
-            url,
-            queryParams,
-            options.Method,
-            options.Headers,
-            jsonData,
-            postData,
-            (FormData)options.Form,
-            (FormData)options.Multipart,
-            options.Timeout,
-            options?.FailOnStatusCode,
-            options?.IgnoreHTTPSErrors,
-            options?.MaxRedirects).ConfigureAwait(false);
+        var message = new Dictionary<string, object>
+        {
+            ["url"] = url,
+            ["method"] = options?.Method,
+            ["failOnStatusCode"] = options?.FailOnStatusCode,
+            ["ignoreHTTPSErrors"] = options?.IgnoreHTTPSErrors,
+            ["maxRedirects"] = options?.MaxRedirects,
+            ["timeout"] = options.Timeout,
+            ["params"] = queryParams?.ToProtocol(),
+            ["headers"] = options.Headers?.ToProtocol(),
+            ["jsonData"] = jsonData,
+            ["postData"] = postData != null ? Convert.ToBase64String(postData) : null,
+            ["formData"] = ((FormData)options.Form)?.ToProtocol(throwWhenSerializingFilePayloads: true),
+            ["multipartData"] = ((FormData)options.Multipart)?.ToProtocol(),
+        };
+
+        var response = await SendMessageToServerAsync("fetch", message).ConfigureAwait(false);
+        return new APIResponse(this, response?.GetProperty("response").ToObject<Transport.Protocol.APIResponse>());
     }
 
     private bool IsJsonContentType(IDictionary<string, string> headers)
@@ -193,7 +198,7 @@ private APIRequestContextOptions WithMethod(APIRequestContextOptions options, st
     public async Task<string> StorageStateAsync(APIRequestContextStorageStateOptions options = null)
     {
         string state = JsonSerializer.Serialize(
-            await _channel.StorageStateAsync().ConfigureAwait(false),
+            await SendMessageToServerAsync<StorageState>("storageState").ConfigureAwait(false),
             JsonExtensions.DefaultJsonSerializerOptions);
 
         if (!string.IsNullOrEmpty(options?.Path))
diff --git a/src/Playwright/Core/APIResponse.cs b/src/Playwright/Core/APIResponse.cs
index 9c6ed84fa6..5e9b12128a 100644
--- a/src/Playwright/Core/APIResponse.cs
+++ b/src/Playwright/Core/APIResponse.cs
@@ -27,6 +27,7 @@
 using System.Linq;
 using System.Text.Json;
 using System.Threading.Tasks;
+using Microsoft.Playwright.Helpers;
 
 namespace Microsoft.Playwright.Core;
 
@@ -61,12 +62,12 @@ public async Task<byte[]> BodyAsync()
     {
         try
         {
-            var result = await _context._channel.FetchResponseBodyAsync(FetchUid()).ConfigureAwait(false);
-            if (result == null)
+            var response = await _context.SendMessageToServerAsync("fetchResponseBody", new Dictionary<string, object> { ["fetchUid"] = FetchUid() }).ConfigureAwait(false);
+            if (response?.TryGetProperty("binary", out var binary) == true)
             {
-                throw new PlaywrightException("Response has been disposed");
+                return Convert.FromBase64String(binary.ToString());
             }
-            return Convert.FromBase64String(result);
+            throw new PlaywrightException("Response has been disposed");
         }
         catch (Exception e) when (DriverMessages.IsTargetClosedError(e))
         {
@@ -86,9 +87,13 @@ public async Task<string> TextAsync()
 
     internal string FetchUid() => _initializer.FetchUid;
 
-    internal Task<string[]> FetchLogAsync() => _context._channel.FetchResponseLogAsync(FetchUid());
+    internal async Task<string[]> FetchLogAsync()
+    {
+        var response = await _context.SendMessageToServerAsync("fetchLog", new Dictionary<string, object> { ["fetchUid"] = FetchUid() }).ConfigureAwait(false);
+        return response.Value.GetProperty("log").ToObject<string[]>();
+    }
 
-    public ValueTask DisposeAsync() => new(_context._channel.DisposeAPIResponseAsync(FetchUid()));
+    public ValueTask DisposeAsync() => new(_context.SendMessageToServerAsync("disposeAPIResponse", new Dictionary<string, object> { ["fetchUid"] = FetchUid() }));
 
     public override string ToString()
     {
diff --git a/src/Playwright/Core/Accessibility.cs b/src/Playwright/Core/Accessibility.cs
index a9ba4df3af..474cc36280 100644
--- a/src/Playwright/Core/Accessibility.cs
+++ b/src/Playwright/Core/Accessibility.cs
@@ -22,6 +22,7 @@
  * SOFTWARE.
  */
 
+using System.Collections.Generic;
 using System.Text.Json;
 using System.Threading.Tasks;
 using Microsoft.Playwright.Transport.Channels;
@@ -37,9 +38,17 @@ public Accessibility(PageChannel channel)
         _channel = channel;
     }
 
-    public Task<JsonElement?> SnapshotAsync(AccessibilitySnapshotOptions options = default)
+    public async Task<JsonElement?> SnapshotAsync(AccessibilitySnapshotOptions options = default)
     {
         options ??= new();
-        return _channel.AccessibilitySnapshotAsync(options.InterestingOnly, (options.Root as ElementHandle)?.ElementChannel);
+        if ((await _channel.Object.SendMessageToServerAsync("accessibilitySnapshot", new Dictionary<string, object>
+        {
+            ["interestingOnly"] = options?.InterestingOnly,
+            ["root"] = (options.Root as ElementHandle)?.ElementChannel,
+        }).ConfigureAwait(false)).Value.TryGetProperty("rootAXNode", out var jsonElement))
+        {
+            return jsonElement;
+        }
+        return null;
     }
 }
diff --git a/src/Playwright/Core/Artifact.cs b/src/Playwright/Core/Artifact.cs
index 15d2e94c03..269d75b426 100644
--- a/src/Playwright/Core/Artifact.cs
+++ b/src/Playwright/Core/Artifact.cs
@@ -22,9 +22,12 @@
  * SOFTWARE.
  */
 
+using System.Collections.Generic;
 using System.IO;
 using System.Runtime.CompilerServices;
+using System.Text.Json;
 using System.Threading.Tasks;
+using Microsoft.Playwright.Helpers;
 using Microsoft.Playwright.Transport;
 using Microsoft.Playwright.Transport.Channels;
 using Microsoft.Playwright.Transport.Protocol;
@@ -56,7 +59,8 @@ public async Task<string> PathAfterFinishedAsync()
         {
             throw new PlaywrightException("Path is not available when connecting remotely. Use SaveAsAsync() to save a local copy.");
         }
-        return await _channel.PathAfterFinishedAsync().ConfigureAwait(false);
+        return (await SendMessageToServerAsync<JsonElement?>("pathAfterFinished")
+            .ConfigureAwait(false)).GetString("value", true);
     }
 
     [MethodImpl(MethodImplOptions.NoInlining)]
@@ -64,11 +68,17 @@ public async Task SaveAsAsync(string path)
     {
         if (!_connection.IsRemote)
         {
-            await _channel.SaveAsAsync(path).ConfigureAwait(false);
+            await SendMessageToServerAsync(
+            "saveAs",
+            new Dictionary<string, object>
+            {
+                ["path"] = path,
+            }).ConfigureAwait(false);
             return;
         }
-        System.IO.Directory.CreateDirectory(Path.GetDirectoryName(Path.GetFullPath(path)));
-        var stream = await _channel.SaveAsStreamAsync().ConfigureAwait(false);
+        Directory.CreateDirectory(Path.GetDirectoryName(Path.GetFullPath(path)));
+        var stream = (await SendMessageToServerAsync("saveAsStream")
+            .ConfigureAwait(false)).GetObject<Stream>("stream", _connection);
         await using (stream.ConfigureAwait(false))
         {
             using (var fileStream = new FileStream(path, FileMode.Create, FileAccess.Write))
@@ -81,13 +91,15 @@ public async Task SaveAsAsync(string path)
     [MethodImpl(MethodImplOptions.NoInlining)]
     public async Task<System.IO.Stream> CreateReadStreamAsync()
     {
-        var stream = await _channel.StreamAsync().ConfigureAwait(false);
+        var stream = (await SendMessageToServerAsync<JsonElement?>("stream")
+            .ConfigureAwait(false))?.GetObject<Stream>("stream", _connection);
         return stream.StreamImpl;
     }
 
-    internal Task CancelAsync() => _channel.CancelAsync();
+    internal Task CancelAsync() => SendMessageToServerAsync("cancel");
 
-    internal Task<string> FailureAsync() => _channel.FailureAsync();
+    internal async Task<string> FailureAsync() => (await SendMessageToServerAsync<JsonElement?>("failure")
+            .ConfigureAwait(false)).GetString("error", true);
 
-    internal Task DeleteAsync() => _channel.DeleteAsync();
+    internal Task DeleteAsync() => SendMessageToServerAsync("delete");
 }
diff --git a/src/Playwright/Core/BindingCall.cs b/src/Playwright/Core/BindingCall.cs
index 02d0a6c82f..7da41e4000 100644
--- a/src/Playwright/Core/BindingCall.cs
+++ b/src/Playwright/Core/BindingCall.cs
@@ -27,6 +27,7 @@
 using System.Linq;
 using System.Reflection;
 using System.Threading.Tasks;
+using Microsoft.Playwright.Helpers;
 using Microsoft.Playwright.Transport;
 using Microsoft.Playwright.Transport.Channels;
 using Microsoft.Playwright.Transport.Protocol;
@@ -96,15 +97,28 @@ internal async Task CallAsync(Delegate binding)
                 }
             }
 
-            await _channel.ResolveAsync(ScriptsHelper.SerializedArgument(result)).ConfigureAwait(false);
+            await SendMessageToServerAsync("resolve", new Dictionary<string, object>
+            {
+                ["result"] = ScriptsHelper.SerializedArgument(result),
+            }).ConfigureAwait(false);
         }
         catch (TargetInvocationException ex)
         {
-            await _channel.RejectAsync(ex.InnerException).ConfigureAwait(false);
+            await SendMessageToServerAsync(
+                "reject",
+                new Dictionary<string, object>
+                {
+                    ["error"] = ex.InnerException.ToObject(),
+                }).ConfigureAwait(false);
         }
         catch (Exception ex)
         {
-            await _channel.RejectAsync(ex).ConfigureAwait(false);
+            await SendMessageToServerAsync(
+                "reject",
+                new Dictionary<string, object>
+                {
+                    ["error"] = ex.ToObject(),
+                }).ConfigureAwait(false);
         }
     }
 }
diff --git a/src/Playwright/Core/Browser.cs b/src/Playwright/Core/Browser.cs
index 63fba13eb6..e05885af0b 100644
--- a/src/Playwright/Core/Browser.cs
+++ b/src/Playwright/Core/Browser.cs
@@ -24,9 +24,13 @@
 
 using System;
 using System.Collections.Generic;
+using System.IO;
+using System.Linq;
 using System.Runtime.CompilerServices;
 using System.Text.Json;
+using System.Text.RegularExpressions;
 using System.Threading.Tasks;
+using Microsoft.Playwright.Helpers;
 using Microsoft.Playwright.Transport;
 using Microsoft.Playwright.Transport.Channels;
 using Microsoft.Playwright.Transport.Protocol;
@@ -88,7 +92,10 @@ public async Task CloseAsync(BrowserCloseOptions options = default)
             }
             else
             {
-                await Channel.CloseAsync(options?.Reason).ConfigureAwait(false);
+                await SendMessageToServerAsync<BrowserContextChannel>("close", new Dictionary<string, object>
+                {
+                    ["reason"] = options?.Reason,
+                }).ConfigureAwait(false);
             }
             await _closedTcs.Task.ConfigureAwait(false);
         }
@@ -102,41 +109,74 @@ public async Task CloseAsync(BrowserCloseOptions options = default)
     public async Task<IBrowserContext> NewContextAsync(BrowserNewContextOptions options = default)
     {
         options ??= new();
-        var context = (await Channel.NewContextAsync(
-            acceptDownloads: options.AcceptDownloads,
-            bypassCSP: options.BypassCSP,
-            colorScheme: options.ColorScheme,
-            reducedMotion: options.ReducedMotion,
-            deviceScaleFactor: options.DeviceScaleFactor,
-            extraHTTPHeaders: options.ExtraHTTPHeaders,
-            geolocation: options.Geolocation,
-            hasTouch: options.HasTouch,
-            httpCredentials: options.HttpCredentials,
-            ignoreHTTPSErrors: options.IgnoreHTTPSErrors,
-            isMobile: options.IsMobile,
-            javaScriptEnabled: options.JavaScriptEnabled,
-            locale: options.Locale,
-            offline: options.Offline,
-            permissions: options.Permissions,
-            proxy: options.Proxy,
-            recordHarContent: options.RecordHarContent,
-            recordHarMode: options.RecordHarMode,
-            recordHarOmitContent: options.RecordHarOmitContent,
-            recordHarPath: options.RecordHarPath,
-            recordHarUrlFilter: options.RecordHarUrlFilter,
-            recordHarUrlFilterString: options.RecordHarUrlFilterString,
-            recordHarUrlFilterRegex: options.RecordHarUrlFilterRegex,
-            recordVideo: GetVideoArgs(options.RecordVideoDir, options.RecordVideoSize),
-            storageState: options.StorageState,
-            storageStatePath: options.StorageStatePath,
-            serviceWorkers: options.ServiceWorkers,
-            timezoneId: options.TimezoneId,
-            userAgent: options.UserAgent,
-            viewportSize: options.ViewportSize,
-            screenSize: options.ScreenSize,
-            baseUrl: options.BaseURL,
-            strictSelectors: options.StrictSelectors,
-            forcedColors: options.ForcedColors).ConfigureAwait(false)).Object;
+
+        var args = new Dictionary<string, object>
+        {
+            ["bypassCSP"] = options.BypassCSP,
+            ["deviceScaleFactor"] = options.DeviceScaleFactor,
+            ["serviceWorkers"] = options.ServiceWorkers,
+            ["geolocation"] = options.Geolocation,
+            ["hasTouch"] = options.HasTouch,
+            ["httpCredentials"] = options.HttpCredentials,
+            ["ignoreHTTPSErrors"] = options.IgnoreHTTPSErrors,
+            ["isMobile"] = options.IsMobile,
+            ["javaScriptEnabled"] = options.JavaScriptEnabled,
+            ["locale"] = options.Locale,
+            ["offline"] = options.Offline,
+            ["permissions"] = options.Permissions,
+            ["proxy"] = options.Proxy,
+            ["strictSelectors"] = options.StrictSelectors,
+            ["colorScheme"] = options.ColorScheme == ColorScheme.Null ? "no-override" : options.ColorScheme,
+            ["reducedMotion"] = options.ReducedMotion == ReducedMotion.Null ? "no-override" : options.ReducedMotion,
+            ["forcedColors"] = options.ForcedColors == ForcedColors.Null ? "no-override" : options.ForcedColors,
+            ["extraHTTPHeaders"] = options.ExtraHTTPHeaders?.Select(kv => new HeaderEntry { Name = kv.Key, Value = kv.Value }).ToArray(),
+            ["recordHar"] = PrepareHarOptions(
+                    recordHarContent: options.RecordHarContent,
+                    recordHarMode: options.RecordHarMode,
+                    recordHarPath: options.RecordHarPath,
+                    recordHarOmitContent: options.RecordHarOmitContent,
+                    recordHarUrlFilter: options.RecordHarUrlFilter,
+                    recordHarUrlFilterString: options.RecordHarUrlFilterString,
+                    recordHarUrlFilterRegex: options.RecordHarUrlFilterRegex),
+            ["recordVideo"] = GetVideoArgs(options.RecordVideoDir, options.RecordVideoSize),
+            ["timezoneId"] = options.TimezoneId,
+            ["userAgent"] = options.UserAgent,
+            ["baseURL"] = options.BaseURL,
+        };
+
+        if (options.AcceptDownloads.HasValue)
+        {
+            args.Add("acceptDownloads", options.AcceptDownloads.Value ? "accept" : "deny");
+        }
+
+        var storageState = options.StorageState;
+        if (!string.IsNullOrEmpty(options.StorageStatePath))
+        {
+            if (!File.Exists(options.StorageStatePath))
+            {
+                throw new PlaywrightException($"The specified storage state file does not exist: {options.StorageStatePath}");
+            }
+
+            storageState = File.ReadAllText(options.StorageStatePath);
+        }
+
+        if (!string.IsNullOrEmpty(storageState))
+        {
+            args.Add("storageState", JsonSerializer.Deserialize<StorageState>(storageState, Helpers.JsonExtensions.DefaultJsonSerializerOptions));
+        }
+
+        if (options.ViewportSize?.Width == -1)
+        {
+            args.Add("noDefaultViewport", true);
+        }
+        else
+        {
+            args.Add("viewport", options.ViewportSize);
+            args.Add("screen", options.ScreenSize);
+        }
+
+        var context = (await SendMessageToServerAsync<BrowserContextChannel>("newContext", args).ConfigureAwait(false)).Object;
+
         _browserType.DidCreateContext(context, options, null);
         return context;
     }
@@ -234,5 +274,54 @@ internal void DidClose()
 
     [MethodImpl(MethodImplOptions.NoInlining)]
     public async Task<ICDPSession> NewBrowserCDPSessionAsync()
-        => (await Channel.NewBrowserCDPSessionAsync().ConfigureAwait(false)).Object;
+        => (await SendMessageToServerAsync<CDPChannel>(
+        "newBrowserCDPSession").ConfigureAwait(false)).Object;
+
+    internal static Dictionary<string, object> PrepareHarOptions(
+        HarContentPolicy? recordHarContent,
+        HarMode? recordHarMode,
+        string recordHarPath,
+        bool? recordHarOmitContent,
+        string recordHarUrlFilter,
+        string recordHarUrlFilterString,
+        Regex recordHarUrlFilterRegex)
+    {
+        if (string.IsNullOrEmpty(recordHarPath))
+        {
+            return null;
+        }
+        var recordHarArgs = new Dictionary<string, object>();
+        recordHarArgs["path"] = recordHarPath;
+        if (recordHarContent.HasValue)
+        {
+            recordHarArgs["content"] = recordHarContent;
+        }
+        else if (recordHarOmitContent == true)
+        {
+            recordHarArgs["content"] = HarContentPolicy.Omit;
+        }
+        if (!string.IsNullOrEmpty(recordHarUrlFilter))
+        {
+            recordHarArgs["urlGlob"] = recordHarUrlFilter;
+        }
+        else if (!string.IsNullOrEmpty(recordHarUrlFilterString))
+        {
+            recordHarArgs["urlGlob"] = recordHarUrlFilterString;
+        }
+        else if (recordHarUrlFilterRegex != null)
+        {
+            recordHarArgs["urlRegexSource"] = recordHarUrlFilterRegex.ToString();
+            recordHarArgs["urlRegexFlags"] = recordHarUrlFilterRegex.Options.GetInlineFlags();
+        }
+        if (recordHarMode.HasValue)
+        {
+            recordHarArgs["mode"] = recordHarMode;
+        }
+
+        if (recordHarArgs.Keys.Count > 0)
+        {
+            return recordHarArgs;
+        }
+        return null;
+    }
 }
diff --git a/src/Playwright/Core/BrowserContext.cs b/src/Playwright/Core/BrowserContext.cs
index 859ebb67a3..3202711518 100644
--- a/src/Playwright/Core/BrowserContext.cs
+++ b/src/Playwright/Core/BrowserContext.cs
@@ -260,7 +260,12 @@ internal void OnDialog(IDialog dialog)
     }
 
     [MethodImpl(MethodImplOptions.NoInlining)]
-    public Task AddCookiesAsync(IEnumerable<Cookie> cookies) => Channel.AddCookiesAsync(cookies);
+    public Task AddCookiesAsync(IEnumerable<Cookie> cookies) => SendMessageToServerAsync<PageChannel>(
+            "addCookies",
+            new Dictionary<string, object>
+            {
+                ["cookies"] = cookies,
+            });
 
     [MethodImpl(MethodImplOptions.NoInlining)]
     public Task AddInitScriptAsync(string script = null, string scriptPath = null)
@@ -270,14 +275,19 @@ public Task AddInitScriptAsync(string script = null, string scriptPath = null)
             script = ScriptsHelper.EvaluationScript(script, scriptPath);
         }
 
-        return Channel.AddInitScriptAsync(script);
+        return SendMessageToServerAsync<PageChannel>(
+            "addInitScript",
+            new Dictionary<string, object>
+            {
+                ["source"] = script,
+            });
     }
 
     [MethodImpl(MethodImplOptions.NoInlining)]
-    public Task ClearCookiesAsync() => Channel.ClearCookiesAsync();
+    public Task ClearCookiesAsync() => SendMessageToServerAsync("clearCookies");
 
     [MethodImpl(MethodImplOptions.NoInlining)]
-    public Task ClearPermissionsAsync() => Channel.ClearPermissionsAsync();
+    public Task ClearPermissionsAsync() => SendMessageToServerAsync("clearPermissions");
 
     [MethodImpl(MethodImplOptions.NoInlining)]
     public async Task CloseAsync(BrowserContextCloseOptions options = default)
@@ -293,7 +303,12 @@ await WrapApiCallAsync(
         {
             foreach (var harRecorder in _harRecorders)
             {
-                Artifact artifact = await Channel.HarExportAsync(harRecorder.Key).ConfigureAwait(false);
+                Artifact artifact = (await SendMessageToServerAsync(
+        "harExport",
+        new Dictionary<string, object>
+        {
+            ["harId"] = harRecorder.Key,
+        }).ConfigureAwait(false)).GetObject<Artifact>("artifact", _connection);
                 // Server side will compress artifact if content is attach or if file is .zip.
                 var isCompressed = harRecorder.Value.Content == HarContentPolicy.Attach || harRecorder.Value.Path.EndsWith(".zip", StringComparison.Ordinal);
                 var needCompressed = harRecorder.Value.Path.EndsWith(".zip", StringComparison.Ordinal);
@@ -310,7 +325,10 @@ await WrapApiCallAsync(
             }
         },
             true).ConfigureAwait(false);
-        await Channel.CloseAsync(options?.Reason).ConfigureAwait(false);
+        await SendMessageToServerAsync("close", new Dictionary<string, object>
+        {
+            ["reason"] = options?.Reason,
+        }).ConfigureAwait(false);
         await _closeTcs.Task.ConfigureAwait(false);
     }
 
@@ -325,7 +343,12 @@ internal void SetOptions(BrowserNewContextOptions contextOptions, string tracesD
     }
 
     [MethodImpl(MethodImplOptions.NoInlining)]
-    public Task<IReadOnlyList<BrowserContextCookiesResult>> CookiesAsync(IEnumerable<string> urls = null) => Channel.CookiesAsync(urls);
+    public async Task<IReadOnlyList<BrowserContextCookiesResult>> CookiesAsync(IEnumerable<string> urls = null) => (await SendMessageToServerAsync(
+            "cookies",
+            new Dictionary<string, object>
+            {
+                ["urls"] = urls?.ToArray() ?? Array.Empty<string>(),
+            }).ConfigureAwait(false))?.GetProperty("cookies").ToObject<IReadOnlyList<BrowserContextCookiesResult>>();
 
     [MethodImpl(MethodImplOptions.NoInlining)]
     public Task ExposeBindingAsync(string name, Action callback, BrowserContextExposeBindingOptions options = default)
@@ -393,15 +416,29 @@ public Task ExposeFunctionAsync<T1, T2, T3, T4, TResult>(string name, Func<T1, T
 
     [MethodImpl(MethodImplOptions.NoInlining)]
     public Task GrantPermissionsAsync(IEnumerable<string> permissions, BrowserContextGrantPermissionsOptions options = default)
-        => Channel.GrantPermissionsAsync(permissions, options?.Origin);
+        => SendMessageToServerAsync<PageChannel>("grantPermissions", new Dictionary<string, object>
+        {
+            ["permissions"] = permissions?.ToArray(),
+            ["origin"] = options?.Origin,
+        });
 
     [MethodImpl(MethodImplOptions.NoInlining)]
     public async Task<ICDPSession> NewCDPSessionAsync(IPage page)
-        => (await Channel.NewCDPSessionAsync(page as Page).ConfigureAwait(false)).Object;
+        => (await SendMessageToServerAsync<CDPChannel>(
+        "newCDPSession",
+        new Dictionary<string, object>
+        {
+            ["page"] = new { guid = (page as Page).Guid },
+        }).ConfigureAwait(false)).Object;
 
     [MethodImpl(MethodImplOptions.NoInlining)]
     public async Task<ICDPSession> NewCDPSessionAsync(IFrame frame)
-        => (await Channel.NewCDPSessionAsync(frame as Frame).ConfigureAwait(false)).Object;
+        => (await SendMessageToServerAsync<CDPChannel>(
+        "newCDPSession",
+        new Dictionary<string, object>
+        {
+            ["frame"] = new { guid = (frame as Frame).Guid },
+        }).ConfigureAwait(false)).Object;
 
     [MethodImpl(MethodImplOptions.NoInlining)]
     public async Task<IPage> NewPageAsync()
@@ -411,7 +448,7 @@ public async Task<IPage> NewPageAsync()
             throw new PlaywrightException("Please use Browser.NewContextAsync()");
         }
 
-        return (await Channel.NewPageAsync().ConfigureAwait(false)).Object;
+        return (await SendMessageToServerAsync<PageChannel>("newPage").ConfigureAwait(false)).Object;
     }
 
     [MethodImpl(MethodImplOptions.NoInlining)]
@@ -440,19 +477,34 @@ public Task RouteAsync(Func<string, bool> url, Func<IRoute, Task> handler, Brows
 
     [MethodImpl(MethodImplOptions.NoInlining)]
     public Task SetExtraHTTPHeadersAsync(IEnumerable<KeyValuePair<string, string>> headers)
-        => Channel.SetExtraHTTPHeadersAsync(headers);
+        => SendMessageToServerAsync(
+            "setExtraHTTPHeaders",
+            new Dictionary<string, object>
+            {
+                ["headers"] = headers.Select(kv => new HeaderEntry { Name = kv.Key, Value = kv.Value }),
+            });
 
     [MethodImpl(MethodImplOptions.NoInlining)]
-    public Task SetGeolocationAsync(Geolocation geolocation) => Channel.SetGeolocationAsync(geolocation);
+    public Task SetGeolocationAsync(Geolocation geolocation) => SendMessageToServerAsync<PageChannel>(
+            "setGeolocation",
+            new Dictionary<string, object>
+            {
+                ["geolocation"] = geolocation,
+            });
 
     [MethodImpl(MethodImplOptions.NoInlining)]
-    public Task SetOfflineAsync(bool offline) => Channel.SetOfflineAsync(offline);
+    public Task SetOfflineAsync(bool offline) => SendMessageToServerAsync<PageChannel>(
+            "setOffline",
+            new Dictionary<string, object>
+            {
+                ["offline"] = offline,
+            });
 
     [MethodImpl(MethodImplOptions.NoInlining)]
     public async Task<string> StorageStateAsync(BrowserContextStorageStateOptions options = default)
     {
         string state = JsonSerializer.Serialize(
-            await Channel.GetStorageStateAsync().ConfigureAwait(false),
+            await SendMessageToServerAsync<StorageState>("storageState").ConfigureAwait(false),
             JsonExtensions.DefaultJsonSerializerOptions);
 
         if (!string.IsNullOrEmpty(options?.Path))
@@ -543,7 +595,14 @@ public Task<IConsoleMessage> RunAndWaitForConsoleMessageAsync(Func<Task> action,
     internal void SetDefaultNavigationTimeoutImpl(float? timeout)
     {
         _timeoutSettings.SetDefaultNavigationTimeout(timeout);
-        WrapApiCallAsync(() => Channel.SetDefaultNavigationTimeoutNoReplyAsync(timeout), true).IgnoreException();
+        WrapApiCallAsync(
+            () => SendMessageToServerAsync<PageChannel>(
+            "setDefaultNavigationTimeoutNoReply",
+            new Dictionary<string, object>
+            {
+                ["timeout"] = timeout,
+            }),
+            true).IgnoreException();
     }
 
     [MethodImpl(MethodImplOptions.NoInlining)]
@@ -552,7 +611,14 @@ internal void SetDefaultNavigationTimeoutImpl(float? timeout)
     internal void SetDefaultTimeoutImpl(float? timeout)
     {
         _timeoutSettings.SetDefaultTimeout(timeout);
-        WrapApiCallAsync(() => Channel.SetDefaultTimeoutNoReplyAsync(timeout), true).IgnoreException();
+        WrapApiCallAsync(
+            () => SendMessageToServerAsync<PageChannel>(
+            "setDefaultTimeoutNoReply",
+            new Dictionary<string, object>
+            {
+                ["timeout"] = timeout,
+            }),
+            true).IgnoreException();
     }
 
     internal async Task OnRouteAsync(Route route)
@@ -644,7 +710,9 @@ private Task UnrouteAsync(RouteHandler setting)
     private Task UpdateInterceptionAsync()
     {
         var patterns = RouteHandler.PrepareInterceptionPatterns(_routes);
-        return Channel.SetNetworkInterceptionPatternsAsync(patterns);
+        return SendMessageToServerAsync(
+            "setNetworkInterceptionPatterns",
+            patterns);
     }
 
     internal void OnClose()
@@ -698,7 +766,13 @@ private Task ExposeBindingAsync(string name, Delegate callback, bool handle = fa
 
         _bindings.Add(name, callback);
 
-        return Channel.ExposeBindingAsync(name, handle);
+        return SendMessageToServerAsync<PageChannel>(
+            "exposeBinding",
+            new Dictionary<string, object>
+            {
+                ["name"] = name,
+                ["needsHandle"] = handle,
+            });
     }
 
     private HarContentPolicy? RouteFromHarUpdateContentPolicyToHarContentPolicy(RouteFromHarUpdateContentPolicy? policy)
@@ -717,14 +791,11 @@ private Task ExposeBindingAsync(string name, Delegate callback, bool handle = fa
     internal async Task RecordIntoHarAsync(string har, Page page, BrowserContextRouteFromHAROptions options)
     {
         var contentPolicy = RouteFromHarUpdateContentPolicyToHarContentPolicy(options?.UpdateContent);
-        var harId = await Channel.HarStartAsync(
-            page,
-            har,
-            options?.Url,
-            options?.UrlString,
-            options?.UrlRegex,
-            contentPolicy,
-            options?.UpdateMode).ConfigureAwait(false);
+        var harId = (await SendMessageToServerAsync("harStart", new Dictionary<string, object>
+            {
+                { "page", page?.Channel },
+                { "options", Core.Browser.PrepareHarOptions(contentPolicy ?? HarContentPolicy.Attach, options.UpdateMode ?? HarMode.Minimal, har, null, options.Url, options.UrlString, options.UrlRegex) },
+            }).ConfigureAwait(false)).GetString("harId", false);
         _harRecorders.Add(harId, new() { Path = har, Content = contentPolicy ?? HarContentPolicy.Attach });
     }
 
diff --git a/src/Playwright/Core/BrowserType.cs b/src/Playwright/Core/BrowserType.cs
index 753f308810..c1b92c5b32 100644
--- a/src/Playwright/Core/BrowserType.cs
+++ b/src/Playwright/Core/BrowserType.cs
@@ -60,25 +60,29 @@ internal BrowserType(IChannelOwner parent, string guid, BrowserTypeInitializer i
     public async Task<IBrowser> LaunchAsync(BrowserTypeLaunchOptions options = default)
     {
         options ??= new BrowserTypeLaunchOptions();
-        Browser browser = (await _channel.LaunchAsync(
-            headless: options.Headless,
-            channel: options.Channel,
-            executablePath: options.ExecutablePath,
-            passedArguments: options.Args,
-            proxy: options.Proxy,
-            downloadsPath: options.DownloadsPath,
-            tracesDir: options.TracesDir,
-            chromiumSandbox: options.ChromiumSandbox,
-            firefoxUserPrefs: options.FirefoxUserPrefs,
-            handleSIGINT: options.HandleSIGINT,
-            handleSIGTERM: options.HandleSIGTERM,
-            handleSIGHUP: options.HandleSIGHUP,
-            timeout: options.Timeout,
-            env: options.Env,
-            devtools: options.Devtools,
-            slowMo: options.SlowMo,
-            ignoreDefaultArgs: options.IgnoreDefaultArgs,
-            ignoreAllDefaultArgs: options.IgnoreAllDefaultArgs).ConfigureAwait(false)).Object;
+        Browser browser = (await SendMessageToServerAsync<BrowserChannel>(
+            "launch",
+            new Dictionary<string, object>
+            {
+                { "channel", options.Channel },
+                { "executablePath", options.ExecutablePath },
+                { "args", options.Args },
+                { "ignoreAllDefaultArgs", options.IgnoreAllDefaultArgs },
+                { "ignoreDefaultArgs", options.IgnoreDefaultArgs },
+                { "handleSIGHUP", options.HandleSIGHUP },
+                { "handleSIGINT", options.HandleSIGINT },
+                { "handleSIGTERM", options.HandleSIGTERM },
+                { "headless", options.Headless },
+                { "devtools", options.Devtools },
+                { "env", options.Env.ToProtocol() },
+                { "proxy", options.Proxy },
+                { "downloadsPath", options.DownloadsPath },
+                { "tracesDir", options.TracesDir },
+                { "firefoxUserPrefs", options.FirefoxUserPrefs },
+                { "chromiumSandbox", options.ChromiumSandbox },
+                { "slowMo", options.ChromiumSandbox },
+                { "timeout", options.Timeout },
+            }).ConfigureAwait(false)).Object;
         DidLaunchBrowser(browser);
         return browser;
     }
@@ -87,56 +91,74 @@ public async Task<IBrowser> LaunchAsync(BrowserTypeLaunchOptions options = defau
     public async Task<IBrowserContext> LaunchPersistentContextAsync(string userDataDir, BrowserTypeLaunchPersistentContextOptions options = default)
     {
         options ??= new BrowserTypeLaunchPersistentContextOptions();
-        var context = (await _channel.LaunchPersistentContextAsync(
-            userDataDir,
-            headless: options.Headless,
-            channel: options.Channel,
-            executablePath: options.ExecutablePath,
-            args: options.Args,
-            proxy: options.Proxy,
-            downloadsPath: options.DownloadsPath,
-            tracesDir: options.TracesDir,
-            chromiumSandbox: options.ChromiumSandbox,
-            firefoxUserPrefs: options.FirefoxUserPrefs,
-            handleSIGINT: options.HandleSIGINT,
-            handleSIGTERM: options.HandleSIGTERM,
-            handleSIGHUP: options.HandleSIGHUP,
-            timeout: options.Timeout,
-            env: options.Env,
-            devtools: options.Devtools,
-            slowMo: options.SlowMo,
-            acceptDownloads: options.AcceptDownloads,
-            ignoreHTTPSErrors: options.IgnoreHTTPSErrors,
-            bypassCSP: options.BypassCSP,
-            viewportSize: options.ViewportSize,
-            screenSize: options.ScreenSize,
-            userAgent: options.UserAgent,
-            deviceScaleFactor: options.DeviceScaleFactor,
-            isMobile: options.IsMobile,
-            hasTouch: options.HasTouch,
-            javaScriptEnabled: options.JavaScriptEnabled,
-            timezoneId: options.TimezoneId,
-            geolocation: options.Geolocation,
-            locale: options.Locale,
-            permissions: options.Permissions,
-            extraHTTPHeaders: options.ExtraHTTPHeaders,
-            offline: options.Offline,
-            httpCredentials: options.HttpCredentials,
-            colorScheme: options.ColorScheme,
-            reducedMotion: options.ReducedMotion,
-            recordHarContent: options.RecordHarContent,
-            recordHarMode: options.RecordHarMode,
-            recordHarPath: options.RecordHarPath,
-            recordHarOmitContent: options.RecordHarOmitContent,
-            recordHarUrlFilter: options.RecordHarUrlFilter,
-            recordHarUrlFilterString: options.RecordHarUrlFilterString,
-            recordHarUrlFilterRegex: options.RecordHarUrlFilterRegex,
-            recordVideo: Browser.GetVideoArgs(options.RecordVideoDir, options.RecordVideoSize),
-            serviceWorkers: options.ServiceWorkers,
-            ignoreDefaultArgs: options.IgnoreDefaultArgs,
-            ignoreAllDefaultArgs: options.IgnoreAllDefaultArgs,
-            baseUrl: options.BaseURL,
-            forcedColors: options.ForcedColors).ConfigureAwait(false)).Object;
+        var channelArgs = new Dictionary<string, object>
+        {
+            ["userDataDir"] = userDataDir,
+            ["headless"] = options.Headless,
+            ["channel"] = options.Channel,
+            ["executablePath"] = options.ExecutablePath,
+            ["args"] = options.Args,
+            ["downloadsPath"] = options.DownloadsPath,
+            ["tracesDir"] = options.TracesDir,
+            ["proxy"] = options.Proxy,
+            ["chromiumSandbox"] = options.ChromiumSandbox,
+            ["firefoxUserPrefs"] = options.FirefoxUserPrefs,
+            ["handleSIGINT"] = options.HandleSIGINT,
+            ["handleSIGTERM"] = options.HandleSIGTERM,
+            ["handleSIGHUP"] = options.HandleSIGHUP,
+            ["timeout"] = options.Timeout,
+            ["env"] = options.Env.ToProtocol(),
+            ["devtools"] = options.Devtools,
+            ["slowMo"] = options.SlowMo,
+            ["ignoreHTTPSErrors"] = options.IgnoreHTTPSErrors,
+            ["bypassCSP"] = options.BypassCSP,
+            ["strictSelectors"] = options.StrictSelectors,
+            ["serviceWorkers"] = options.ServiceWorkers,
+            ["screensize"] = options.ScreenSize,
+            ["userAgent"] = options.UserAgent,
+            ["deviceScaleFactor"] = options.DeviceScaleFactor,
+            ["isMobile"] = options.IsMobile,
+            ["hasTouch"] = options.HasTouch,
+            ["javaScriptEnabled"] = options.JavaScriptEnabled,
+            ["timezoneId"] = options.TimezoneId,
+            ["geolocation"] = options.Geolocation,
+            ["locale"] = options.Locale,
+            ["permissions"] = options.Permissions,
+            ["extraHTTPHeaders"] = options.ExtraHTTPHeaders.ToProtocol(),
+            ["offline"] = options.Offline,
+            ["httpCredentials"] = options.HttpCredentials,
+            ["colorScheme"] = options.ColorScheme == ColorScheme.Null ? "no-override" : options.ColorScheme,
+            ["reducedMotion"] = options.ReducedMotion == ReducedMotion.Null ? "no-override" : options.ReducedMotion,
+            ["forcedColors"] = options.ForcedColors == ForcedColors.Null ? "no-override" : options.ForcedColors,
+            ["recordVideo"] = Browser.GetVideoArgs(options.RecordVideoDir, options.RecordVideoSize),
+            ["ignoreDefaultArgs"] = options.IgnoreDefaultArgs,
+            ["ignoreAllDefaultArgs"] = options.IgnoreAllDefaultArgs,
+            ["baseURL"] = options.BaseURL,
+            ["recordHar"] = Browser.PrepareHarOptions(
+                    recordHarContent: options.RecordHarContent,
+                    recordHarMode: options.RecordHarMode,
+                    recordHarPath: options.RecordHarPath,
+                    recordHarOmitContent: options.RecordHarOmitContent,
+                    recordHarUrlFilter: options.RecordHarUrlFilter,
+                    recordHarUrlFilterString: options.RecordHarUrlFilterString,
+                    recordHarUrlFilterRegex: options.RecordHarUrlFilterRegex),
+        };
+
+        if (options.AcceptDownloads.HasValue)
+        {
+            channelArgs.Add("acceptDownloads", options.AcceptDownloads.Value ? "accept" : "deny");
+        }
+
+        if (options.ViewportSize?.Width == -1)
+        {
+            channelArgs.Add("noDefaultViewport", true);
+        }
+        else
+        {
+            channelArgs.Add("viewport", options.ViewportSize);
+        }
+
+        var context = (await SendMessageToServerAsync<BrowserContextChannel>("launchPersistentContext", channelArgs).ConfigureAwait(false)).Object;
 
         // TODO: unite with a single browser context options type which is derived from channels
         DidCreateContext(
@@ -254,7 +276,13 @@ public async Task<IBrowser> ConnectOverCDPAsync(string endpointURL, BrowserTypeC
             throw new ArgumentException("Connecting over CDP is only supported in Chromium.");
         }
         options ??= new BrowserTypeConnectOverCDPOptions();
-        JsonElement result = await _channel.ConnectOverCDPAsync(endpointURL, headers: options.Headers, slowMo: options.SlowMo, timeout: options.Timeout).ConfigureAwait(false);
+        JsonElement result = await SendMessageToServerAsync<JsonElement>("connectOverCDP", new Dictionary<string, object>
+            {
+                { "endpointURL", endpointURL },
+                { "headers", options.Headers.ToProtocol() },
+                { "slowMo", options.SlowMo },
+                { "timeout", options.Timeout },
+            }).ConfigureAwait(false);
         Browser browser = result.GetProperty("browser").ToObject<Browser>(_channel.Connection.DefaultJsonSerializerOptions);
         DidLaunchBrowser(browser);
         if (result.TryGetProperty("defaultContext", out JsonElement defaultContextValue))
diff --git a/src/Playwright/Core/CDPSession.cs b/src/Playwright/Core/CDPSession.cs
index aca4da9c14..5e73b08883 100644
--- a/src/Playwright/Core/CDPSession.cs
+++ b/src/Playwright/Core/CDPSession.cs
@@ -58,11 +58,19 @@ internal override void OnMessage(string method, JsonElement? serverParams)
     }
 
     [MethodImpl(MethodImplOptions.NoInlining)]
-    public Task DetachAsync() => _channel.DetachAsync();
+    public Task DetachAsync() => SendMessageToServerAsync("detach");
 
     [MethodImpl(MethodImplOptions.NoInlining)]
-    public Task<JsonElement?> SendAsync(string method, Dictionary<string, object>? args = null)
-        => _channel.SendAsync(method, args);
+    public async Task<JsonElement?> SendAsync(string method, Dictionary<string, object>? args = null)
+    {
+        var newArgs = new Dictionary<string, object>() { { "method", method } };
+        if (args != null)
+        {
+            newArgs["params"] = args;
+        }
+        var result = await SendMessageToServerAsync("send", newArgs).ConfigureAwait(false);
+        return result?.GetProperty("result");
+    }
 
     private void OnCDPEvent(string name, JsonElement? @params)
     {
diff --git a/src/Playwright/Core/Dialog.cs b/src/Playwright/Core/Dialog.cs
index 5ceec2af2c..9e15123ae8 100644
--- a/src/Playwright/Core/Dialog.cs
+++ b/src/Playwright/Core/Dialog.cs
@@ -22,6 +22,7 @@
  * SOFTWARE.
  */
 
+using System.Collections.Generic;
 using System.Runtime.CompilerServices;
 using System.Threading.Tasks;
 using Microsoft.Playwright.Transport;
@@ -56,8 +57,13 @@ public Dialog(IChannelOwner parent, string guid, DialogInitializer initializer)
     IChannel<Dialog> IChannelOwner<Dialog>.Channel => _channel;
 
     [MethodImpl(MethodImplOptions.NoInlining)]
-    public Task AcceptAsync(string promptText) => _channel.AcceptAsync(promptText ?? string.Empty);
+    public Task AcceptAsync(string promptText) => SendMessageToServerAsync<PageChannel>(
+            "accept",
+            new Dictionary<string, object>
+            {
+                ["promptText"] = promptText ?? string.Empty,
+            });
 
     [MethodImpl(MethodImplOptions.NoInlining)]
-    public Task DismissAsync() => _channel.DismissAsync();
+    public Task DismissAsync() => SendMessageToServerAsync("dismiss");
 }
diff --git a/src/Playwright/Core/ElementHandle.cs b/src/Playwright/Core/ElementHandle.cs
index b346d2f901..5a138d2134 100644
--- a/src/Playwright/Core/ElementHandle.cs
+++ b/src/Playwright/Core/ElementHandle.cs
@@ -60,24 +60,40 @@ internal override void OnMessage(string method, JsonElement? serverParams)
     }
 
     public async Task<IElementHandle> WaitForSelectorAsync(string selector, ElementHandleWaitForSelectorOptions options = default)
-        => (await _channel.WaitForSelectorAsync(
-            selector: selector,
-            state: options?.State,
-            timeout: options?.Timeout,
-            strict: options?.Strict).ConfigureAwait(false))?.Object;
+        => (await SendMessageToServerAsync<ElementHandleChannel>(
+            "waitForSelector",
+            new Dictionary<string, object>
+            {
+                ["selector"] = selector,
+                ["timeout"] = options?.Timeout,
+                ["state"] = options?.State,
+                ["strict"] = options?.Strict,
+            }).ConfigureAwait(false)).Object;
 
     public Task WaitForElementStateAsync(ElementState state, ElementHandleWaitForElementStateOptions options = default)
-        => _channel.WaitForElementStateAsync(state, timeout: options?.Timeout);
+        => SendMessageToServerAsync("waitForElementState", new Dictionary<string, object>
+        {
+            ["state"] = state,
+            ["timeout"] = options?.Timeout,
+        });
 
     public Task PressAsync(string key, ElementHandlePressOptions options = default)
-        => _channel.PressAsync(
-            key,
-            delay: options?.Delay,
-            timeout: options?.Timeout,
-            noWaitAfter: options?.NoWaitAfter);
+        => SendMessageToServerAsync("press", new Dictionary<string, object>
+        {
+            ["key"] = key,
+            ["delay"] = options?.Delay,
+            ["timeout"] = options?.Timeout,
+            ["noWaitAfter"] = options?.NoWaitAfter,
+        });
 
     public Task TypeAsync(string text, ElementHandleTypeOptions options = default)
-        => _channel.TypeAsync(text, delay: options?.Delay, timeout: options?.Timeout, noWaitAfter: options?.NoWaitAfter);
+        => SendMessageToServerAsync("type", new Dictionary<string, object>
+        {
+            ["text"] = text,
+            ["delay"] = options?.Delay,
+            ["timeout"] = options?.Timeout,
+            ["noWaitAfter"] = options?.NoWaitAfter,
+        });
 
     public async Task<byte[]> ScreenshotAsync(ElementHandleScreenshotOptions options = default)
     {
@@ -87,17 +103,28 @@ public async Task<byte[]> ScreenshotAsync(ElementHandleScreenshotOptions options
             options.Type = DetermineScreenshotType(options.Path);
         }
 
-        byte[] result = await _channel.ScreenshotAsync(
-            options.Path,
-            options.OmitBackground,
-            options.Type,
-            options.Quality,
-            options.Mask,
-            options.MaskColor,
-            options.Animations,
-            options.Caret,
-            options.Scale,
-            options.Timeout).ConfigureAwait(false);
+        var args = new Dictionary<string, object>
+        {
+            ["type"] = options.Type,
+            ["omitBackground"] = options.OmitBackground,
+            ["path"] = options.Path,
+            ["timeout"] = options.Timeout,
+            ["animations"] = options.Animations,
+            ["caret"] = options.Caret,
+            ["scale"] = options.Scale,
+            ["quality"] = options.Quality,
+            ["maskColor"] = options.MaskColor,
+        };
+        if (options.Mask != null)
+        {
+            args["mask"] = options.Mask.Select(locator => new Dictionary<string, object>
+            {
+                ["frame"] = ((Locator)locator)._frame._channel,
+                ["selector"] = ((Locator)locator)._selector,
+            }).ToArray();
+        }
+
+        var result = (await SendMessageToServerAsync("screenshot", args).ConfigureAwait(false))?.GetProperty("binary").GetBytesFromBase64();
 
         if (!string.IsNullOrEmpty(options.Path))
         {
@@ -109,52 +136,71 @@ public async Task<byte[]> ScreenshotAsync(ElementHandleScreenshotOptions options
     }
 
     public Task FillAsync(string value, ElementHandleFillOptions options = default)
-        => _channel.FillAsync(
-            value,
-            noWaitAfter: options?.NoWaitAfter,
-            force: options?.Force,
-            timeout: options?.Timeout);
+        => SendMessageToServerAsync("fill", new Dictionary<string, object>
+        {
+            ["value"] = value,
+            ["timeout"] = options?.Timeout,
+            ["force"] = options?.Force,
+            ["noWaitAfter"] = options?.NoWaitAfter,
+        });
 
-    public async Task<IFrame> ContentFrameAsync() => (await _channel.ContentFrameAsync().ConfigureAwait(false))?.Object;
+    public async Task<IFrame> ContentFrameAsync() => (await SendMessageToServerAsync<FrameChannel>("contentFrame").ConfigureAwait(false))?.Object;
 
     public Task HoverAsync(ElementHandleHoverOptions options = default)
-        => _channel.HoverAsync(
-            modifiers: options?.Modifiers,
-            position: options?.Position,
-            timeout: options?.Timeout,
-            force: options?.Force,
-            noWaitAfter: options?.NoWaitAfter,
-            trial: options?.Trial);
+        => SendMessageToServerAsync<JsonElement?>("hover", new Dictionary<string, object>
+        {
+            ["force"] = options?.Force,
+            ["position"] = options?.Position,
+            ["timeout"] = options?.Timeout,
+            ["trial"] = options?.Trial,
+            ["modifiers"] = options?.Modifiers?.Select(m => m.ToValueString()),
+            ["noWaitAfter"] = options?.NoWaitAfter,
+        });
 
     public Task ScrollIntoViewIfNeededAsync(ElementHandleScrollIntoViewIfNeededOptions options = default)
-        => _channel.ScrollIntoViewIfNeededAsync(options?.Timeout);
+        => SendMessageToServerAsync<ElementHandleChannel>("scrollIntoViewIfNeeded", new Dictionary<string, object>
+        {
+            ["timeout"] = options?.Timeout,
+        });
 
-    public async Task<IFrame> OwnerFrameAsync() => (await _channel.OwnerFrameAsync().ConfigureAwait(false)).Object;
+    public async Task<IFrame> OwnerFrameAsync() => (await SendMessageToServerAsync<FrameChannel>("ownerFrame").ConfigureAwait(false)).Object;
 
-    public Task<ElementHandleBoundingBoxResult> BoundingBoxAsync() => _channel.BoundingBoxAsync();
+    public async Task<ElementHandleBoundingBoxResult> BoundingBoxAsync()
+    {
+        var result = (await SendMessageToServerAsync("boundingBox").ConfigureAwait(false)).Value;
+        if (result.TryGetProperty("value", out var value))
+        {
+            return value.ToObject<ElementHandleBoundingBoxResult>();
+        }
+        return null;
+    }
 
     public Task ClickAsync(ElementHandleClickOptions options = default)
-        => _channel.ClickAsync(
-            delay: options?.Delay,
-            button: options?.Button,
-            clickCount: options?.ClickCount,
-            modifiers: options?.Modifiers,
-            position: options?.Position,
-            timeout: options?.Timeout,
-            force: options?.Force,
-            noWaitAfter: options?.NoWaitAfter,
-            trial: options?.Trial);
+        => SendMessageToServerAsync("click", new Dictionary<string, object>
+        {
+            ["delay"] = options?.Delay,
+            ["button"] = options?.Button,
+            ["clickCount"] = options?.ClickCount,
+            ["force"] = options?.Force,
+            ["noWaitAfter"] = options?.NoWaitAfter,
+            ["timeout"] = options?.Timeout,
+            ["trial"] = options?.Trial,
+            ["position"] = options?.Position,
+            ["modifiers"] = options?.Modifiers?.Select(m => m.ToValueString()),
+        });
 
     public Task DblClickAsync(ElementHandleDblClickOptions options = default)
-        => _channel.DblClickAsync(
-            delay: options?.Delay,
-            button: options?.Button,
-            modifiers: options?.Modifiers,
-            position: options?.Position,
-            timeout: options?.Timeout,
-            force: options?.Force,
-            noWaitAfter: options?.NoWaitAfter,
-            trial: options?.Trial);
+        => SendMessageToServerAsync("dblclick", new Dictionary<string, object>
+        {
+            ["delay"] = options?.Delay,
+            ["button"] = options?.Button,
+            ["force"] = options?.Force,
+            ["noWaitAfter"] = options?.NoWaitAfter,
+            ["timeout"] = options?.Timeout,
+            ["trial"] = options?.Trial,
+            ["position"] = options?.Position,
+            ["modifiers"] = options?.Modifiers?.Select(m => m.ToValueString()),
+        });
 
     public Task SetInputFilesAsync(string files, ElementHandleSetInputFilesOptions options = default)
         => SetInputFilesAsync(new[] { files }, options);
@@ -167,7 +213,14 @@ public async Task SetInputFilesAsync(IEnumerable<string> files, ElementHandleSet
             throw new PlaywrightException("Cannot set input files to detached element.");
         }
         var converted = await SetInputFilesHelpers.ConvertInputFilesAsync(files, (BrowserContext)frame.Page.Context).ConfigureAwait(false);
-        await _channel.SetInputFilesAsync(converted, options?.NoWaitAfter, options?.Timeout).ConfigureAwait(false);
+        await SendMessageToServerAsync("setInputFiles", new Dictionary<string, object>
+        {
+            ["payloads"] = converted.Payloads,
+            ["localPaths"] = converted.LocalPaths,
+            ["streams"] = converted.Streams,
+            ["timeout"] = options?.Timeout,
+            ["noWaitAfter"] = options?.NoWaitAfter,
+        }).ConfigureAwait(false);
     }
 
     public Task SetInputFilesAsync(FilePayload files, ElementHandleSetInputFilesOptions options = default)
@@ -176,123 +229,194 @@ public Task SetInputFilesAsync(FilePayload files, ElementHandleSetInputFilesOpti
     public async Task SetInputFilesAsync(IEnumerable<FilePayload> files, ElementHandleSetInputFilesOptions options = default)
     {
         var converted = SetInputFilesHelpers.ConvertInputFiles(files);
-        await _channel.SetInputFilesAsync(converted, options?.NoWaitAfter, options?.Timeout).ConfigureAwait(false);
+        await SendMessageToServerAsync("setInputFiles", new Dictionary<string, object>
+        {
+            ["payloads"] = converted.Payloads,
+            ["localPaths"] = converted.LocalPaths,
+            ["streams"] = converted.Streams,
+            ["timeout"] = options?.Timeout,
+            ["noWaitAfter"] = options?.NoWaitAfter,
+        }).ConfigureAwait(false);
     }
 
     public async Task<IElementHandle> QuerySelectorAsync(string selector)
-        => (await _channel.QuerySelectorAsync(selector).ConfigureAwait(false))?.Object;
+        => (await SendMessageToServerAsync<ElementHandleChannel>(
+            "querySelector",
+            new Dictionary<string, object>
+            {
+                ["selector"] = selector,
+            }).ConfigureAwait(false))?.Object;
 
     public async Task<IReadOnlyList<IElementHandle>> QuerySelectorAllAsync(string selector)
-        => (await _channel.QuerySelectorAllAsync(selector).ConfigureAwait(false)).Select(e => ((ElementHandleChannel)e).Object).ToList().AsReadOnly();
+        => (await SendMessageToServerAsync<ChannelBase[]>(
+            "querySelectorAll",
+            new Dictionary<string, object>
+            {
+                ["selector"] = selector,
+            }).ConfigureAwait(false)).Select(e => ((ElementHandleChannel)e).Object).ToList().AsReadOnly();
 
     public async Task<JsonElement?> EvalOnSelectorAsync(string selector, string expression, object arg = null)
-        => ScriptsHelper.ParseEvaluateResult<JsonElement?>(await _channel.EvalOnSelectorAsync(
-            selector: selector,
-            script: expression,
-            arg: ScriptsHelper.SerializedArgument(arg)).ConfigureAwait(false));
+        => ScriptsHelper.ParseEvaluateResult<JsonElement?>(await SendMessageToServerAsync<JsonElement?>(
+            "evalOnSelector",
+            new Dictionary<string, object>
+            {
+                ["selector"] = selector,
+                ["expression"] = expression,
+                ["arg"] = ScriptsHelper.SerializedArgument(arg),
+            }).ConfigureAwait(false));
 
     public async Task<T> EvalOnSelectorAsync<T>(string selector, string expression, object arg = null)
-        => ScriptsHelper.ParseEvaluateResult<T>(await _channel.EvalOnSelectorAsync(
-            selector: selector,
-            script: expression,
-            arg: ScriptsHelper.SerializedArgument(arg)).ConfigureAwait(false));
+        => ScriptsHelper.ParseEvaluateResult<T>(await SendMessageToServerAsync<JsonElement?>(
+            "evalOnSelector",
+            new Dictionary<string, object>
+            {
+                ["selector"] = selector,
+                ["expression"] = expression,
+                ["arg"] = ScriptsHelper.SerializedArgument(arg),
+            }).ConfigureAwait(false));
 
     public async Task<T> EvalOnSelectorAllAsync<T>(string selector, string expression, object arg = null)
-        => ScriptsHelper.ParseEvaluateResult<T>(await _channel.EvalOnSelectorAllAsync(
-            selector: selector,
-            script: expression,
-            arg: ScriptsHelper.SerializedArgument(arg)).ConfigureAwait(false));
+        => ScriptsHelper.ParseEvaluateResult<T>(await SendMessageToServerAsync<JsonElement?>(
+            "evalOnSelectorAll",
+            new Dictionary<string, object>
+            {
+                ["selector"] = selector,
+                ["expression"] = expression,
+                ["arg"] = ScriptsHelper.SerializedArgument(arg),
+            }).ConfigureAwait(false));
 
-    public Task FocusAsync() => _channel.FocusAsync();
+    public Task FocusAsync() => SendMessageToServerAsync("focus");
 
     public Task DispatchEventAsync(string type, object eventInit = null)
-        => _channel.DispatchEventAsync(
-            type,
-            eventInit = ScriptsHelper.SerializedArgument(eventInit));
+        => SendMessageToServerAsync<ElementHandleChannel>("dispatchEvent", new Dictionary<string, object>
+        {
+            ["type"] = type,
+            ["eventInit"] = ScriptsHelper.SerializedArgument(eventInit),
+        });
 
-    public Task<string> GetAttributeAsync(string name) => _channel.GetAttributeAsync(name);
+    public async Task<string> GetAttributeAsync(string name)
+    {
+        if ((await SendMessageToServerAsync("getAttribute", new Dictionary<string, object>
+        {
+            ["name"] = name,
+        }).ConfigureAwait(false))?.TryGetProperty("value", out var value) ?? false)
+        {
+            return value.ToString();
+        }
+        return null;
+    }
 
-    public Task<string> InnerHTMLAsync() => _channel.InnerHTMLAsync();
+    public async Task<string> InnerHTMLAsync() => (await SendMessageToServerAsync("innerHTML").ConfigureAwait(false))?.GetProperty("value").ToString();
 
-    public Task<string> InnerTextAsync() => _channel.InnerTextAsync();
+    public async Task<string> InnerTextAsync() => (await SendMessageToServerAsync("innerText").ConfigureAwait(false))?.GetProperty("value").ToString();
 
-    public Task<string> TextContentAsync() => _channel.TextContentAsync();
+    public async Task<string> TextContentAsync() => (await SendMessageToServerAsync("textContent").ConfigureAwait(false))?.GetProperty("value").ToString();
 
     public Task SelectTextAsync(ElementHandleSelectTextOptions options = default)
-        => _channel.SelectTextAsync(options?.Force, options?.Timeout);
+        => SendMessageToServerAsync<ElementHandleChannel>("selectText", new Dictionary<string, object>
+        {
+            ["force"] = options?.Force,
+            ["timeout"] = options?.Timeout,
+        });
 
     public Task<IReadOnlyList<string>> SelectOptionAsync(string value, ElementHandleSelectOptionOptions options = default)
-        => _channel.SelectOptionAsync(new[] { new SelectOptionValueProtocol() { ValueOrLabel = value } }, options?.NoWaitAfter, options?.Force, options?.Timeout);
+        => _selectOptionAsync(new[] { new SelectOptionValueProtocol() { ValueOrLabel = value } }, options?.NoWaitAfter, options?.Force, options?.Timeout);
 
     public Task<IReadOnlyList<string>> SelectOptionAsync(IElementHandle values, ElementHandleSelectOptionOptions options = default)
-        => _channel.SelectOptionAsync(new[] { values }, options?.NoWaitAfter, options?.Force, options?.Timeout);
+        => _selectOptionAsync(new[] { values }, options?.NoWaitAfter, options?.Force, options?.Timeout);
 
     public Task<IReadOnlyList<string>> SelectOptionAsync(IEnumerable<string> values, ElementHandleSelectOptionOptions options = default)
-        => _channel.SelectOptionAsync(values.Select(x => new SelectOptionValueProtocol() { ValueOrLabel = x }), options?.NoWaitAfter, options?.Force, options?.Timeout);
+        => _selectOptionAsync(values.Select(x => new SelectOptionValueProtocol() { ValueOrLabel = x }), options?.NoWaitAfter, options?.Force, options?.Timeout);
 
     public Task<IReadOnlyList<string>> SelectOptionAsync(SelectOptionValue values, ElementHandleSelectOptionOptions options = default)
-        => _channel.SelectOptionAsync(new[] { SelectOptionValueProtocol.From(values) }, options?.NoWaitAfter, options?.Force, options?.Timeout);
+        => _selectOptionAsync(new[] { SelectOptionValueProtocol.From(values) }, options?.NoWaitAfter, options?.Force, options?.Timeout);
 
     public Task<IReadOnlyList<string>> SelectOptionAsync(IEnumerable<IElementHandle> values, ElementHandleSelectOptionOptions options = default)
-        => _channel.SelectOptionAsync(values, options?.NoWaitAfter, options?.Force, options?.Timeout);
+        => _selectOptionAsync(values, options?.NoWaitAfter, options?.Force, options?.Timeout);
 
     public Task<IReadOnlyList<string>> SelectOptionAsync(IEnumerable<SelectOptionValue> values, ElementHandleSelectOptionOptions options = default)
-        => _channel.SelectOptionAsync(values.Select(v => SelectOptionValueProtocol.From(v)), options?.NoWaitAfter, options?.Force, options?.Timeout);
+        => _selectOptionAsync(values.Select(v => SelectOptionValueProtocol.From(v)), options?.NoWaitAfter, options?.Force, options?.Timeout);
+
+    private async Task<IReadOnlyList<string>> _selectOptionAsync(IEnumerable<SelectOptionValueProtocol> values, bool? noWaitAfter, bool? force, float? timeout)
+    {
+        return (await SendMessageToServerAsync("selectOption", new Dictionary<string, object>
+        {
+            ["options"] = values,
+            ["noWaitAfter"] = noWaitAfter,
+            ["force"] = force,
+            ["timeout"] = timeout,
+        }).ConfigureAwait(false))?.GetProperty("values").ToObject<string[]>();
+    }
+
+    private async Task<IReadOnlyList<string>> _selectOptionAsync(IEnumerable<IElementHandle> values, bool? noWaitAfter, bool? force, float? timeout)
+    {
+        return (await SendMessageToServerAsync("selectOption", new Dictionary<string, object>
+        {
+            ["elements"] = values,
+            ["noWaitAfter"] = noWaitAfter,
+            ["force"] = force,
+            ["timeout"] = timeout,
+        }).ConfigureAwait(false))?.GetProperty("values").ToObject<string[]>();
+    }
 
     public Task CheckAsync(ElementHandleCheckOptions options = default)
-        => _channel.CheckAsync(
-            position: options?.Position,
-            timeout: options?.Timeout,
-            force: options?.Force,
-            noWaitAfter: options?.NoWaitAfter,
-            trial: options?.Trial);
+        => SendMessageToServerAsync<ElementHandleChannel>("check", new Dictionary<string, object>
+        {
+            ["force"] = options?.Force,
+            ["position"] = options?.Position,
+            ["trial"] = options?.Trial,
+            ["timeout"] = options?.Timeout,
+            ["noWaitAfter"] = options?.NoWaitAfter,
+        });
 
     public Task UncheckAsync(ElementHandleUncheckOptions options = default)
-        => _channel.UncheckAsync(
-            position: options?.Position,
-            timeout: options?.Timeout,
-            force: options?.Force,
-            noWaitAfter: options?.NoWaitAfter,
-            trial: options?.Trial);
+        => SendMessageToServerAsync<ElementHandleChannel>("uncheck", new Dictionary<string, object>
+        {
+            ["force"] = options?.Force,
+            ["position"] = options?.Position,
+            ["trial"] = options?.Trial,
+            ["timeout"] = options?.Timeout,
+            ["noWaitAfter"] = options?.NoWaitAfter,
+        });
 
     public Task TapAsync(ElementHandleTapOptions options = default)
-        => _channel.TapAsync(
-            position: options?.Position,
-            modifiers: options?.Modifiers,
-            timeout: options?.Timeout,
-            force: options?.Force,
-            noWaitAfter: options?.NoWaitAfter,
-            trial: options?.Trial);
+        => SendMessageToServerAsync("tap", new Dictionary<string, object>
+        {
+            ["force"] = options?.Force,
+            ["noWaitAfter"] = options?.NoWaitAfter,
+            ["position"] = options?.Position,
+            ["modifiers"] = options?.Modifiers?.Select(m => m.ToValueString()),
+            ["trial"] = options?.Trial,
+            ["timeout"] = options?.Timeout,
+        });
 
-    public Task<bool> IsCheckedAsync() => _channel.IsCheckedAsync();
+    public async Task<bool> IsCheckedAsync() => (await SendMessageToServerAsync("isChecked").ConfigureAwait(false))?.GetProperty("value").GetBoolean() ?? default;
 
-    public Task<bool> IsDisabledAsync() => _channel.IsDisabledAsync();
+    public async Task<bool> IsDisabledAsync() => (await SendMessageToServerAsync("isDisabled").ConfigureAwait(false))?.GetProperty("value").GetBoolean() ?? default;
 
-    public Task<bool> IsEditableAsync() => _channel.IsEditableAsync();
+    public async Task<bool> IsEditableAsync() => (await SendMessageToServerAsync("isEditable").ConfigureAwait(false))?.GetProperty("value").GetBoolean() ?? default;
 
-    public Task<bool> IsEnabledAsync() => _channel.IsEnabledAsync();
+    public async Task<bool> IsEnabledAsync() => (await SendMessageToServerAsync("isEnabled").ConfigureAwait(false))?.GetProperty("value").GetBoolean() ?? default;
 
-    public Task<bool> IsHiddenAsync() => _channel.IsHiddenAsync();
+    public async Task<bool> IsHiddenAsync() => (await SendMessageToServerAsync("isHidden").ConfigureAwait(false))?.GetProperty("value").GetBoolean() ?? default;
 
-    public Task<bool> IsVisibleAsync() => _channel.IsVisibleAsync();
+    public async Task<bool> IsVisibleAsync() => (await SendMessageToServerAsync("isVisible").ConfigureAwait(false))?.GetProperty("value").GetBoolean() ?? default;
 
-    public Task<string> InputValueAsync(ElementHandleInputValueOptions options = null)
-        => _channel.InputValueAsync(options?.Timeout);
+    public async Task<string> InputValueAsync(ElementHandleInputValueOptions options = null)
+        => (await SendMessageToServerAsync("inputValue", new Dictionary<string, object>()
+            {
+                { "timeout", options?.Timeout },
+            }).ConfigureAwait(false))?.GetProperty("value").GetString();
 
     public Task SetCheckedAsync(bool checkedState, ElementHandleSetCheckedOptions options = null)
-            => checkedState
-            ? _channel.CheckAsync(
-                position: options?.Position,
-                timeout: options?.Timeout,
-                force: options?.Force,
-                noWaitAfter: options?.NoWaitAfter,
-                trial: options?.Trial)
-            : _channel.UncheckAsync(
-                position: options?.Position,
-                timeout: options?.Timeout,
-                force: options?.Force,
-                noWaitAfter: options?.NoWaitAfter,
-                trial: options?.Trial);
+        => SendMessageToServerAsync<ElementHandleChannel>(checkedState ? "check" : "uncheck", new Dictionary<string, object>
+        {
+            ["force"] = options?.Force,
+            ["position"] = options?.Position,
+            ["trial"] = options?.Trial,
+            ["timeout"] = options?.Timeout,
+            ["noWaitAfter"] = options?.NoWaitAfter,
+        });
 
     internal static ScreenshotType DetermineScreenshotType(string path)
     {
diff --git a/src/Playwright/Core/Frame.cs b/src/Playwright/Core/Frame.cs
index ae2aeab0df..bd7b4e698a 100644
--- a/src/Playwright/Core/Frame.cs
+++ b/src/Playwright/Core/Frame.cs
@@ -29,7 +29,9 @@
 using System.IO;
 using System.Linq;
 using System.Runtime.CompilerServices;
+
 using System.Text.Json;
+using System.Text.Json.Serialization;
 using System.Text.RegularExpressions;
 using System.Threading.Tasks;
 using Microsoft.Playwright.Helpers;
@@ -148,18 +150,23 @@ internal void OnNavigated(FrameNavigatedEventArgs e)
 
     [MethodImpl(MethodImplOptions.NoInlining)]
     public async Task<IElementHandle> FrameElementAsync()
-        => (await _channel.FrameElementAsync().ConfigureAwait(false)).Object;
+        => (await SendMessageToServerAsync<ElementHandleChannel>("frameElement").ConfigureAwait(false)).Object;
 
     [MethodImpl(MethodImplOptions.NoInlining)]
     public IFrameLocator FrameLocator(string selector)
         => new FrameLocator(this, selector);
 
     [MethodImpl(MethodImplOptions.NoInlining)]
-    public Task<string> TitleAsync() => _channel.TitleAsync();
+    public async Task<string> TitleAsync() => (await SendMessageToServerAsync("title").ConfigureAwait(false))?.GetProperty("value").ToString();
 
     [MethodImpl(MethodImplOptions.NoInlining)]
     public Task WaitForTimeoutAsync(float timeout)
-        => _channel.WaitForTimeoutAsync(timeout);
+        => SendMessageToServerAsync(
+            "waitForTimeout",
+            new Dictionary<string, object>
+            {
+                ["timeout"] = timeout,
+            });
 
     [MethodImpl(MethodImplOptions.NoInlining)]
     public Task<IReadOnlyList<string>> SelectOptionAsync(string selector, string values, FrameSelectOptionOptions options = default)
@@ -175,13 +182,15 @@ public Task<IReadOnlyList<string>> SelectOptionAsync(string selector, IElementHa
 
     [MethodImpl(MethodImplOptions.NoInlining)]
     public async Task<IReadOnlyList<string>> SelectOptionAsync(string selector, IEnumerable<IElementHandle> values, FrameSelectOptionOptions options = default)
-        => (await _channel.SelectOptionAsync(
-            selector,
-            values.Select(x => x as ElementHandle),
-            noWaitAfter: options?.NoWaitAfter,
-            strict: options?.Strict,
-            force: options?.Force,
-            timeout: options?.Timeout).ConfigureAwait(false)).ToList().AsReadOnly();
+        => (await SendMessageToServerAsync("selectOption", new Dictionary<string, object>
+        {
+            ["selector"] = selector,
+            ["elements"] = values.Select(x => x as ElementHandle),
+            ["noWaitAfter"] = options?.NoWaitAfter,
+            ["strict"] = options?.Strict,
+            ["force"] = options?.Force,
+            ["timeout"] = options?.Timeout,
+        }).ConfigureAwait(false))?.GetProperty("values").ToObject<string[]>().ToList().AsReadOnly();
 
     [MethodImpl(MethodImplOptions.NoInlining)]
     public Task<IReadOnlyList<string>> SelectOptionAsync(string selector, SelectOptionValue values, FrameSelectOptionOptions options = default)
@@ -192,13 +201,15 @@ public Task<IReadOnlyList<string>> SelectOptionAsync(string selector, IEnumerabl
         => SelectOptionAsync(selector, values.Select(value => SelectOptionValueProtocol.From(value)), options);
 
     internal async Task<IReadOnlyList<string>> SelectOptionAsync(string selector, IEnumerable<SelectOptionValueProtocol> values, FrameSelectOptionOptions options = default)
-        => (await _channel.SelectOptionAsync(
-            selector,
-            values,
-            noWaitAfter: options?.NoWaitAfter,
-            strict: options?.Strict,
-            force: options?.Force,
-            timeout: options?.Timeout).ConfigureAwait(false)).ToList().AsReadOnly();
+        => (await SendMessageToServerAsync("selectOption", new Dictionary<string, object>
+        {
+            ["selector"] = selector,
+            ["options"] = values,
+            ["noWaitAfter"] = options?.NoWaitAfter,
+            ["strict"] = options?.Strict,
+            ["force"] = options?.Force,
+            ["timeout"] = options?.Timeout,
+        }).ConfigureAwait(false))?.GetProperty("values").ToObject<string[]>().ToList().AsReadOnly();
 
     [MethodImpl(MethodImplOptions.NoInlining)]
     public async Task WaitForLoadStateAsync(LoadState? state = default, FrameWaitForLoadStateOptions options = default)
@@ -328,86 +339,143 @@ await waiter.WaitForEventAsync<WaitUntilState>(
 
     [MethodImpl(MethodImplOptions.NoInlining)]
     public Task TapAsync(string selector, FrameTapOptions options = default)
-        => _channel.TapAsync(
-            selector,
-            modifiers: options?.Modifiers,
-            position: options?.Position,
-            timeout: options?.Timeout,
-            force: options?.Force,
-            noWaitAfter: options?.NoWaitAfter,
-            trial: options?.Trial,
-            strict: options?.Strict);
+        => SendMessageToServerAsync("tap", new Dictionary<string, object>
+        {
+            ["selector"] = selector,
+            ["force"] = options?.Force,
+            ["modifiers"] = options?.Modifiers?.Select(m => m.ToValueString()),
+            ["noWaitAfter"] = options?.NoWaitAfter,
+            ["trial"] = options?.Trial,
+            ["timeout"] = options?.Timeout,
+            ["position"] = options?.Position,
+            ["strict"] = options?.Strict,
+        });
 
-    internal Task<int> QueryCountAsync(string selector)
-        => _channel.QueryCountAsync(selector);
+    internal async Task<int> QueryCountAsync(string selector)
+    {
+        var result = await SendMessageToServerAsync("queryCount", new Dictionary<string, object>
+        {
+            ["selector"] = selector,
+        }).ConfigureAwait(false);
+        return result.Value.GetProperty("value").GetInt32();
+    }
 
     [MethodImpl(MethodImplOptions.NoInlining)]
-    public Task<string> ContentAsync() => _channel.ContentAsync();
+    public async Task<string> ContentAsync()
+        => (await SendMessageToServerAsync("content").ConfigureAwait(false))?.GetProperty("value").ToString();
 
     [MethodImpl(MethodImplOptions.NoInlining)]
     public Task FocusAsync(string selector, FrameFocusOptions options = default)
-        => _channel.FocusAsync(selector, options?.Timeout, options?.Strict);
+        => SendMessageToServerAsync("focus", new Dictionary<string, object>
+        {
+            ["selector"] = selector,
+            ["timeout"] = options?.Timeout,
+            ["strict"] = options?.Strict,
+        });
 
     [MethodImpl(MethodImplOptions.NoInlining)]
     public Task TypeAsync(string selector, string text, FrameTypeOptions options = default)
-        => _channel.TypeAsync(
-            selector,
-            text,
-            delay: options?.Delay,
-            timeout: options?.Timeout,
-            noWaitAfter: options?.NoWaitAfter,
-            strict: options?.Strict);
+        => SendMessageToServerAsync("type", new Dictionary<string, object>
+        {
+            ["selector"] = selector,
+            ["text"] = text,
+            ["delay"] = options?.Delay,
+            ["noWaitAfter"] = options?.NoWaitAfter,
+            ["timeout"] = options?.Timeout,
+            ["strict"] = options?.Strict,
+        });
 
     [MethodImpl(MethodImplOptions.NoInlining)]
-    public Task<string> GetAttributeAsync(string selector, string name, FrameGetAttributeOptions options = default)
-        => _channel.GetAttributeAsync(selector, name, options?.Timeout, options?.Strict);
+    public async Task<string> GetAttributeAsync(string selector, string name, FrameGetAttributeOptions options = default)
+    {
+        if ((await SendMessageToServerAsync("getAttribute", new Dictionary<string, object>
+        {
+            ["selector"] = selector,
+            ["name"] = name,
+            ["timeout"] = options?.Timeout,
+            ["strict"] = options?.Strict,
+        }).ConfigureAwait(false))?.TryGetProperty("value", out JsonElement retValue) ?? false)
+        {
+            return retValue.ToString();
+        }
+        return null;
+    }
 
     [MethodImpl(MethodImplOptions.NoInlining)]
-    public Task<string> InnerHTMLAsync(string selector, FrameInnerHTMLOptions options = default)
-        => _channel.InnerHTMLAsync(selector, options?.Timeout, options?.Strict);
+    public async Task<string> InnerHTMLAsync(string selector, FrameInnerHTMLOptions options = default)
+        => (await SendMessageToServerAsync("innerHTML", new Dictionary<string, object>
+        {
+            ["selector"] = selector,
+            ["timeout"] = options?.Timeout,
+            ["strict"] = options?.Strict,
+        }).ConfigureAwait(false))?.GetProperty("value").ToString();
 
     [MethodImpl(MethodImplOptions.NoInlining)]
-    public Task<string> InnerTextAsync(string selector, FrameInnerTextOptions options = default)
-        => _channel.InnerTextAsync(selector, options?.Timeout, options?.Strict);
+    public async Task<string> InnerTextAsync(string selector, FrameInnerTextOptions options = default)
+        => (await SendMessageToServerAsync("innerText", new Dictionary<string, object>
+        {
+            ["selector"] = selector,
+            ["timeout"] = options?.Timeout,
+            ["strict"] = options?.Strict,
+        }).ConfigureAwait(false))?.GetProperty("value").ToString();
 
     [MethodImpl(MethodImplOptions.NoInlining)]
-    public Task<string> TextContentAsync(string selector, FrameTextContentOptions options = default)
-        => _channel.TextContentAsync(selector, options?.Timeout, options?.Strict);
+    public async Task<string> TextContentAsync(string selector, FrameTextContentOptions options = default)
+        => (await SendMessageToServerAsync("textContent", new Dictionary<string, object>
+        {
+            ["selector"] = selector,
+            ["timeout"] = options?.Timeout,
+            ["strict"] = options?.Strict,
+        }).ConfigureAwait(false))?.GetProperty("value").ToString();
 
     [MethodImpl(MethodImplOptions.NoInlining)]
     public Task HoverAsync(string selector, FrameHoverOptions options = default)
-        => _channel.HoverAsync(
-            selector,
-            position: options?.Position,
-            modifiers: options?.Modifiers,
-            force: options?.Force,
-            noWaitAfter: options?.NoWaitAfter,
-            timeout: options?.Timeout,
-            trial: options?.Trial,
-            strict: options?.Strict);
+        => SendMessageToServerAsync("hover", new Dictionary<string, object>
+        {
+            ["selector"] = selector,
+            ["force"] = options?.Force,
+            ["modifiers"] = options?.Modifiers?.Select(m => m.ToValueString()),
+            ["position"] = options?.Position,
+            ["trial"] = options?.Trial,
+            ["timeout"] = options?.Timeout,
+            ["strict"] = options?.Strict,
+            ["noWaitAfter"] = options?.NoWaitAfter,
+        });
 
     [MethodImpl(MethodImplOptions.NoInlining)]
     public Task PressAsync(string selector, string key, FramePressOptions options = default)
-        => _channel.PressAsync(
-            selector,
-            key,
-            delay: options?.Delay,
-            timeout: options?.Timeout,
-            noWaitAfter: options?.NoWaitAfter,
-            strict: options?.Strict);
+        => SendMessageToServerAsync("press", new Dictionary<string, object>
+        {
+            ["selector"] = selector,
+            ["key"] = key,
+            ["delay"] = options?.Delay,
+            ["timeout"] = options?.Timeout,
+            ["noWaitAfter"] = options?.NoWaitAfter,
+            ["strict"] = options?.Strict,
+        });
 
     [MethodImpl(MethodImplOptions.NoInlining)]
     public Task DispatchEventAsync(string selector, string type, object eventInit = default, FrameDispatchEventOptions options = default)
-        => _channel.DispatchEventAsync(
-                selector,
-                type,
-                ScriptsHelper.SerializedArgument(eventInit),
-                options?.Timeout,
-                options?.Strict);
+        => SendMessageToServerAsync("dispatchEvent", new Dictionary<string, object>
+        {
+            ["selector"] = selector,
+            ["type"] = type,
+            ["eventInit"] = ScriptsHelper.SerializedArgument(eventInit),
+            ["timeout"] = options?.Timeout,
+            ["strict"] = options?.Strict,
+        });
 
     [MethodImpl(MethodImplOptions.NoInlining)]
     public Task FillAsync(string selector, string value, FrameFillOptions options = default)
-        => _channel.FillAsync(selector, value, force: options?.Force, timeout: options?.Timeout, noWaitAfter: options?.NoWaitAfter, options?.Strict);
+        => SendMessageToServerAsync("fill", new Dictionary<string, object>
+        {
+            ["selector"] = selector,
+            ["value"] = value,
+            ["force"] = options?.Force,
+            ["timeout"] = options?.Timeout,
+            ["noWaitAfter"] = options?.NoWaitAfter,
+            ["strict"] = options?.Strict,
+        });
 
     [MethodImpl(MethodImplOptions.NoInlining)]
     public async Task<IElementHandle> AddScriptTagAsync(FrameAddScriptTagOptions options = default)
@@ -419,7 +487,13 @@ public async Task<IElementHandle> AddScriptTagAsync(FrameAddScriptTagOptions opt
             content += "//# sourceURL=" + options.Path.Replace("\n", string.Empty);
         }
 
-        return (await _channel.AddScriptTagAsync(options?.Url, options?.Path, content, options?.Type).ConfigureAwait(false)).Object;
+        return (await SendMessageToServerAsync<ElementHandleChannel>("addScriptTag", new Dictionary<string, object>
+        {
+            ["url"] = options?.Url,
+            ["path"] = options?.Path,
+            ["content"] = content,
+            ["type"] = options?.Type,
+        }).ConfigureAwait(false)).Object;
     }
 
     [MethodImpl(MethodImplOptions.NoInlining)]
@@ -432,7 +506,12 @@ public async Task<IElementHandle> AddStyleTagAsync(FrameAddStyleTagOptions optio
             content += "//# sourceURL=" + options.Path.Replace("\n", string.Empty);
         }
 
-        return (await _channel.AddStyleTagAsync(options?.Url, options?.Path, content).ConfigureAwait(false)).Object;
+        return (await SendMessageToServerAsync<ElementHandleChannel>("addStyleTag", new Dictionary<string, object>
+        {
+            ["url"] = options?.Url,
+            ["path"] = options?.Path,
+            ["content"] = content,
+        }).ConfigureAwait(false)).Object;
     }
 
     [MethodImpl(MethodImplOptions.NoInlining)]
@@ -443,7 +522,7 @@ public Task SetInputFilesAsync(string selector, string files, FrameSetInputFiles
     public async Task SetInputFilesAsync(string selector, IEnumerable<string> files, FrameSetInputFilesOptions options = default)
     {
         var converted = await SetInputFilesHelpers.ConvertInputFilesAsync(files, (BrowserContext)Page.Context).ConfigureAwait(false);
-        await _channel.SetInputFilesAsync(selector, converted, options?.NoWaitAfter, options?.Timeout, options?.Strict).ConfigureAwait(false);
+        await _setInputFilesAsync(selector, converted, options?.NoWaitAfter, options?.Timeout, options?.Strict).ConfigureAwait(false);
     }
 
     [MethodImpl(MethodImplOptions.NoInlining)]
@@ -454,134 +533,187 @@ public Task SetInputFilesAsync(string selector, FilePayload files, FrameSetInput
     public async Task SetInputFilesAsync(string selector, IEnumerable<FilePayload> files, FrameSetInputFilesOptions options = default)
     {
         var converted = SetInputFilesHelpers.ConvertInputFiles(files);
-        await _channel.SetInputFilesAsync(selector, converted, noWaitAfter: options?.NoWaitAfter, timeout: options?.Timeout, options?.Strict).ConfigureAwait(false);
+        await _setInputFilesAsync(selector, converted, noWaitAfter: options?.NoWaitAfter, timeout: options?.Timeout, options?.Strict).ConfigureAwait(false);
+    }
+
+    private Task _setInputFilesAsync(string selector, SetInputFilesFiles files, bool? noWaitAfter, float? timeout, bool? strict)
+    {
+        return SendMessageToServerAsync("setInputFiles", new Dictionary<string, object>
+        {
+            ["selector"] = selector,
+            ["payloads"] = files.Payloads,
+            ["localPaths"] = files.LocalPaths,
+            ["streams"] = files.Streams,
+            ["noWaitAfter"] = noWaitAfter,
+            ["timeout"] = timeout,
+            ["strict"] = strict,
+        });
     }
 
     [MethodImpl(MethodImplOptions.NoInlining)]
     public Task ClickAsync(string selector, FrameClickOptions options = default)
-        => _channel.ClickAsync(
-            selector,
-            delay: options?.Delay,
-            button: options?.Button,
-            clickCount: options?.ClickCount,
-            modifiers: options?.Modifiers,
-            position: options?.Position,
-            timeout: options?.Timeout,
-            force: options?.Force,
-            noWaitAfter: options?.NoWaitAfter,
-            trial: options?.Trial,
-            strict: options?.Strict);
+        => SendMessageToServerAsync("click", new Dictionary<string, object>
+        {
+            ["selector"] = selector,
+            ["button"] = options?.Button,
+            ["force"] = options?.Force,
+            ["delay"] = options?.Delay,
+            ["clickCount"] = options?.ClickCount,
+            ["modifiers"] = options?.Modifiers?.Select(m => m.ToValueString()),
+            ["position"] = options?.Position,
+            ["noWaitAfter"] = options?.NoWaitAfter,
+            ["trial"] = options?.Trial,
+            ["timeout"] = options?.Timeout,
+            ["strict"] = options?.Strict,
+        });
 
     [MethodImpl(MethodImplOptions.NoInlining)]
     public Task DblClickAsync(string selector, FrameDblClickOptions options = default)
-        => _channel.DblClickAsync(
-            selector,
-            delay: options?.Delay,
-            button: options?.Button,
-            position: options?.Position,
-            modifiers: options?.Modifiers,
-            timeout: options?.Timeout,
-            force: options?.Force,
-            noWaitAfter: options?.NoWaitAfter,
-            trial: options?.Trial,
-            strict: options?.Strict);
+        => SendMessageToServerAsync("dblclick", new Dictionary<string, object>
+        {
+            ["selector"] = selector,
+            ["button"] = options?.Button,
+            ["delay"] = options?.Delay,
+            ["force"] = options?.Force,
+            ["modifiers"] = options?.Modifiers?.Select(m => m.ToValueString()),
+            ["position"] = options?.Position,
+            ["trial"] = options?.Trial,
+            ["timeout"] = options?.Timeout,
+            ["noWaitAfter"] = options?.NoWaitAfter,
+            ["strict"] = options?.Strict,
+        });
 
     [MethodImpl(MethodImplOptions.NoInlining)]
     public Task CheckAsync(string selector, FrameCheckOptions options = default)
-        => _channel.CheckAsync(
-            selector,
-            position: options?.Position,
-            timeout: options?.Timeout,
-            force: options?.Force,
-            noWaitAfter: options?.NoWaitAfter,
-            trial: options?.Trial,
-            strict: options?.Strict);
+        => SendMessageToServerAsync("check", new Dictionary<string, object>
+        {
+            ["selector"] = selector,
+            ["force"] = options?.Force,
+            ["position"] = options?.Position,
+            ["noWaitAfter"] = options?.NoWaitAfter,
+            ["trial"] = options?.Trial,
+            ["timeout"] = options?.Timeout,
+            ["strict"] = options?.Strict,
+        });
 
     [MethodImpl(MethodImplOptions.NoInlining)]
     public Task UncheckAsync(string selector, FrameUncheckOptions options = default)
-        => _channel.UncheckAsync(
-            selector,
-            position: options?.Position,
-            timeout: options?.Timeout,
-            force: options?.Force,
-            noWaitAfter: options?.NoWaitAfter,
-            trial: options?.Trial,
-            strict: options?.Strict);
+        => SendMessageToServerAsync("uncheck", new Dictionary<string, object>
+        {
+            ["selector"] = selector,
+            ["force"] = options?.Force,
+            ["position"] = options?.Position,
+            ["noWaitAfter"] = options?.NoWaitAfter,
+            ["trial"] = options?.Trial,
+            ["timeout"] = options?.Timeout,
+            ["strict"] = options?.Strict,
+        });
 
     [MethodImpl(MethodImplOptions.NoInlining)]
     public Task SetCheckedAsync(string selector, bool checkedState, FrameSetCheckedOptions options = null)
-        => checkedState ?
-        _channel.CheckAsync(
-            selector,
-            position: options?.Position,
-            timeout: options?.Timeout,
-            force: options?.Force,
-            noWaitAfter: options?.NoWaitAfter,
-            trial: options?.Trial,
-            strict: options?.Strict)
-        : _channel.UncheckAsync(
-            selector,
-            position: options?.Position,
-            timeout: options?.Timeout,
-            force: options?.Force,
-            noWaitAfter: options?.NoWaitAfter,
-            trial: options?.Trial,
-            strict: options?.Strict);
+        => SendMessageToServerAsync(checkedState ? "check" : "uncheck", new Dictionary<string, object>
+        {
+            ["selector"] = selector,
+            ["force"] = options?.Force,
+            ["position"] = options?.Position,
+            ["noWaitAfter"] = options?.NoWaitAfter,
+            ["trial"] = options?.Trial,
+            ["timeout"] = options?.Timeout,
+            ["strict"] = options?.Strict,
+        });
 
     [MethodImpl(MethodImplOptions.NoInlining)]
     public Task SetContentAsync(string html, FrameSetContentOptions options = default)
-        => _channel.SetContentAsync(html, timeout: options?.Timeout, waitUntil: options?.WaitUntil);
+        => SendMessageToServerAsync("setContent", new Dictionary<string, object>
+        {
+            ["html"] = html,
+            ["waitUntil"] = options?.WaitUntil,
+            ["timeout"] = options?.Timeout,
+        });
 
     [MethodImpl(MethodImplOptions.NoInlining)]
-    public Task<string> InputValueAsync(string selector, FrameInputValueOptions options = null)
-        => _channel.InputValueAsync(selector, options?.Timeout, options?.Strict);
+    public async Task<string> InputValueAsync(string selector, FrameInputValueOptions options = null)
+        => (await SendMessageToServerAsync("inputValue", new Dictionary<string, object>
+        {
+            ["selector"] = selector,
+            ["timeout"] = options?.Timeout,
+            ["strict"] = options?.Strict,
+        }).ConfigureAwait(false))?.GetProperty("value").ToString();
 
     [MethodImpl(MethodImplOptions.NoInlining)]
     public async Task<IElementHandle> QuerySelectorAsync(string selector)
-        => (await _channel.QuerySelectorAsync(selector).ConfigureAwait(false))?.Object;
+        => (await SendMessageToServerAsync<ElementHandleChannel>("querySelector", new Dictionary<string, object>
+        {
+            ["selector"] = selector,
+        }).ConfigureAwait(false))?.Object;
 
     [MethodImpl(MethodImplOptions.NoInlining)]
     public async Task<IReadOnlyList<IElementHandle>> QuerySelectorAllAsync(string selector)
-        => (await _channel.QuerySelectorAllAsync(selector).ConfigureAwait(false)).Select(c => ((ElementHandleChannel)c).Object).ToList().AsReadOnly();
+        => (await SendMessageToServerAsync<ChannelBase[]>(
+            "querySelectorAll",
+            new Dictionary<string, object>
+            {
+                ["selector"] = selector,
+            }).ConfigureAwait(false)).Select(c => ((ElementHandleChannel)c).Object).ToList().AsReadOnly();
 
     [MethodImpl(MethodImplOptions.NoInlining)]
     public async Task<IJSHandle> WaitForFunctionAsync(string expression, object arg = default, FrameWaitForFunctionOptions options = default)
-         => (await _channel.WaitForFunctionAsync(
-            expression: expression,
-            arg: ScriptsHelper.SerializedArgument(arg),
-            timeout: options?.Timeout,
-            polling: options?.PollingInterval).ConfigureAwait(false)).Object;
+         => (await SendMessageToServerAsync<JSHandleChannel>(
+            "waitForFunction",
+            new Dictionary<string, object>
+            {
+                ["expression"] = expression,
+                ["arg"] = ScriptsHelper.SerializedArgument(arg),
+                ["timeout"] = options?.Timeout,
+                ["pollingInterval"] = options?.PollingInterval,
+            }).ConfigureAwait(false)).Object;
 
     [MethodImpl(MethodImplOptions.NoInlining)]
     public async Task<IElementHandle> WaitForSelectorAsync(string selector, FrameWaitForSelectorOptions options = default)
-        => (await _channel.WaitForSelectorAsync(
-            selector: selector,
-            state: options?.State,
-            timeout: options?.Timeout,
-            strict: options?.Strict,
-            omitReturnValue: false).ConfigureAwait(false))?.Object;
+       => (await SendMessageToServerAsync<ElementHandleChannel>(
+            "waitForSelector",
+            new Dictionary<string, object>
+            {
+                ["selector"] = selector,
+                ["timeout"] = options?.Timeout,
+                ["state"] = options?.State,
+                ["strict"] = options?.Strict,
+                ["omitReturnValue"] = false,
+            }).ConfigureAwait(false))?.Object;
 
     [MethodImpl(MethodImplOptions.NoInlining)]
     public async Task<IJSHandle> EvaluateHandleAsync(string script, object args = null)
-        => (await _channel.EvaluateExpressionHandleAsync(
-            script,
-            arg: ScriptsHelper.SerializedArgument(args)).ConfigureAwait(false))?.Object;
+        => (await SendMessageToServerAsync<JSHandleChannel>(
+            "evaluateExpressionHandle",
+            new Dictionary<string, object>
+            {
+                ["expression"] = script,
+                ["arg"] = ScriptsHelper.SerializedArgument(args),
+            }).ConfigureAwait(false))?.Object;
 
     [MethodImpl(MethodImplOptions.NoInlining)]
     public async Task<JsonElement?> EvaluateAsync(string script, object arg = null)
-        => ScriptsHelper.ParseEvaluateResult<JsonElement?>(await _channel.EvaluateExpressionAsync(
-            script,
-            arg: ScriptsHelper.SerializedArgument(arg)).ConfigureAwait(false));
+        => ScriptsHelper.ParseEvaluateResult<JsonElement?>(await SendMessageToServerAsync<JsonElement?>(
+            "evaluateExpression",
+            new Dictionary<string, object>
+            {
+                ["expression"] = script,
+                ["arg"] = ScriptsHelper.SerializedArgument(arg),
+            }).ConfigureAwait(false));
 
     [MethodImpl(MethodImplOptions.NoInlining)]
     public async Task<T> EvaluateAsync<T>(string script, object arg = null)
-        => ScriptsHelper.ParseEvaluateResult<T>(await _channel.EvaluateExpressionAsync(
-            script,
-            arg: ScriptsHelper.SerializedArgument(arg)).ConfigureAwait(false));
+        => ScriptsHelper.ParseEvaluateResult<T>(await SendMessageToServerAsync<JsonElement?>(
+            "evaluateExpression",
+            new Dictionary<string, object>
+            {
+                ["expression"] = script,
+                ["arg"] = ScriptsHelper.SerializedArgument(arg),
+            }).ConfigureAwait(false));
 
     [MethodImpl(MethodImplOptions.NoInlining)]
     public async Task<JsonElement?> EvalOnSelectorAsync(string selector, string script, object arg = null)
-        => ScriptsHelper.ParseEvaluateResult<JsonElement?>(await _channel.EvalOnSelectorAsync(
+        => ScriptsHelper.ParseEvaluateResult<JsonElement?>(await _evalOnSelectorAsync(
             selector: selector,
             script,
             arg: ScriptsHelper.SerializedArgument(arg),
@@ -589,7 +721,7 @@ public async Task<T> EvaluateAsync<T>(string script, object arg = null)
 
     [MethodImpl(MethodImplOptions.NoInlining)]
     public async Task<T> EvalOnSelectorAsync<T>(string selector, string script, object arg = null)
-        => ScriptsHelper.ParseEvaluateResult<T>(await _channel.EvalOnSelectorAsync(
+        => ScriptsHelper.ParseEvaluateResult<T>(await _evalOnSelectorAsync(
             selector: selector,
             script,
             arg: ScriptsHelper.SerializedArgument(arg),
@@ -597,26 +729,47 @@ public async Task<T> EvalOnSelectorAsync<T>(string selector, string script, obje
 
     [MethodImpl(MethodImplOptions.NoInlining)]
     public async Task<T> EvalOnSelectorAsync<T>(string selector, string expression, object arg = null, FrameEvalOnSelectorOptions options = null)
-        => ScriptsHelper.ParseEvaluateResult<T>(await _channel.EvalOnSelectorAsync(
+        => ScriptsHelper.ParseEvaluateResult<T>(await _evalOnSelectorAsync(
             selector: selector,
             expression,
             arg: ScriptsHelper.SerializedArgument(arg),
             strict: options?.Strict).ConfigureAwait(false));
 
+    private Task<JsonElement?> _evalOnSelectorAsync(string selector, string script, object arg, bool? strict)
+        => SendMessageToServerAsync<JsonElement?>(
+            "evalOnSelector",
+            new Dictionary<string, object>
+            {
+                ["selector"] = selector,
+                ["expression"] = script,
+                ["arg"] = arg,
+                ["strict"] = strict,
+            });
+
     [MethodImpl(MethodImplOptions.NoInlining)]
     public async Task<JsonElement?> EvalOnSelectorAllAsync(string selector, string script, object arg = null)
-        => ScriptsHelper.ParseEvaluateResult<JsonElement?>(await _channel.EvalOnSelectorAllAsync(
+        => ScriptsHelper.ParseEvaluateResult<JsonElement?>(await _evalOnSelectorAllAsync(
             selector: selector,
             script,
             arg: ScriptsHelper.SerializedArgument(arg)).ConfigureAwait(false));
 
     [MethodImpl(MethodImplOptions.NoInlining)]
     public async Task<T> EvalOnSelectorAllAsync<T>(string selector, string script, object arg = null)
-        => ScriptsHelper.ParseEvaluateResult<T>(await _channel.EvalOnSelectorAllAsync(
+        => ScriptsHelper.ParseEvaluateResult<T>(await _evalOnSelectorAllAsync(
             selector: selector,
             script,
             arg: ScriptsHelper.SerializedArgument(arg)).ConfigureAwait(false));
 
+    private Task<JsonElement?> _evalOnSelectorAllAsync(string selector, string script, object arg)
+        => SendMessageToServerAsync<JsonElement?>(
+            "evalOnSelectorAll",
+            new Dictionary<string, object>
+            {
+                ["selector"] = selector,
+                ["expression"] = script,
+                ["arg"] = arg,
+            });
+
     [MethodImpl(MethodImplOptions.NoInlining)]
     public ILocator Locator(string selector, FrameLocatorOptions options = null) =>
         new Locator(this, selector, new()
@@ -633,40 +786,78 @@ public ILocator Locator(string selector, FrameLocatorOptions options = null) =>
 
     [MethodImpl(MethodImplOptions.NoInlining)]
     public async Task<IElementHandle> QuerySelectorAsync(string selector, FrameQuerySelectorOptions options = null)
-        => (await _channel.QuerySelectorAsync(selector, options?.Strict).ConfigureAwait(false))?.Object;
+        => (await SendMessageToServerAsync<ElementHandleChannel>(
+            "querySelector",
+            new Dictionary<string, object>
+            {
+                ["selector"] = selector,
+                ["strict"] = options?.Strict,
+            }).ConfigureAwait(false))?.Object;
 
     [MethodImpl(MethodImplOptions.NoInlining)]
     public async Task<IResponse> GotoAsync(string url, FrameGotoOptions options = default)
-        => (await _channel.GotoAsync(
-            url,
-            timeout: options?.Timeout,
-            waitUntil: options?.WaitUntil,
-            referer: options?.Referer).ConfigureAwait(false))?.Object;
+        => (await SendMessageToServerAsync<ResponseChannel>("goto", new Dictionary<string, object>
+        {
+            ["url"] = url,
+            ["timeout"] = options?.Timeout,
+            ["waitUntil"] = options?.WaitUntil,
+            ["referer"] = options?.Referer,
+        }).ConfigureAwait(false))?.Object;
 
     [MethodImpl(MethodImplOptions.NoInlining)]
-    public Task<bool> IsCheckedAsync(string selector, FrameIsCheckedOptions options = default)
-        => _channel.IsCheckedAsync(selector, timeout: options?.Timeout, options?.Strict);
+    public async Task<bool> IsCheckedAsync(string selector, FrameIsCheckedOptions options = default)
+        => (await SendMessageToServerAsync("isChecked", new Dictionary<string, object>
+        {
+            ["selector"] = selector,
+            ["timeout"] = options?.Timeout,
+            ["strict"] = options?.Strict,
+        }).ConfigureAwait(false))?.GetProperty("value").GetBoolean() ?? default;
 
     [MethodImpl(MethodImplOptions.NoInlining)]
-    public Task<bool> IsDisabledAsync(string selector, FrameIsDisabledOptions options = default)
-        => _channel.IsDisabledAsync(selector, timeout: options?.Timeout, options?.Strict);
+    public async Task<bool> IsDisabledAsync(string selector, FrameIsDisabledOptions options = default)
+        => (await SendMessageToServerAsync("isDisabled", new Dictionary<string, object>
+        {
+            ["selector"] = selector,
+            ["timeout"] = options?.Timeout,
+            ["strict"] = options?.Strict,
+        }).ConfigureAwait(false))?.GetProperty("value").GetBoolean() ?? default;
 
     [MethodImpl(MethodImplOptions.NoInlining)]
-    public Task<bool> IsEditableAsync(string selector, FrameIsEditableOptions options = default)
-        => _channel.IsEditableAsync(selector, timeout: options?.Timeout, options?.Strict);
+    public async Task<bool> IsEditableAsync(string selector, FrameIsEditableOptions options = default)
+        => (await SendMessageToServerAsync("isEditable", new Dictionary<string, object>
+        {
+            ["selector"] = selector,
+            ["timeout"] = options?.Timeout,
+            ["strict"] = options?.Strict,
+        }).ConfigureAwait(false))?.GetProperty("value").GetBoolean() ?? default;
 
     [MethodImpl(MethodImplOptions.NoInlining)]
-    public Task<bool> IsEnabledAsync(string selector, FrameIsEnabledOptions options = default)
-        => _channel.IsEnabledAsync(selector, timeout: options?.Timeout, options?.Strict);
+    public async Task<bool> IsEnabledAsync(string selector, FrameIsEnabledOptions options = default)
+        => (await SendMessageToServerAsync("isEnabled", new Dictionary<string, object>
+        {
+            ["selector"] = selector,
+            ["timeout"] = options?.Timeout,
+            ["strict"] = options?.Strict,
+        }).ConfigureAwait(false))?.GetProperty("value").GetBoolean() ?? default;
 
 #pragma warning disable CS0612 // Type or member is obsolete
     [MethodImpl(MethodImplOptions.NoInlining)]
-    public Task<bool> IsHiddenAsync(string selector, FrameIsHiddenOptions options = default)
-        => _channel.IsHiddenAsync(selector, timeout: options?.Timeout, options?.Strict);
+    public async Task<bool> IsHiddenAsync(string selector, FrameIsHiddenOptions options = default)
+        => (await SendMessageToServerAsync("isHidden", new Dictionary<string, object>
+        {
+            ["selector"] = selector,
+            ["timeout"] = options?.Timeout,
+            ["strict"] = options?.Strict,
+        }).ConfigureAwait(false))?.GetProperty("value").GetBoolean() ?? default;
 
     [MethodImpl(MethodImplOptions.NoInlining)]
-    public Task<bool> IsVisibleAsync(string selector, FrameIsVisibleOptions options = default)
-        => _channel.IsVisibleAsync(selector, timeout: options?.Timeout, options?.Strict);
+    public async Task<bool> IsVisibleAsync(string selector, FrameIsVisibleOptions options = default)
+        => (await SendMessageToServerAsync("isVisible", new Dictionary<string, object>
+        {
+            ["selector"] = selector,
+            ["timeout"] = options?.Timeout,
+            ["strict"] = options?.Strict,
+        }).ConfigureAwait(false))?.GetProperty("value").GetBoolean() ?? default;
 #pragma warning restore CS0612 // Type or member is obsolete
 
     [MethodImpl(MethodImplOptions.NoInlining)]
@@ -683,10 +874,40 @@ public Task WaitForURLAsync(Func<string, bool> url, FrameWaitForURLOptions optio
 
     [MethodImpl(MethodImplOptions.NoInlining)]
     public Task DragAndDropAsync(string source, string target, FrameDragAndDropOptions options = null)
-        => _channel.DragAndDropAsync(source, target, options?.Force, options?.NoWaitAfter, options?.Timeout, options?.Trial, options?.Strict, options?.SourcePosition, options?.TargetPosition);
+        => SendMessageToServerAsync("dragAndDrop", new Dictionary<string, object>
+        {
+            ["source"] = source,
+            ["target"] = target,
+            ["force"] = options?.Force,
+            ["noWaitAfter"] = options?.NoWaitAfter,
+            ["timeout"] = options?.Timeout,
+            ["trial"] = options?.Trial,
+            ["strict"] = options?.Strict,
+            ["sourcePosition"] = options?.SourcePosition,
+            ["targetPosition"] = options?.TargetPosition,
+        });
 
-    internal Task<FrameExpectResult> ExpectAsync(string selector, string expression, FrameExpectOptions options = null) =>
-        _channel.ExpectAsync(selector, expression, expressionArg: options?.ExpressionArg, expectedText: options?.ExpectedText, expectedNumber: options?.ExpectedNumber, expectedValue: options?.ExpectedValue, useInnerText: options?.UseInnerText, isNot: options?.IsNot, timeout: options?.Timeout);
+    internal async Task<FrameExpectResult> ExpectAsync(string selector, string expression, FrameExpectOptions options = null)
+    {
+        var result = await SendMessageToServerAsync("expect", new Dictionary<string, object>
+        {
+            ["selector"] = selector,
+            ["expression"] = expression,
+            ["expressionArg"] = options?.ExpressionArg,
+            ["expectedText"] = options?.ExpectedText,
+            ["expectedNumber"] = options?.ExpectedNumber,
+            ["expectedValue"] = options?.ExpectedValue,
+            ["useInnerText"] = options?.UseInnerText,
+            ["isNot"] = options?.IsNot,
+            ["timeout"] = options?.Timeout,
+        }).ConfigureAwait(false);
+        var parsed = result.Value.ToObject<FrameExpectResult>();
+        if (result.Value.TryGetProperty("received", out var received))
+        {
+            parsed.Received = ScriptsHelper.ParseEvaluateResult<object>(received);
+        }
+        return parsed;
+    }
 
     private Task WaitForURLAsync(string urlString, Regex urlRegex, Func<string, bool> urlFunc, FrameWaitForURLOptions options = default)
     {
@@ -770,7 +991,10 @@ private bool UrlMatches(string url, string matchUrl, Regex regex, Func<string, b
     }
 
     internal Task HighlightAsync(string selector)
-        => _channel.HighlightAsync(selector);
+        => SendMessageToServerAsync("highlight", new Dictionary<string, object>
+        {
+            ["selector"] = selector,
+        });
 
     [MethodImpl(MethodImplOptions.NoInlining)]
     public ILocator GetByAltText(string text, FrameGetByAltTextOptions options = null)
@@ -824,3 +1048,31 @@ public ILocator GetByTitle(string text, FrameGetByTitleOptions options = null)
     public ILocator GetByTitle(Regex text, FrameGetByTitleOptions options = null)
         => Locator(Core.Locator.GetByTitleSelector(text, options?.Exact));
 }
+
+internal class SelectOptionValueProtocol
+{
+
+#nullable enable
+    [JsonPropertyName("value")]
+    public string? Value { get; set; }
+
+    [JsonPropertyName("valueOrLabel")]
+    public string? ValueOrLabel { get; set; }
+
+    [JsonPropertyName("label")]
+    public string? Label { get; set; }
+
+    [JsonPropertyName("index")]
+    public int? Index { get; set; }
+#nullable disable
+
+    internal static SelectOptionValueProtocol From(SelectOptionValue value)
+    {
+        return new SelectOptionValueProtocol
+        {
+            Value = value.Value,
+            Label = value.Label,
+            Index = value.Index,
+        };
+    }
+}
diff --git a/src/Playwright/Core/JSHandle.cs b/src/Playwright/Core/JSHandle.cs
index 12b4b883a3..ddbca1a245 100644
--- a/src/Playwright/Core/JSHandle.cs
+++ b/src/Playwright/Core/JSHandle.cs
@@ -26,6 +26,7 @@
 using System.Runtime.CompilerServices;
 using System.Text.Json;
 using System.Threading.Tasks;
+using Microsoft.Playwright.Helpers;
 using Microsoft.Playwright.Transport;
 using Microsoft.Playwright.Transport.Channels;
 using Microsoft.Playwright.Transport.Protocol;
@@ -53,33 +54,51 @@ internal JSHandle(IChannelOwner parent, string guid, JSHandleInitializer initial
 
     [MethodImpl(MethodImplOptions.NoInlining)]
     public async Task<JsonElement?> EvaluateAsync(string expression, object arg = null)
-        => ScriptsHelper.ParseEvaluateResult<JsonElement?>(await _channel.EvaluateExpressionAsync(
-            script: expression,
-            arg: ScriptsHelper.SerializedArgument(arg)).ConfigureAwait(false));
+        => ScriptsHelper.ParseEvaluateResult<JsonElement?>(await SendMessageToServerAsync<JsonElement?>(
+            "evaluateExpression",
+            new Dictionary<string, object>
+            {
+                ["expression"] = expression,
+                ["arg"] = ScriptsHelper.SerializedArgument(arg),
+            }).ConfigureAwait(false));
 
     [MethodImpl(MethodImplOptions.NoInlining)]
     public async Task<IJSHandle> EvaluateHandleAsync(string expression, object arg = null)
-        => (await _channel.EvaluateExpressionHandleAsync(
-            script: expression,
-            arg: ScriptsHelper.SerializedArgument(arg)).ConfigureAwait(false))?.Object;
+        => (await SendMessageToServerAsync<JSHandleChannel>(
+            "evaluateExpressionHandle",
+            new Dictionary<string, object>
+            {
+                ["expression"] = expression,
+                ["arg"] = ScriptsHelper.SerializedArgument(arg),
+            }).ConfigureAwait(false))?.Object;
 
     [MethodImpl(MethodImplOptions.NoInlining)]
     public async Task<T> EvaluateAsync<T>(string expression, object arg = null)
-        => ScriptsHelper.ParseEvaluateResult<T>(await _channel.EvaluateExpressionAsync(
-            script: expression,
-            arg: ScriptsHelper.SerializedArgument(arg)).ConfigureAwait(false));
+        => ScriptsHelper.ParseEvaluateResult<T>(await SendMessageToServerAsync<JsonElement?>(
+            "evaluateExpression",
+            new Dictionary<string, object>
+            {
+                ["expression"] = expression,
+                ["arg"] = ScriptsHelper.SerializedArgument(arg),
+            }).ConfigureAwait(false));
 
     [MethodImpl(MethodImplOptions.NoInlining)]
-    public async Task<T> JsonValueAsync<T>() => ScriptsHelper.ParseEvaluateResult<T>(await _channel.JsonValueAsync().ConfigureAwait(false));
+    public async Task<T> JsonValueAsync<T>() => ScriptsHelper.ParseEvaluateResult<T>(await SendMessageToServerAsync<JsonElement>("jsonValue").ConfigureAwait(false));
 
     [MethodImpl(MethodImplOptions.NoInlining)]
-    public async Task<IJSHandle> GetPropertyAsync(string propertyName) => (await _channel.GetPropertyAsync(propertyName).ConfigureAwait(false))?.Object;
+    public async Task<IJSHandle> GetPropertyAsync(string propertyName) => (await SendMessageToServerAsync<JSHandleChannel>(
+            "getProperty",
+            new Dictionary<string, object>
+            {
+                ["name"] = propertyName,
+            }).ConfigureAwait(false))?.Object;
 
     [MethodImpl(MethodImplOptions.NoInlining)]
     public async Task<Dictionary<string, IJSHandle>> GetPropertiesAsync()
     {
         var result = new Dictionary<string, IJSHandle>();
-        var channelResult = await _channel.GetPropertiesAsync().ConfigureAwait(false);
+        var channelResult = (await SendMessageToServerAsync("getPropertyList").ConfigureAwait(false))?
+            .GetProperty("properties").ToObject<List<JSElementProperty>>(_connection.DefaultJsonSerializerOptions);
 
         foreach (var kv in channelResult)
         {
@@ -90,7 +109,14 @@ public async Task<Dictionary<string, IJSHandle>> GetPropertiesAsync()
     }
 
     [MethodImpl(MethodImplOptions.NoInlining)]
-    public async ValueTask DisposeAsync() => await _channel.DisposeAsync().ConfigureAwait(false);
+    public async ValueTask DisposeAsync() => await SendMessageToServerAsync("dispose").ConfigureAwait(false);
 
     public override string ToString() => Preview;
 }
+
+internal class JSElementProperty
+{
+    public string Name { get; set; }
+
+    public JSHandleChannel Value { get; set; }
+}
diff --git a/src/Playwright/Core/JsonPipe.cs b/src/Playwright/Core/JsonPipe.cs
index 2803634472..0ae32d71e9 100644
--- a/src/Playwright/Core/JsonPipe.cs
+++ b/src/Playwright/Core/JsonPipe.cs
@@ -23,6 +23,7 @@
  */
 
 using System;
+using System.Collections.Generic;
 using System.Runtime.CompilerServices;
 using System.Text.Json;
 using System.Threading.Tasks;
@@ -73,8 +74,11 @@ internal override void OnMessage(string method, JsonElement? serverParams)
     }
 
     [MethodImpl(MethodImplOptions.NoInlining)]
-    public Task CloseAsync() => _channel.CloseAsync();
+    public Task CloseAsync() => SendMessageToServerAsync("close");
 
     [MethodImpl(MethodImplOptions.NoInlining)]
-    public Task SendAsync(object message) => _channel.SendAsync(message);
+    public Task SendAsync(object message) => SendMessageToServerAsync("send", new Dictionary<string, object>
+        {
+                { "message", message },
+        });
 }
diff --git a/src/Playwright/Core/Keyboard.cs b/src/Playwright/Core/Keyboard.cs
index ac2c4bd14d..ddbb027f5d 100644
--- a/src/Playwright/Core/Keyboard.cs
+++ b/src/Playwright/Core/Keyboard.cs
@@ -22,6 +22,7 @@
  * SOFTWARE.
  */
 
+using System.Collections.Generic;
 using System.Threading.Tasks;
 using Microsoft.Playwright.Transport.Channels;
 
@@ -36,15 +37,45 @@ public Keyboard(PageChannel channel)
         _channel = channel;
     }
 
-    public Task DownAsync(string key) => _channel.KeyboardDownAsync(key);
+    public Task DownAsync(string key)
+          => _channel.Object.SendMessageToServerAsync(
+            "keyboardDown",
+            new Dictionary<string, object>
+            {
+                ["key"] = key,
+            });
 
-    public Task UpAsync(string key) => _channel.KeyboardUpAsync(key);
+    public Task UpAsync(string key)
+            => _channel.Object.SendMessageToServerAsync(
+            "keyboardUp",
+            new Dictionary<string, object>
+            {
+                ["key"] = key,
+            });
 
     public Task PressAsync(string key, KeyboardPressOptions options = default)
-       => _channel.PressAsync(key, options?.Delay);
+       => _channel.Object.SendMessageToServerAsync(
+            "keyboardPress",
+            new Dictionary<string, object>
+            {
+                ["key"] = key,
+                ["delay"] = options?.Delay,
+            });
 
     public Task TypeAsync(string text, KeyboardTypeOptions options = default)
-       => _channel.TypeAsync(text, options?.Delay);
+        => _channel.Object.SendMessageToServerAsync(
+            "keyboardType",
+            new Dictionary<string, object>
+            {
+                ["text"] = text,
+                ["delay"] = options?.Delay,
+            });
 
-    public Task InsertTextAsync(string text) => _channel.InsertTextAsync(text);
+    public Task InsertTextAsync(string text)
+        => _channel.Object.SendMessageToServerAsync(
+            "keyboardInsertText",
+            new Dictionary<string, object>
+            {
+                ["text"] = text,
+            });
 }
diff --git a/src/Playwright/Core/LocalUtils.cs b/src/Playwright/Core/LocalUtils.cs
index 6852f0f016..b9062f5b8e 100644
--- a/src/Playwright/Core/LocalUtils.cs
+++ b/src/Playwright/Core/LocalUtils.cs
@@ -22,8 +22,10 @@
  * SOFTWARE.
  */
 
+using System;
 using System.Collections.Generic;
 using System.Threading.Tasks;
+using Microsoft.Playwright.Helpers;
 using Microsoft.Playwright.Transport;
 using Microsoft.Playwright.Transport.Channels;
 using Microsoft.Playwright.Transport.Protocol;
@@ -49,10 +51,23 @@ public LocalUtils(IChannelOwner parent, string guid, LocalUtilsInitializer initi
     IChannel<LocalUtils> IChannelOwner<LocalUtils>.Channel => _channel;
 
     internal Task ZipAsync(string zipFile, List<NameValue> entries, string mode, string stacksId, bool includeSources)
-        => _channel.ZipAsync(zipFile, entries, mode, stacksId, includeSources);
-
-    internal Task<(string HarId, string Error)> HarOpenAsync(string file)
-        => _channel.HarOpenAsync(file);
+        => SendMessageToServerAsync("zip", new Dictionary<string, object>
+        {
+                { "zipFile", zipFile },
+                { "entries", entries },
+                { "mode", mode },
+                { "stacksId", stacksId },
+                { "includeSources", includeSources },
+        });
+
+    internal async Task<(string HarId, string Error)> HarOpenAsync(string file)
+    {
+        var response = await SendMessageToServerAsync("harOpen", new Dictionary<string, object>
+            {
+                  { "file", file },
+            }).ConfigureAwait(false);
+        return (response.GetString("harId", true), response.GetString("error", true));
+    }
 
     internal Task<LocalUtilsHarLookupResult> HarLookupAsync(
         string harId,
@@ -61,25 +76,66 @@ internal Task<LocalUtilsHarLookupResult> HarLookupAsync(
         List<Header> headers,
         byte[] postData,
         bool isNavigationRequest)
-        => _channel.HarLookupAsync(harId, url, method, headers, postData, isNavigationRequest);
+        => SendMessageToServerAsync<LocalUtilsHarLookupResult>("harLookup", new Dictionary<string, object>
+            {
+                { "harId", harId },
+                { "url", url },
+                { "method", method },
+                { "headers", headers },
+                { "postData", postData != null ? Convert.ToBase64String(postData) : null },
+                { "isNavigationRequest", isNavigationRequest },
+            });
 
     internal Task HarCloseAsync(string harId)
-         => _channel.HarCloseAsync(harId);
+         => SendMessageToServerAsync("HarCloseAsync", new Dictionary<string, object>
+        {
+                  { "harId", harId },
+        });
 
     internal Task HarUnzipAsync(string zipFile, string harFile)
-         => _channel.HarUnzipAsync(zipFile, harFile);
-
-    internal Task<JsonPipe> ConnectAsync(string wsEndpoint = default, IEnumerable<KeyValuePair<string, string>> headers = default, float? slowMo = default, float? timeout = default, string exposeNetwork = default)
-         => _channel.ConnectAsync(wsEndpoint, headers, slowMo, timeout, exposeNetwork);
+         => SendMessageToServerAsync("harUnzip", new Dictionary<string, object>
+        {
+                  { "zipFile", zipFile },
+                  { "harFile", harFile },
+        });
+
+    internal async Task<JsonPipe> ConnectAsync(string wsEndpoint = default, IEnumerable<KeyValuePair<string, string>> headers = default, float? slowMo = default, float? timeout = default, string exposeNetwork = default)
+         => (await SendMessageToServerAsync("connect", new Dictionary<string, object>
+            {
+                { "wsEndpoint", wsEndpoint },
+                { "headers", headers },
+                { "slowMo", slowMo },
+                { "timeout", timeout },
+                { "exposeNetwork", exposeNetwork },
+            }).ConfigureAwait(false)).Value.GetObject<JsonPipe>("pipe", _connection);
 
     internal void AddStackToTracingNoReply(List<StackFrame> stack, int id)
-         => _channel.AddStackToTracingNoReply(stack, id);
+         => SendMessageToServerAsync("addStackToTracingNoReply", new Dictionary<string, object>
+        {
+            {
+                "callData", new ClientSideCallMetadata()
+                {
+                    Id = id,
+                    Stack = stack,
+                }
+            },
+        }).IgnoreException();
 
     internal Task TraceDiscardedAsync(string stacksId)
-        => _channel.TraceDiscardedAsync(stacksId);
+        => SendMessageToServerAsync("traceDiscarded", new Dictionary<string, object>
+        {
+            { "stacksId", stacksId },
+        });
 
-    internal Task<string> TracingStartedAsync(string tracesDir, string traceName)
-        => _channel.TracingStartedAsync(tracesDir, traceName);
+    internal async Task<string> TracingStartedAsync(string tracesDir, string traceName)
+    {
+        var response = await SendMessageToServerAsync("tracingStarted", new Dictionary<string, object>
+        {
+            { "tracesDir", tracesDir },
+            { "traceName", traceName },
+        }).ConfigureAwait(false);
+        return response.GetString("stacksId", true);
+    }
 }
 
 internal class LocalUtilsHarLookupResult
diff --git a/src/Playwright/Core/Locator.cs b/src/Playwright/Core/Locator.cs
index 11f4b28673..3449ece2cf 100644
--- a/src/Playwright/Core/Locator.cs
+++ b/src/Playwright/Core/Locator.cs
@@ -32,6 +32,7 @@
 using System.Text.RegularExpressions;
 using System.Threading.Tasks;
 using Microsoft.Playwright.Helpers;
+using Microsoft.Playwright.Transport.Channels;
 using Microsoft.Playwright.Transport.Protocol;
 
 namespace Microsoft.Playwright.Core;
@@ -228,7 +229,13 @@ public Task FocusAsync(LocatorFocusOptions options = null)
         => _frame.FocusAsync(_selector, ConvertOptions<FrameFocusOptions>(options));
 
     public Task BlurAsync(LocatorBlurOptions options = null)
-        => _frame._channel.BlurAsync(_selector, true, options?.Timeout);
+        => _frame.SendMessageToServerAsync(
+            "blur",
+            new Dictionary<string, object>
+            {
+                ["selector"] = _selector,
+                ["options"] = options,
+            });
 
     public Task<int> CountAsync()
         => _frame.QueryCountAsync(_selector);
@@ -335,12 +342,16 @@ public async Task<IReadOnlyList<string>> AllTextContentsAsync()
         => await _frame.EvalOnSelectorAllAsync<string[]>(_selector, "ee => ee.map(e => e.textContent || '')").ConfigureAwait(false);
 
     public Task WaitForAsync(LocatorWaitForOptions options = null)
-        => _frame._channel.WaitForSelectorAsync(
-            selector: _selector,
-            strict: true,
-            omitReturnValue: true,
-            state: options?.State,
-            timeout: options?.Timeout);
+    {
+        return _frame.SendMessageToServerAsync("waitForSelector", new Dictionary<string, object>
+        {
+            ["selector"] = _selector,
+            ["timeout"] = options?.Timeout,
+            ["state"] = options?.State,
+            ["strict"] = true,
+            ["omitReturnValue"] = true,
+        });
+    }
 
     internal Task<FrameExpectResult> ExpectAsync(string expression, FrameExpectOptions options = null)
         => _frame.ExpectAsync(
@@ -382,7 +393,13 @@ private Task<TResult> WithElementAsync<TResult>(Func<IElementHandle, float?, Tas
 
         return this._frame.WrapApiCallAsync(async () =>
         {
-            var result = await this._frame._channel.WaitForSelectorAsync(this._selector, state: WaitForSelectorState.Attached, strict: true, timeout: timeout).ConfigureAwait(false);
+            var result = await _frame.SendMessageToServerAsync<ElementHandleChannel>("waitForSelector", new Dictionary<string, object>
+            {
+                ["selector"] = this._selector,
+                ["state"] = WaitForSelectorState.Attached,
+                ["timeout"] = timeout,
+                ["strict"] = true,
+            }).ConfigureAwait(false);
             var handle = result?.Object;
             if (handle == null)
             {
diff --git a/src/Playwright/Core/Mouse.cs b/src/Playwright/Core/Mouse.cs
index 90d43a4b1c..5ce2a1a20a 100644
--- a/src/Playwright/Core/Mouse.cs
+++ b/src/Playwright/Core/Mouse.cs
@@ -22,6 +22,7 @@
  * SOFTWARE.
  */
 
+using System.Collections.Generic;
 using System.Threading.Tasks;
 using Microsoft.Playwright.Transport.Channels;
 
@@ -37,20 +38,63 @@ public Mouse(PageChannel channel)
     }
 
     public Task ClickAsync(float x, float y, MouseClickOptions options = default)
-        => _channel.MouseClickAsync(x, y, delay: options?.Delay, button: options?.Button, clickCount: options?.ClickCount);
+        => _channel.Object.SendMessageToServerAsync(
+            "mouseClick",
+            new Dictionary<string, object>
+            {
+                ["x"] = x,
+                ["y"] = y,
+                ["delay"] = options?.Delay,
+                ["button"] = options?.Button,
+                ["clickCount"] = options?.ClickCount,
+            });
 
     public Task DblClickAsync(float x, float y, MouseDblClickOptions options = default)
-        => _channel.MouseClickAsync(x, y, delay: options?.Delay, button: options?.Button, 2);
+        => _channel.Object.SendMessageToServerAsync(
+            "mouseClick",
+            new Dictionary<string, object>
+            {
+                ["x"] = x,
+                ["y"] = y,
+                ["delay"] = options?.Delay,
+                ["button"] = options?.Button,
+                ["clickCount"] = 2,
+            });
 
     public Task DownAsync(MouseDownOptions options = default)
-        => _channel.MouseDownAsync(button: options?.Button, clickCount: options?.ClickCount);
+        => _channel.Object.SendMessageToServerAsync(
+            "mouseDown",
+            new Dictionary<string, object>
+            {
+                ["button"] = options?.Button,
+                ["clickCount"] = options?.ClickCount,
+            });
 
     public Task MoveAsync(float x, float y, MouseMoveOptions options = default)
-        => _channel.MouseMoveAsync(x, y, steps: options?.Steps);
+        => _channel.Object.SendMessageToServerAsync(
+            "mouseMove",
+            new Dictionary<string, object>
+            {
+                ["x"] = x,
+                ["y"] = y,
+                ["steps"] = options?.Steps,
+            });
 
     public Task UpAsync(MouseUpOptions options = default)
-        => _channel.MouseUpAsync(button: options?.Button, clickCount: options?.ClickCount);
+      => _channel.Object.SendMessageToServerAsync(
+            "mouseUp",
+            new Dictionary<string, object>
+            {
+                ["button"] = options?.Button,
+                ["clickCount"] = options?.ClickCount,
+            });
 
     public Task WheelAsync(float deltaX, float deltaY)
-        => _channel.MouseWheelAsync(deltaX, deltaY);
+        => _channel.Object.SendMessageToServerAsync(
+            "mouseWheel",
+            new Dictionary<string, object>
+            {
+                ["deltaX"] = deltaX,
+                ["deltaY"] = deltaY,
+            });
 }
diff --git a/src/Playwright/Core/Page.cs b/src/Playwright/Core/Page.cs
index 6925351130..24af6dac04 100644
--- a/src/Playwright/Core/Page.cs
+++ b/src/Playwright/Core/Page.cs
@@ -301,7 +301,7 @@ public IFrame Frame(string name)
     public Task<string> TitleAsync() => MainFrame.TitleAsync();
 
     [MethodImpl(MethodImplOptions.NoInlining)]
-    public Task BringToFrontAsync() => _channel.BringToFrontAsync();
+    public Task BringToFrontAsync() => SendMessageToServerAsync("bringToFront");
 
     [MethodImpl(MethodImplOptions.NoInlining)]
     public Task<IPage> OpenerAsync() => Task.FromResult<IPage>(Opener?.IsClosed == false ? Opener : null);
@@ -316,7 +316,7 @@ public Task EmulateMediaAsync(PageEmulateMediaOptions options = default)
             ["reducedMotion"] = options?.ReducedMotion == ReducedMotion.Null ? "no-override" : options?.ReducedMotion,
             ["forcedColors"] = options?.ForcedColors == ForcedColors.Null ? "no-override" : options?.ForcedColors,
         };
-        return _channel.EmulateMediaAsync(args);
+        return SendMessageToServerAsync("emulateMedia", args);
     }
 
     [MethodImpl(MethodImplOptions.NoInlining)]
@@ -510,7 +510,12 @@ public async Task CloseAsync(PageCloseOptions options = default)
         _closeReason = options?.Reason;
         try
         {
-            await _channel.CloseAsync(options?.RunBeforeUnload ?? false).ConfigureAwait(false);
+            await SendMessageToServerAsync(
+            "close",
+            new Dictionary<string, object>
+            {
+                ["runBeforeUnload"] = options?.RunBeforeUnload ?? false,
+            }).ConfigureAwait(false);
             if (OwnedContext != null)
             {
                 await OwnedContext.CloseAsync().ConfigureAwait(false);
@@ -681,19 +686,25 @@ public async Task<byte[]> ScreenshotAsync(PageScreenshotOptions options = defaul
             options.Type = ElementHandle.DetermineScreenshotType(options.Path);
         }
 
-        byte[] result = await _channel.ScreenshotAsync(
-            path: options.Path,
-            fullPage: options.FullPage,
-            clip: options.Clip,
-            omitBackground: options.OmitBackground,
-            type: options.Type,
-            quality: options.Quality,
-            mask: options.Mask,
-            maskColor: options.MaskColor,
-            animations: options.Animations,
-            caret: options.Caret,
-            scale: options.Scale,
-            timeout: options.Timeout).ConfigureAwait(false);
+        var result = (await SendMessageToServerAsync("screenshot", new Dictionary<string, object>
+        {
+            ["fullPage"] = options.FullPage,
+            ["omitBackground"] = options.OmitBackground,
+            ["clip"] = options.Clip,
+            ["path"] = options.Path,
+            ["type"] = options.Type,
+            ["timeout"] = options.Timeout,
+            ["animations"] = options.Animations,
+            ["caret"] = options.Caret,
+            ["scale"] = options.Scale,
+            ["quality"] = options.Quality,
+            ["maskColor"] = options.MaskColor,
+            ["mask"] = options.Mask?.Select(locator => new Dictionary<string, object>
+            {
+                ["frame"] = ((Locator)locator)._frame._channel,
+                ["selector"] = ((Locator)locator)._selector,
+            }).ToArray(),
+        }).ConfigureAwait(false))?.GetProperty("binary").GetBytesFromBase64();
 
         if (!string.IsNullOrEmpty(options.Path))
         {
@@ -713,7 +724,12 @@ public Task SetContentAsync(string html, PageSetContentOptions options = default
 
     [MethodImpl(MethodImplOptions.NoInlining)]
     public Task SetExtraHTTPHeadersAsync(IEnumerable<KeyValuePair<string, string>> headers)
-        => _channel.SetExtraHTTPHeadersAsync(headers);
+        => SendMessageToServerAsync(
+            "setExtraHTTPHeaders",
+            new Dictionary<string, object>
+            {
+                ["headers"] = headers.Select(kv => new HeaderEntry { Name = kv.Key, Value = kv.Value }),
+            });
 
     [MethodImpl(MethodImplOptions.NoInlining)]
     public Task<IElementHandle> QuerySelectorAsync(string selector) => MainFrame.QuerySelectorAsync(selector);
@@ -779,15 +795,27 @@ public Task DblClickAsync(string selector, PageDblClickOptions options = default
 
     [MethodImpl(MethodImplOptions.NoInlining)]
     public async Task<IResponse> GoBackAsync(PageGoBackOptions options = default)
-        => (await _channel.GoBackAsync(options?.Timeout, options?.WaitUntil).ConfigureAwait(false))?.Object;
+        => (await SendMessageToServerAsync<ResponseChannel>("goBack", new Dictionary<string, object>
+        {
+            ["timeout"] = options?.Timeout,
+            ["waitUntil"] = options?.WaitUntil,
+        }).ConfigureAwait(false))?.Object;
 
     [MethodImpl(MethodImplOptions.NoInlining)]
     public async Task<IResponse> GoForwardAsync(PageGoForwardOptions options = default)
-        => (await _channel.GoForwardAsync(options?.Timeout, options?.WaitUntil).ConfigureAwait(false))?.Object;
+        => (await SendMessageToServerAsync<ResponseChannel>("goForward", new Dictionary<string, object>
+        {
+            ["timeout"] = options?.Timeout,
+            ["waitUntil"] = options?.WaitUntil,
+        }).ConfigureAwait(false))?.Object;
 
     [MethodImpl(MethodImplOptions.NoInlining)]
     public async Task<IResponse> ReloadAsync(PageReloadOptions options = default)
-        => (await _channel.ReloadAsync(options?.Timeout, options?.WaitUntil).ConfigureAwait(false))?.Object;
+        => (await SendMessageToServerAsync<ResponseChannel>("reload", new Dictionary<string, object>
+        {
+            ["timeout"] = options?.Timeout,
+            ["waitUntil"] = options?.WaitUntil,
+        }).ConfigureAwait(false))?.Object;
 
     [MethodImpl(MethodImplOptions.NoInlining)]
     public Task ExposeBindingAsync(string name, Action callback, PageExposeBindingOptions options = default)
@@ -861,19 +889,21 @@ public async Task<byte[]> PdfAsync(PagePdfOptions options = default)
             throw new NotSupportedException("This browser doesn't support this action.");
         }
 
-        byte[] result = await _channel.PdfAsync(
-            scale: options?.Scale,
-            displayHeaderFooter: options?.DisplayHeaderFooter,
-            headerTemplate: options?.HeaderTemplate,
-            footerTemplate: options?.FooterTemplate,
-            printBackground: options?.PrintBackground,
-            landscape: options?.Landscape,
-            pageRanges: options?.PageRanges,
-            format: options?.Format,
-            width: options?.Width,
-            height: options?.Height,
-            margin: options?.Margin,
-            preferCSSPageSize: options?.PreferCSSPageSize).ConfigureAwait(false);
+        byte[] result = (await SendMessageToServerAsync("pdf", new Dictionary<string, object>
+        {
+            ["scale"] = options.Scale,
+            ["displayHeaderFooter"] = options.DisplayHeaderFooter,
+            ["printBackground"] = options.PrintBackground,
+            ["landscape"] = options.Landscape,
+            ["preferCSSPageSize"] = options.PreferCSSPageSize,
+            ["pageRanges"] = options.PageRanges,
+            ["headerTemplate"] = options.HeaderTemplate,
+            ["footerTemplate"] = options.FooterTemplate,
+            ["margin"] = options.Margin,
+            ["width"] = options.Width,
+            ["format"] = options.Format,
+            ["height"] = options.Height,
+        }).ConfigureAwait(false))?.GetProperty("pdf").GetBytesFromBase64();
 
         if (!string.IsNullOrEmpty(options?.Path))
         {
@@ -886,7 +916,12 @@ public async Task<byte[]> PdfAsync(PagePdfOptions options = default)
 
     [MethodImpl(MethodImplOptions.NoInlining)]
     public Task AddInitScriptAsync(string script, string scriptPath)
-        => _channel.AddInitScriptAsync(ScriptsHelper.EvaluationScript(script, scriptPath));
+        => SendMessageToServerAsync<PageChannel>(
+            "addInitScript",
+            new Dictionary<string, object>
+            {
+                ["source"] = ScriptsHelper.EvaluationScript(script, scriptPath),
+            });
 
     [MethodImpl(MethodImplOptions.NoInlining)]
     public Task RouteAsync(string url, Func<IRoute, Task> handler, PageRouteOptions options = null)
@@ -944,7 +979,12 @@ public Task WaitForLoadStateAsync(LoadState? state = default, PageWaitForLoadSta
     public Task SetViewportSizeAsync(int width, int height)
     {
         ViewportSize = new() { Width = width, Height = height };
-        return _channel.SetViewportSizeAsync(ViewportSize);
+        return SendMessageToServerAsync(
+            "setViewportSize",
+            new Dictionary<string, object>
+            {
+                ["viewportSize"] = ViewportSize,
+            });
     }
 
     [MethodImpl(MethodImplOptions.NoInlining)]
@@ -1103,7 +1143,7 @@ public async Task PauseAsync()
         _timeoutSettings.SetDefaultTimeout(0);
         try
         {
-            await Task.WhenAny(Context.Channel.PauseAsync(), ClosedOrCrashedTcs.Task).ConfigureAwait(false);
+            await Task.WhenAny(Context.SendMessageToServerAsync("pause"), ClosedOrCrashedTcs.Task).ConfigureAwait(false);
         }
         finally
         {
@@ -1116,14 +1156,26 @@ public async Task PauseAsync()
     public void SetDefaultNavigationTimeout(float timeout)
     {
         _timeoutSettings.SetDefaultNavigationTimeout(timeout);
-        WrapApiCallAsync(() => Channel.SetDefaultNavigationTimeoutNoReplyAsync(timeout), true).IgnoreException();
+        WrapApiCallAsync(
+            () => SendMessageToServerAsync(
+            "setDefaultNavigationTimeoutNoReply",
+            new Dictionary<string, object>
+            {
+                ["timeout"] = timeout,
+            }),
+            true).IgnoreException();
     }
 
     [MethodImpl(MethodImplOptions.NoInlining)]
     public void SetDefaultTimeout(float timeout)
     {
         _timeoutSettings.SetDefaultTimeout(timeout);
-        WrapApiCallAsync(() => Channel.SetDefaultTimeoutNoReplyAsync(timeout), true).IgnoreException();
+        WrapApiCallAsync(
+            () => SendMessageToServerAsync("setDefaultTimeoutNoReply", new Dictionary<string, object>
+            {
+                ["timeout"] = timeout,
+            }),
+            true).IgnoreException();
     }
 
     [MethodImpl(MethodImplOptions.NoInlining)]
@@ -1209,7 +1261,7 @@ private Task UnrouteAsync(RouteHandler setting)
     private Task UpdateInterceptionAsync()
     {
         var patterns = RouteHandler.PrepareInterceptionPatterns(_routes);
-        return Channel.SetNetworkInterceptionPatternsAsync(patterns);
+        return SendMessageToServerAsync("setNetworkInterceptionPatterns", patterns);
     }
 
     internal void OnClose()
@@ -1291,7 +1343,13 @@ private Task InnerExposeBindingAsync(string name, Delegate callback, bool handle
 
         Bindings.Add(name, callback);
 
-        return _channel.ExposeBindingAsync(name, handle);
+        return SendMessageToServerAsync<PageChannel>(
+            "exposeBinding",
+            new Dictionary<string, object>
+            {
+                ["name"] = name,
+                ["needsHandle"] = handle,
+            });
     }
 
     private Video ForceVideo() => _video ??= new(this, _channel.Connection);
diff --git a/src/Playwright/Core/Request.cs b/src/Playwright/Core/Request.cs
index 6a5d26bb37..4aa522f049 100644
--- a/src/Playwright/Core/Request.cs
+++ b/src/Playwright/Core/Request.cs
@@ -29,6 +29,7 @@
 using System.Text.Json;
 using System.Threading.Tasks;
 using System.Web;
+using Microsoft.Playwright.Helpers;
 using Microsoft.Playwright.Transport;
 using Microsoft.Playwright.Transport.Channels;
 using Microsoft.Playwright.Transport.Protocol;
@@ -143,7 +144,7 @@ public byte[] PostDataBuffer
     internal BrowserContext _context => (BrowserContext)Frame.Page.Context;
 
     [MethodImpl(MethodImplOptions.NoInlining)]
-    public async Task<IResponse> ResponseAsync() => (await _channel.GetResponseAsync().ConfigureAwait(false))?.Object;
+    public async Task<IResponse> ResponseAsync() => (await SendMessageToServerAsync<ResponseChannel>("response").ConfigureAwait(false))?.Object;
 
     [MethodImpl(MethodImplOptions.NoInlining)]
     public JsonElement? PostDataJSON()
@@ -184,7 +185,7 @@ public async Task<RequestSizesResult> SizesAsync()
             throw new PlaywrightException("Unable to fetch resources sizes.");
         }
 
-        return await ((ResponseChannel)res.Channel).SizesAsync().ConfigureAwait(false);
+        return (await ((Response)res).SendMessageToServerAsync("sizes").ConfigureAwait(false))?.GetProperty("sizes").ToObject<RequestSizesResult>();
     }
 
     [MethodImpl(MethodImplOptions.NoInlining)]
@@ -215,7 +216,8 @@ private Task<RawHeaders> ActualHeadersAsync()
 
     private async Task<RawHeaders> GetRawHeadersTaskAsync()
     {
-        return new(await _channel.GetRawRequestHeadersAsync().ConfigureAwait(false));
+        var headerList = (await SendMessageToServerAsync("rawRequestHeaders").ConfigureAwait(false))?.GetProperty("headers").ToObject<List<NameValue>>();
+        return new(headerList);
     }
 
     internal void ApplyFallbackOverrides(RouteFallbackOptions overrides)
diff --git a/src/Playwright/Core/Response.cs b/src/Playwright/Core/Response.cs
index 63b23e80f2..3ffa75e499 100644
--- a/src/Playwright/Core/Response.cs
+++ b/src/Playwright/Core/Response.cs
@@ -28,6 +28,7 @@
 using System.Text;
 using System.Text.Json;
 using System.Threading.Tasks;
+using Microsoft.Playwright.Helpers;
 using Microsoft.Playwright.Transport;
 using Microsoft.Playwright.Transport.Channels;
 using Microsoft.Playwright.Transport.Protocol;
@@ -77,7 +78,7 @@ public async Task<Dictionary<string, string>> AllHeadersAsync()
         => (await GetRawHeadersAsync().ConfigureAwait(false)).Headers;
 
     [MethodImpl(MethodImplOptions.NoInlining)]
-    public Task<byte[]> BodyAsync() => _channel.GetBodyAsync();
+    public async Task<byte[]> BodyAsync() => (await SendMessageToServerAsync("body").ConfigureAwait(false))?.GetProperty("binary").GetBytesFromBase64();
 
     [MethodImpl(MethodImplOptions.NoInlining)]
     public async Task<string> FinishedAsync()
@@ -114,10 +115,12 @@ public async Task<T> JsonAsync<T>()
         => JsonSerializer.Deserialize<T>(await BodyAsync().ConfigureAwait(false));
 
     [MethodImpl(MethodImplOptions.NoInlining)]
-    public Task<ResponseSecurityDetailsResult> SecurityDetailsAsync() => _channel.SecurityDetailsAsync();
+    public async Task<ResponseSecurityDetailsResult> SecurityDetailsAsync() => (await SendMessageToServerAsync("securityDetails").ConfigureAwait(false))
+            ?.GetProperty("value").ToObject<ResponseSecurityDetailsResult>(_connection.DefaultJsonSerializerOptions);
 
     [MethodImpl(MethodImplOptions.NoInlining)]
-    public Task<ResponseServerAddrResult> ServerAddrAsync() => _channel.ServerAddrAsync();
+    public async Task<ResponseServerAddrResult> ServerAddrAsync() => (await SendMessageToServerAsync("serverAddr").ConfigureAwait(false))
+            ?.GetProperty("value").ToObject<ResponseServerAddrResult>(_connection.DefaultJsonSerializerOptions);
 
     [MethodImpl(MethodImplOptions.NoInlining)]
     public async Task<string> TextAsync()
@@ -143,7 +146,6 @@ private Task<RawHeaders> GetRawHeadersAsync()
 
     private async Task<RawHeaders> GetRawHeadersTaskAsync()
     {
-        var headers = await _channel.GetRawHeadersAsync().ConfigureAwait(false);
-        return new(headers);
+        return new((await SendMessageToServerAsync("rawResponseHeaders").ConfigureAwait(false))?.GetProperty("headers").ToObject<List<NameValue>>());
     }
 }
diff --git a/src/Playwright/Core/Route.cs b/src/Playwright/Core/Route.cs
index 96bdc1ae83..4811bbf029 100644
--- a/src/Playwright/Core/Route.cs
+++ b/src/Playwright/Core/Route.cs
@@ -77,7 +77,7 @@ public async Task FulfillAsync(RouteFulfillOptions options = default)
             options.Path,
             options.Response).ConfigureAwait(false);
         normalized["requestUrl"] = _request._initializer.Url;
-        await RaceWithTargetCloseAsync(_channel.FulfillAsync(normalized)).ConfigureAwait(false);
+        await RaceWithTargetCloseAsync(SendMessageToServerAsync("fulfill", normalized)).ConfigureAwait(false);
         ReportHandled(true);
     }
 
@@ -85,7 +85,13 @@ public async Task FulfillAsync(RouteFulfillOptions options = default)
     public async Task AbortAsync(string errorCode = RequestAbortErrorCode.Failed)
     {
         CheckNotHandled();
-        await RaceWithTargetCloseAsync(_channel.AbortAsync(_request._initializer.Url, errorCode)).ConfigureAwait(false);
+        await RaceWithTargetCloseAsync(SendMessageToServerAsync(
+            "abort",
+            new Dictionary<string, object>
+            {
+                ["requestUrl"] = _request._initializer.Url,
+                ["errorCode"] = string.IsNullOrEmpty(errorCode) ? RequestAbortErrorCode.Failed : errorCode,
+            })).ConfigureAwait(false);
         ReportHandled(true);
     }
 
@@ -102,7 +108,18 @@ internal async Task InnerContinueAsync(bool @internal = false)
     {
         var options = _request.FallbackOverridesForContinue();
         await _channel.Connection.WrapApiCallAsync(
-            () => RaceWithTargetCloseAsync(_channel.ContinueAsync(requestUrl: _request._initializer.Url, url: options.Url, method: options.Method, postData: options.PostData, headers: options.Headers, isFallback: @internal)),
+            () => RaceWithTargetCloseAsync(
+                SendMessageToServerAsync(
+            "continue",
+            new Dictionary<string, object>
+            {
+                ["requestUrl"] = _request._initializer.Url,
+                ["url"] = options.Url,
+                ["method"] = options.Method,
+                ["postData"] = options.PostData != null ? Convert.ToBase64String(options.PostData) : null,
+                ["headers"] = options.Headers?.Select(kv => new HeaderEntry { Name = kv.Key, Value = kv.Value }).ToArray(),
+                ["isFallback"] = @internal,
+            })),
             @internal).ConfigureAwait(false);
     }
 
@@ -235,7 +252,12 @@ public Task FallbackAsync(RouteFallbackOptions options = null)
     internal async Task RedirectNavigationRequestAsync(string url)
     {
         CheckNotHandled();
-        await RaceWithTargetCloseAsync(_channel.RedirectNavigationRequestAsync(url)).ConfigureAwait(false);
+        await RaceWithTargetCloseAsync(SendMessageToServerAsync(
+            "redirectNavigationRequest",
+            new Dictionary<string, object>
+            {
+                ["url"] = url,
+            })).ConfigureAwait(false);
         ReportHandled(true);
     }
 
diff --git a/src/Playwright/Core/Selectors.cs b/src/Playwright/Core/Selectors.cs
index 6161e8b3c6..35d690feb2 100644
--- a/src/Playwright/Core/Selectors.cs
+++ b/src/Playwright/Core/Selectors.cs
@@ -47,21 +47,21 @@ internal Selectors(IChannelOwner parent, string guid) : base(parent, guid)
 internal class SelectorsAPI : ISelectors
 {
     private readonly HashSet<Selectors> _channels = new();
-    private readonly List<SelectorsRegisterParams> _registrations = new();
+    private readonly List<Dictionary<string, object>> _registrations = new();
 
     public async Task RegisterAsync(string name, SelectorsRegisterOptions options = default)
     {
         options ??= new SelectorsRegisterOptions();
         var source = ScriptsHelper.EvaluationScript(options.Script, options.Path);
-        SelectorsRegisterParams @params = new()
+        var @params = new Dictionary<string, object>()
         {
-            Name = name,
-            Source = source,
-            ContentScript = options?.ContentScript,
+            ["name"] = name,
+            ["source"] = source,
+            ["contentScript"] = options.ContentScript,
         };
         foreach (var channel in _channels)
         {
-            await channel._channel.RegisterAsync(@params).ConfigureAwait(false);
+            await channel.SendMessageToServerAsync("register", @params).ConfigureAwait(false);
         }
         _registrations.Add(@params);
     }
@@ -71,7 +71,12 @@ public void SetTestIdAttribute(string attributeName)
         Locator.SetTestIdAttribute(attributeName);
         foreach (var channel in _channels)
         {
-            channel._channel.SetTestIdAttributeAsync(attributeName).IgnoreException();
+            channel.SendMessageToServerAsync(
+            "setTestIdAttributeName",
+            new Dictionary<string, object>
+            {
+                ["testIdAttributeName"] = attributeName,
+            }).IgnoreException();
         }
     }
 
@@ -81,8 +86,11 @@ internal void AddChannel(Selectors channel)
         foreach (var @params in _registrations)
         {
             // This should not fail except for connection closure, but just in case we catch.
-            channel._channel.RegisterAsync(@params).IgnoreException();
-            channel._channel.SetTestIdAttributeAsync(Locator.TestIdAttributeName()).IgnoreException();
+            channel.SendMessageToServerAsync("register", @params).IgnoreException();
+            channel.SendMessageToServerAsync("setTestIdAttributeName", new Dictionary<string, object>
+            {
+                ["testIdAttributeName"] = Locator.TestIdAttributeName(),
+            }).IgnoreException();
         }
     }
 
@@ -91,3 +99,10 @@ internal void RemoveChannel(Selectors channel)
         _channels.Remove(channel);
     }
 }
+
+internal record SelectorsRegisterParams
+{
+    internal string Name;
+    internal string Source;
+    internal bool? ContentScript;
+}
diff --git a/src/Playwright/Core/Stream.cs b/src/Playwright/Core/Stream.cs
index df1d773075..72daf84a08 100644
--- a/src/Playwright/Core/Stream.cs
+++ b/src/Playwright/Core/Stream.cs
@@ -23,6 +23,7 @@
  */
 
 using System;
+using System.Collections.Generic;
 using System.IO;
 using System.Runtime.CompilerServices;
 using System.Threading;
@@ -48,13 +49,22 @@ internal Stream(IChannelOwner parent, string guid) : base(parent, guid)
     public StreamImpl StreamImpl => new(this);
 
     [MethodImpl(MethodImplOptions.NoInlining)]
-    public Task<byte[]> ReadAsync(int size) => Channel.ReadAsync(size);
+    public async Task<byte[]> ReadAsync(int size)
+    {
+        var response = await SendMessageToServerAsync(
+            "read",
+            new Dictionary<string, object>
+            {
+                ["size"] = size,
+            }).ConfigureAwait(false);
+        return response.Value.GetProperty("binary").GetBytesFromBase64();
+    }
 
     [MethodImpl(MethodImplOptions.NoInlining)]
     public ValueTask DisposeAsync() => new ValueTask(CloseAsync());
 
     [MethodImpl(MethodImplOptions.NoInlining)]
-    public Task CloseAsync() => Channel.CloseAsync();
+    public Task CloseAsync() => SendMessageToServerAsync("close");
 }
 
 internal class StreamImpl : System.IO.Stream
diff --git a/src/Playwright/Core/Touchscreen.cs b/src/Playwright/Core/Touchscreen.cs
index 8540156224..8708185ce8 100644
--- a/src/Playwright/Core/Touchscreen.cs
+++ b/src/Playwright/Core/Touchscreen.cs
@@ -21,6 +21,7 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  */
+using System.Collections.Generic;
 using System.Threading.Tasks;
 using Microsoft.Playwright.Transport.Channels;
 
@@ -35,5 +36,12 @@ public Touchscreen(PageChannel channel)
         _channel = channel;
     }
 
-    public Task TapAsync(float x, float y) => _channel.TouchscreenTapAsync(x, y);
+    public Task TapAsync(float x, float y)
+           => _channel.Object.SendMessageToServerAsync(
+            "touchscreenTap",
+            new Dictionary<string, object>
+            {
+                ["x"] = x,
+                ["y"] = y,
+            });
 }
diff --git a/src/Playwright/Core/Tracing.cs b/src/Playwright/Core/Tracing.cs
index 1176e880e0..b6b11c1061 100644
--- a/src/Playwright/Core/Tracing.cs
+++ b/src/Playwright/Core/Tracing.cs
@@ -22,10 +22,14 @@
  * SOFTWARE.
  */
 
+using System.Collections.Generic;
 using System.Runtime.CompilerServices;
+using System.Text.Json;
 using System.Threading.Tasks;
+using Microsoft.Playwright.Helpers;
 using Microsoft.Playwright.Transport;
 using Microsoft.Playwright.Transport.Channels;
+using Microsoft.Playwright.Transport.Protocol;
 
 namespace Microsoft.Playwright.Core;
 
@@ -54,13 +58,21 @@ public async Task StartAsync(
         var traceName = await _channel.Connection.WrapApiCallAsync(
             async () =>
         {
-            await _channel.TracingStartAsync(
-                name: options?.Name,
-                title: options?.Title,
-                screenshots: options?.Screenshots,
-                snapshots: options?.Snapshots,
-                sources: options?.Sources).ConfigureAwait(false);
-            return await _channel.StartChunkAsync(title: options?.Title, name: options?.Name).ConfigureAwait(false);
+            await SendMessageToServerAsync(
+            "tracingStart",
+            new Dictionary<string, object>
+            {
+                ["name"] = options?.Name,
+                ["title"] = options?.Title,
+                ["screenshots"] = options?.Screenshots,
+                ["snapshots"] = options?.Snapshots,
+                ["sources"] = options?.Sources,
+            }).ConfigureAwait(false);
+            return (await SendMessageToServerAsync("tracingStartChunk", new Dictionary<string, object>
+            {
+                ["title"] = options?.Title,
+                ["name"] = options?.Name,
+            }).ConfigureAwait(false))?.GetProperty("traceName").ToString();
         },
             true).ConfigureAwait(false);
         await StartCollectingStacksAsync(traceName).ConfigureAwait(false);
@@ -69,7 +81,11 @@ await _channel.TracingStartAsync(
     [MethodImpl(MethodImplOptions.NoInlining)]
     public async Task StartChunkAsync(TracingStartChunkOptions options = default)
     {
-        var traceName = await _channel.StartChunkAsync(title: options?.Title, name: options?.Name).ConfigureAwait(false);
+        var traceName = (await SendMessageToServerAsync("tracingStartChunk", new Dictionary<string, object>
+        {
+            ["title"] = options?.Title,
+            ["name"] = options?.Name,
+        }).ConfigureAwait(false))?.GetProperty("traceName").ToString();
         await StartCollectingStacksAsync(traceName).ConfigureAwait(false);
     }
 
@@ -93,7 +109,7 @@ await _channel.Connection.WrapApiCallAsync(
             async () =>
             {
                 await StopChunkAsync(new() { Path = options?.Path }).ConfigureAwait(false);
-                await _channel.TracingStopAsync().ConfigureAwait(false);
+                await SendMessageToServerAsync("tracingStop").ConfigureAwait(false);
             },
             true).ConfigureAwait(false);
     }
@@ -109,7 +125,7 @@ private async Task DoStopChunkAsync(string filePath)
         if (string.IsNullOrEmpty(filePath))
         {
             // Not interested in artifacts.
-            await _channel.TracingStopChunkAsync("discard").ConfigureAwait(false);
+            await _TracingStopChunkAsync("discard").ConfigureAwait(false);
             if (!string.IsNullOrEmpty(_stacksId))
             {
                 await _channel.Connection.LocalUtils.TraceDiscardedAsync(stacksId: _stacksId).ConfigureAwait(false);
@@ -121,12 +137,12 @@ private async Task DoStopChunkAsync(string filePath)
 
         if (isLocal)
         {
-            var (_, sourceEntries) = await _channel.TracingStopChunkAsync("entries").ConfigureAwait(false);
+            var (_, sourceEntries) = await _TracingStopChunkAsync("entries").ConfigureAwait(false);
             await _channel.Connection.LocalUtils.ZipAsync(filePath, sourceEntries, "write", _stacksId, _includeSources).ConfigureAwait(false);
             return;
         }
 
-        var (artifact, _) = await _channel.TracingStopChunkAsync("archive").ConfigureAwait(false);
+        var (artifact, _) = await _TracingStopChunkAsync("archive").ConfigureAwait(false);
 
         // The artifact may be missing if the browser closed while stopping tracing.
         if (artifact == null)
@@ -144,4 +160,23 @@ private async Task DoStopChunkAsync(string filePath)
 
         await _channel.Connection.LocalUtils.ZipAsync(filePath, new(), "append", _stacksId, _includeSources).ConfigureAwait(false);
     }
+
+    internal async Task<(Artifact Artifact, List<NameValue> Entries)> _TracingStopChunkAsync(string mode)
+    {
+        var result = await SendMessageToServerAsync("tracingStopChunk", new Dictionary<string, object>
+        {
+            ["mode"] = mode,
+        }).ConfigureAwait(false);
+
+        var artifact = result.GetObject<Artifact>("artifact", _connection);
+        List<NameValue> entries = new();
+        if (result.Value.TryGetProperty("entries", out var entriesElement))
+        {
+            foreach (var current in entriesElement.EnumerateArray())
+            {
+                entries.Add(current.Deserialize<NameValue>());
+            }
+        }
+        return (artifact, entries);
+    }
 }
diff --git a/src/Playwright/Core/Worker.cs b/src/Playwright/Core/Worker.cs
index b7f459bf91..70ba0c00e1 100644
--- a/src/Playwright/Core/Worker.cs
+++ b/src/Playwright/Core/Worker.cs
@@ -23,6 +23,7 @@
  */
 
 using System;
+using System.Collections.Generic;
 using System.Runtime.CompilerServices;
 using System.Text.Json;
 using System.Threading.Tasks;
@@ -86,18 +87,24 @@ internal void OnClose()
 
     [MethodImpl(MethodImplOptions.NoInlining)]
     public async Task<T> EvaluateAsync<T>(string expression, object arg = null)
-        => ScriptsHelper.ParseEvaluateResult<T>(await _channel.EvaluateExpressionAsync(
-            expression,
-            null,
-            ScriptsHelper.SerializedArgument(arg)).ConfigureAwait(false));
+        => ScriptsHelper.ParseEvaluateResult<T>((await SendMessageToServerAsync(
+                "evaluateExpression",
+                new Dictionary<string, object>
+                {
+                    ["expression"] = expression,
+                    ["arg"] = ScriptsHelper.SerializedArgument(arg),
+                }).ConfigureAwait(false)).Value.GetProperty("value"));
 
     [MethodImpl(MethodImplOptions.NoInlining)]
     public async Task<IJSHandle> EvaluateHandleAsync(string expression, object arg = null)
-        => await _channel.EvaluateExpressionHandleAsync(
-            expression,
-            null,
-            ScriptsHelper.SerializedArgument(arg))
-        .ConfigureAwait(false);
+        => (await SendMessageToServerAsync<JsonElement>(
+            "evaluateExpressionHandle",
+            new Dictionary<string, object>
+            {
+                ["expression"] = expression,
+                ["arg"] = ScriptsHelper.SerializedArgument(arg),
+            })
+            .ConfigureAwait(false)).GetObject<JSHandle>("handle", _connection);
 
     [MethodImpl(MethodImplOptions.NoInlining)]
     public async Task<IWorker> WaitForCloseAsync(Func<Task> action = default, float? timeout = default)
diff --git a/src/Playwright/Core/WritableStream.cs b/src/Playwright/Core/WritableStream.cs
index caa6059eba..7498eb0a99 100644
--- a/src/Playwright/Core/WritableStream.cs
+++ b/src/Playwright/Core/WritableStream.cs
@@ -23,6 +23,7 @@
  */
 
 using System;
+using System.Collections.Generic;
 using System.IO;
 using System.Runtime.CompilerServices;
 using System.Threading;
@@ -48,13 +49,18 @@ internal WritableStream(IChannelOwner parent, string guid) : base(parent, guid)
     public WritableStreamImpl WritableStreamImpl => new(this);
 
     [MethodImpl(MethodImplOptions.NoInlining)]
-    public Task WriteAsync(string binary) => Channel.WriteAsync(binary);
+    public Task WriteAsync(string binary) => SendMessageToServerAsync(
+            "write",
+            new Dictionary<string, object>
+            {
+                ["binary"] = binary,
+            });
 
     [MethodImpl(MethodImplOptions.NoInlining)]
     public ValueTask DisposeAsync() => new ValueTask(CloseAsync());
 
     [MethodImpl(MethodImplOptions.NoInlining)]
-    public Task CloseAsync() => Channel.CloseAsync();
+    public Task CloseAsync() => SendMessageToServerAsync("close");
 }
 
 internal class WritableStreamImpl : System.IO.Stream
diff --git a/src/Playwright/Helpers/SetInputFilesHelpers.cs b/src/Playwright/Helpers/SetInputFilesHelpers.cs
index c70d2c1d43..d56e9c2a5b 100644
--- a/src/Playwright/Helpers/SetInputFilesHelpers.cs
+++ b/src/Playwright/Helpers/SetInputFilesHelpers.cs
@@ -51,7 +51,11 @@ public static async Task<SetInputFilesFiles> ConvertInputFilesAsync(IEnumerable<
             {
                 var lastModifiedMs = new DateTimeOffset(File.GetLastWriteTime(f)).ToUnixTimeMilliseconds();
 #pragma warning disable CA2007 // Upstream bug: https://github.com/dotnet/roslyn-analyzers/issues/5712
-                await using var stream = await context.Channel.CreateTempFileAsync(Path.GetFileName(f), lastModifiedMs).ConfigureAwait(false);
+                await using var stream = (await context.SendMessageToServerAsync("createTempFile", new Dictionary<string, object>
+            {
+                { "name", Path.GetFileName(f) },
+                { "lastModifiedMs", lastModifiedMs },
+            }).ConfigureAwait(false)).GetObject<WritableStream>("writableStream", context._connection);
 #pragma warning restore CA2007
                 using var fileStream = File.OpenRead(f);
                 await fileStream.CopyToAsync(stream.WritableStreamImpl).ConfigureAwait(false);
diff --git a/src/Playwright/Transport/ChannelOwnerBase.cs b/src/Playwright/Transport/ChannelOwnerBase.cs
index 13720b058d..028da4d9fe 100644
--- a/src/Playwright/Transport/ChannelOwnerBase.cs
+++ b/src/Playwright/Transport/ChannelOwnerBase.cs
@@ -136,4 +136,15 @@ private void UpdateEventSubscription(string eventName, bool enabled)
             }),
             true).IgnoreException();
     }
+
+    internal Task<JsonElement?> SendMessageToServerAsync(
+        string method,
+        Dictionary<string, object> args = null,
+        bool keepNulls = false)
+        => SendMessageToServerAsync<JsonElement?>(method, args, keepNulls);
+
+    internal Task<T> SendMessageToServerAsync<T>(
+        string method,
+        Dictionary<string, object> args = null,
+        bool keepNulls = false) => _connection.SendMessageToServerAsync<T>(this, method, args, keepNulls);
 }
diff --git a/src/Playwright/Transport/Channels/APIRequestContextChannel.cs b/src/Playwright/Transport/Channels/APIRequestContextChannel.cs
index 2cca0d4214..e7f26eb54e 100644
--- a/src/Playwright/Transport/Channels/APIRequestContextChannel.cs
+++ b/src/Playwright/Transport/Channels/APIRequestContextChannel.cs
@@ -22,11 +22,7 @@
  * SOFTWARE.
  */
 
-using System;
-using System.Collections.Generic;
-using System.Threading.Tasks;
 using Microsoft.Playwright.Core;
-using Microsoft.Playwright.Helpers;
 
 namespace Microsoft.Playwright.Transport.Channels;
 
@@ -35,62 +31,4 @@ internal class APIRequestContextChannel : Channel<APIRequestContext>
     public APIRequestContextChannel(string guid, Connection connection, APIRequestContext owner) : base(guid, connection, owner)
     {
     }
-
-    internal Task DisposeAsync() => Connection.SendMessageToServerAsync(Object, "dispose");
-
-    internal async Task<IAPIResponse> FetchAsync(
-        string url,
-        IEnumerable<KeyValuePair<string, string>> parameters,
-        string method,
-        IEnumerable<KeyValuePair<string, string>> headers,
-        object jsonData,
-        byte[] postData,
-        FormData formData,
-        FormData multipartData,
-        float? timeout,
-        bool? failOnStatusCode,
-        bool? ignoreHTTPSErrors,
-        int? maxRedirects)
-    {
-        var message = new Dictionary<string, object>
-        {
-            ["url"] = url,
-            ["method"] = method,
-            ["failOnStatusCode"] = failOnStatusCode,
-            ["ignoreHTTPSErrors"] = ignoreHTTPSErrors,
-            ["maxRedirects"] = maxRedirects,
-            ["timeout"] = timeout,
-            ["params"] = parameters?.ToProtocol(),
-            ["headers"] = headers?.ToProtocol(),
-            ["jsonData"] = jsonData,
-            ["postData"] = postData != null ? Convert.ToBase64String(postData) : null,
-            ["formData"] = formData?.ToProtocol(throwWhenSerializingFilePayloads: true),
-            ["multipartData"] = multipartData?.ToProtocol(),
-        };
-
-        var response = await Connection.SendMessageToServerAsync(Object, "fetch", message).ConfigureAwait(false);
-        return new Core.APIResponse(Object, response?.GetProperty("response").ToObject<Protocol.APIResponse>());
-    }
-
-    internal Task<StorageState> StorageStateAsync()
-        => Connection.SendMessageToServerAsync<StorageState>(Object, "storageState", null);
-
-    internal async Task<string> FetchResponseBodyAsync(string fetchUid)
-    {
-        var response = await Connection.SendMessageToServerAsync(Object, "fetchResponseBody", new Dictionary<string, object> { ["fetchUid"] = fetchUid }).ConfigureAwait(false);
-        if (response?.TryGetProperty("binary", out var binary) == true)
-        {
-            return binary.ToString();
-        }
-        return null;
-    }
-
-    internal async Task<string[]> FetchResponseLogAsync(string fetchUid)
-    {
-        var response = await Connection.SendMessageToServerAsync(Object, "fetchLog", new Dictionary<string, object> { ["fetchUid"] = fetchUid }).ConfigureAwait(false);
-        return response.Value.GetProperty("log").ToObject<string[]>();
-    }
-
-    internal Task DisposeAPIResponseAsync(string fetchUid)
-        => Connection.SendMessageToServerAsync(Object, "disposeAPIResponse", new Dictionary<string, object> { ["fetchUid"] = fetchUid });
 }
diff --git a/src/Playwright/Transport/Channels/ArtifactChannel.cs b/src/Playwright/Transport/Channels/ArtifactChannel.cs
index 843d65ac64..bc8f0a6496 100644
--- a/src/Playwright/Transport/Channels/ArtifactChannel.cs
+++ b/src/Playwright/Transport/Channels/ArtifactChannel.cs
@@ -22,11 +22,7 @@
 * SOFTWARE.
 */
 
-using System.Collections.Generic;
-using System.Text.Json;
-using System.Threading.Tasks;
 using Microsoft.Playwright.Core;
-using Microsoft.Playwright.Helpers;
 
 namespace Microsoft.Playwright.Transport.Channels;
 
@@ -35,51 +31,4 @@ internal class ArtifactChannel : Channel<Artifact>
     public ArtifactChannel(string guid, Connection connection, Artifact owner) : base(guid, connection, owner)
     {
     }
-
-    internal async Task<string> PathAfterFinishedAsync()
-        => (await Connection.SendMessageToServerAsync<JsonElement?>(
-            Object,
-            "pathAfterFinished",
-            null)
-            .ConfigureAwait(false)).GetString("value", true);
-
-    internal Task SaveAsAsync(string path)
-        => Connection.SendMessageToServerAsync<JsonElement>(
-            Object,
-            "saveAs",
-            new Dictionary<string, object>
-            {
-                ["path"] = path,
-            });
-
-    internal async Task<Stream> SaveAsStreamAsync()
-        => (await Connection.SendMessageToServerAsync<JsonElement>(
-            Object,
-            "saveAsStream",
-            null)
-            .ConfigureAwait(false)).GetObject<Stream>("stream", Connection);
-
-    internal async Task<string> FailureAsync()
-        => (await Connection.SendMessageToServerAsync<JsonElement?>(
-            Object,
-            "failure",
-            null)
-            .ConfigureAwait(false)).GetString("error", true);
-
-    internal async Task<Stream> StreamAsync()
-        => (await Connection.SendMessageToServerAsync<JsonElement?>(
-            Object,
-            "stream",
-            null)
-            .ConfigureAwait(false))?.GetObject<Stream>("stream", Connection);
-
-    internal Task CancelAsync()
-        => Connection.SendMessageToServerAsync<JsonElement>(
-            Object,
-            "cancel");
-
-    internal Task DeleteAsync()
-        => Connection.SendMessageToServerAsync<JsonElement>(
-            Object,
-            "delete");
 }
diff --git a/src/Playwright/Transport/Channels/BindingCallChannel.cs b/src/Playwright/Transport/Channels/BindingCallChannel.cs
index 7bd56ed35c..3824dad8c8 100644
--- a/src/Playwright/Transport/Channels/BindingCallChannel.cs
+++ b/src/Playwright/Transport/Channels/BindingCallChannel.cs
@@ -22,12 +22,7 @@
 * SOFTWARE.
 */
 
-using System;
-using System.Collections.Generic;
-using System.Text.Json;
-using System.Threading.Tasks;
 using Microsoft.Playwright.Core;
-using Microsoft.Playwright.Helpers;
 
 namespace Microsoft.Playwright.Transport.Channels;
 
@@ -36,22 +31,4 @@ internal class BindingCallChannel : Channel<BindingCall>
     public BindingCallChannel(string guid, Connection connection, BindingCall owner) : base(guid, connection, owner)
     {
     }
-
-    internal Task RejectAsync(Exception error)
-        => Connection.SendMessageToServerAsync<JsonElement>(
-            Object,
-            "reject",
-            new Dictionary<string, object>
-            {
-                ["error"] = error.ToObject(),
-            });
-
-    internal Task ResolveAsync(object result)
-        => Connection.SendMessageToServerAsync<JsonElement>(
-            Object,
-            "resolve",
-            new Dictionary<string, object>
-            {
-                ["result"] = result,
-            });
 }
diff --git a/src/Playwright/Transport/Channels/BrowserChannel.cs b/src/Playwright/Transport/Channels/BrowserChannel.cs
index 4e6661fb96..53cb05d091 100644
--- a/src/Playwright/Transport/Channels/BrowserChannel.cs
+++ b/src/Playwright/Transport/Channels/BrowserChannel.cs
@@ -22,15 +22,7 @@
  * SOFTWARE.
  */
 
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Text.Json;
-using System.Text.RegularExpressions;
-using System.Threading.Tasks;
 using Microsoft.Playwright.Core;
-using Microsoft.Playwright.Helpers;
-using Microsoft.Playwright.Transport.Protocol;
 
 namespace Microsoft.Playwright.Transport.Channels;
 
@@ -39,185 +31,4 @@ internal class BrowserChannel : Channel<Browser>
     public BrowserChannel(string guid, Connection connection, Browser owner) : base(guid, connection, owner)
     {
     }
-
-    internal static Dictionary<string, object> PrepareHarOptions(
-        HarContentPolicy? recordHarContent,
-        HarMode? recordHarMode,
-        string recordHarPath,
-        bool? recordHarOmitContent,
-        string recordHarUrlFilter,
-        string recordHarUrlFilterString,
-        Regex recordHarUrlFilterRegex)
-    {
-        if (string.IsNullOrEmpty(recordHarPath))
-        {
-            return null;
-        }
-        var recordHarArgs = new Dictionary<string, object>();
-        recordHarArgs["path"] = recordHarPath;
-        if (recordHarContent.HasValue)
-        {
-            recordHarArgs["content"] = recordHarContent;
-        }
-        else if (recordHarOmitContent == true)
-        {
-            recordHarArgs["content"] = HarContentPolicy.Omit;
-        }
-        if (!string.IsNullOrEmpty(recordHarUrlFilter))
-        {
-            recordHarArgs["urlGlob"] = recordHarUrlFilter;
-        }
-        else if (!string.IsNullOrEmpty(recordHarUrlFilterString))
-        {
-            recordHarArgs["urlGlob"] = recordHarUrlFilterString;
-        }
-        else if (recordHarUrlFilterRegex != null)
-        {
-            recordHarArgs["urlRegexSource"] = recordHarUrlFilterRegex.ToString();
-            recordHarArgs["urlRegexFlags"] = recordHarUrlFilterRegex.Options.GetInlineFlags();
-        }
-        if (recordHarMode.HasValue)
-        {
-            recordHarArgs["mode"] = recordHarMode;
-        }
-
-        if (recordHarArgs.Keys.Count > 0)
-        {
-            return recordHarArgs;
-        }
-        return null;
-    }
-
-    internal Task<CDPChannel> NewBrowserCDPSessionAsync()
-    => Connection.SendMessageToServerAsync<CDPChannel>(
-        Object,
-        "newBrowserCDPSession");
-
-    internal Task<BrowserContextChannel> NewContextAsync(
-        bool? acceptDownloads = null,
-        bool? bypassCSP = null,
-        ColorScheme? colorScheme = null,
-        ReducedMotion? reducedMotion = null,
-        ForcedColors? forcedColors = null,
-        float? deviceScaleFactor = null,
-        IEnumerable<KeyValuePair<string, string>> extraHTTPHeaders = null,
-        Geolocation geolocation = null,
-        bool? hasTouch = null,
-        HttpCredentials httpCredentials = null,
-        bool? ignoreHTTPSErrors = null,
-        bool? isMobile = null,
-        bool? javaScriptEnabled = null,
-        string locale = null,
-        bool? offline = null,
-        IEnumerable<string> permissions = null,
-        Proxy proxy = null,
-        HarContentPolicy? recordHarContent = default,
-        HarMode? recordHarMode = default,
-        string recordHarPath = default,
-        bool? recordHarOmitContent = default,
-        string recordHarUrlFilter = default,
-        string recordHarUrlFilterString = default,
-        Regex recordHarUrlFilterRegex = default,
-        Dictionary<string, object> recordVideo = null,
-        string storageState = null,
-        string storageStatePath = null,
-        ServiceWorkerPolicy? serviceWorkers = default,
-        string timezoneId = null,
-        string userAgent = null,
-        ViewportSize viewportSize = default,
-        ScreenSize screenSize = default,
-        string baseUrl = default,
-        bool? strictSelectors = default)
-    {
-        var args = new Dictionary<string, object>
-        {
-            ["bypassCSP"] = bypassCSP,
-            ["deviceScaleFactor"] = deviceScaleFactor,
-            ["serviceWorkers"] = serviceWorkers,
-            ["geolocation"] = geolocation,
-            ["hasTouch"] = hasTouch,
-            ["httpCredentials"] = httpCredentials,
-            ["ignoreHTTPSErrors"] = ignoreHTTPSErrors,
-            ["isMobile"] = isMobile,
-            ["javaScriptEnabled"] = javaScriptEnabled,
-            ["locale"] = locale,
-            ["offline"] = offline,
-            ["permissions"] = permissions,
-            ["proxy"] = proxy,
-            ["strictSelectors"] = strictSelectors,
-            ["colorScheme"] = colorScheme == ColorScheme.Null ? "no-override" : colorScheme,
-            ["reducedMotion"] = reducedMotion == ReducedMotion.Null ? "no-override" : reducedMotion,
-            ["forcedColors"] = forcedColors == ForcedColors.Null ? "no-override" : forcedColors,
-            ["extraHTTPHeaders"] = extraHTTPHeaders?.Select(kv => new HeaderEntry { Name = kv.Key, Value = kv.Value }).ToArray(),
-            ["recordHar"] = PrepareHarOptions(
-                    recordHarContent: recordHarContent,
-                    recordHarMode: recordHarMode,
-                    recordHarPath: recordHarPath,
-                    recordHarOmitContent: recordHarOmitContent,
-                    recordHarUrlFilter: recordHarUrlFilter,
-                    recordHarUrlFilterString: recordHarUrlFilterString,
-                    recordHarUrlFilterRegex: recordHarUrlFilterRegex),
-            ["recordVideo"] = recordVideo,
-            ["timezoneId"] = timezoneId,
-            ["userAgent"] = userAgent,
-            ["baseURL"] = baseUrl,
-        };
-
-        if (acceptDownloads.HasValue)
-        {
-            args.Add("acceptDownloads", acceptDownloads.Value ? "accept" : "deny");
-        }
-
-
-        if (!string.IsNullOrEmpty(storageStatePath))
-        {
-            if (!File.Exists(storageStatePath))
-            {
-                throw new PlaywrightException($"The specified storage state file does not exist: {storageStatePath}");
-            }
-
-            storageState = File.ReadAllText(storageStatePath);
-        }
-
-        if (!string.IsNullOrEmpty(storageState))
-        {
-            args.Add("storageState", JsonSerializer.Deserialize<StorageState>(storageState, Helpers.JsonExtensions.DefaultJsonSerializerOptions));
-        }
-
-        if (viewportSize?.Width == -1)
-        {
-            args.Add("noDefaultViewport", true);
-        }
-        else
-        {
-            args.Add("viewport", viewportSize);
-            args.Add("screen", screenSize);
-        }
-
-        return Connection.SendMessageToServerAsync<BrowserContextChannel>(
-            Object,
-            "newContext",
-            args);
-    }
-
-    internal Task CloseAsync(string reason) => Connection.SendMessageToServerAsync<BrowserContextChannel>(Object, "close", new Dictionary<string, object>
-    {
-        ["reason"] = reason,
-    });
-
-    internal Task StartTracingAsync(IPage page, bool screenshots, string path, IEnumerable<string> categories)
-    {
-        var args = new Dictionary<string, object>
-        {
-            ["screenshots"] = screenshots,
-            ["path"] = path,
-            ["page"] = page,
-            ["categories"] = categories,
-        };
-
-        return Connection.SendMessageToServerAsync(Object, "crStartTracing", args);
-    }
-
-    internal async Task<string> StopTracingAsync()
-        => (await Connection.SendMessageToServerAsync(Object, "crStopTracing").ConfigureAwait(false))?.GetProperty("binary").ToString();
 }
diff --git a/src/Playwright/Transport/Channels/BrowserContextChannel.cs b/src/Playwright/Transport/Channels/BrowserContextChannel.cs
index 9d0a57c926..1059517b13 100644
--- a/src/Playwright/Transport/Channels/BrowserContextChannel.cs
+++ b/src/Playwright/Transport/Channels/BrowserContextChannel.cs
@@ -22,14 +22,7 @@
  * SOFTWARE.
  */
 
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text.RegularExpressions;
-using System.Threading.Tasks;
 using Microsoft.Playwright.Core;
-using Microsoft.Playwright.Helpers;
-using Microsoft.Playwright.Transport.Protocol;
 
 namespace Microsoft.Playwright.Transport.Channels;
 
@@ -38,184 +31,4 @@ internal class BrowserContextChannel : Channel<BrowserContext>
     public BrowserContextChannel(string guid, Connection connection, BrowserContext owner) : base(guid, connection, owner)
     {
     }
-
-    internal Task<CDPChannel> NewCDPSessionAsync(Page page)
-    => Connection.SendMessageToServerAsync<CDPChannel>(
-        Object,
-        "newCDPSession",
-        new Dictionary<string, object>
-        {
-            ["page"] = new { guid = page.Guid },
-        });
-
-    internal Task<CDPChannel> NewCDPSessionAsync(Frame frame)
-    => Connection.SendMessageToServerAsync<CDPChannel>(
-        Object,
-        "newCDPSession",
-        new Dictionary<string, object>
-        {
-            ["frame"] = new { guid = frame.Guid },
-        });
-
-    internal Task<PageChannel> NewPageAsync()
-        => Connection.SendMessageToServerAsync<PageChannel>(
-            Object,
-            "newPage",
-            null);
-
-    internal Task CloseAsync(string reason) => Connection.SendMessageToServerAsync(Object, "close", new Dictionary<string, object>
-    {
-        ["reason"] = reason,
-    });
-
-    internal Task PauseAsync()
-        => Connection.SendMessageToServerAsync(Object, "pause");
-
-    internal Task SetDefaultNavigationTimeoutNoReplyAsync(float? timeout)
-        => Connection.SendMessageToServerAsync<PageChannel>(
-            Object,
-            "setDefaultNavigationTimeoutNoReply",
-            new Dictionary<string, object>
-            {
-                ["timeout"] = timeout,
-            });
-
-    internal Task SetDefaultTimeoutNoReplyAsync(float? timeout)
-        => Connection.SendMessageToServerAsync<PageChannel>(
-            Object,
-            "setDefaultTimeoutNoReply",
-            new Dictionary<string, object>
-            {
-                ["timeout"] = timeout,
-            });
-
-    internal Task ExposeBindingAsync(string name, bool needsHandle)
-        => Connection.SendMessageToServerAsync<PageChannel>(
-            Object,
-            "exposeBinding",
-            new Dictionary<string, object>
-            {
-                ["name"] = name,
-                ["needsHandle"] = needsHandle,
-            });
-
-    internal Task AddInitScriptAsync(string script)
-        => Connection.SendMessageToServerAsync<PageChannel>(
-            Object,
-            "addInitScript",
-            new Dictionary<string, object>
-            {
-                ["source"] = script,
-            });
-
-    internal Task SetNetworkInterceptionPatternsAsync(Dictionary<string, object> args)
-        => Connection.SendMessageToServerAsync(
-            Object,
-            "setNetworkInterceptionPatterns",
-            args);
-
-    internal Task SetOfflineAsync(bool offline)
-        => Connection.SendMessageToServerAsync<PageChannel>(
-            Object,
-            "setOffline",
-            new Dictionary<string, object>
-            {
-                ["offline"] = offline,
-            });
-
-    internal async Task<IReadOnlyList<BrowserContextCookiesResult>> CookiesAsync(IEnumerable<string> urls)
-    {
-        return (await Connection.SendMessageToServerAsync(
-            Object,
-            "cookies",
-            new Dictionary<string, object>
-            {
-                ["urls"] = urls?.ToArray() ?? Array.Empty<string>(),
-            }).ConfigureAwait(false))?.GetProperty("cookies").ToObject<IReadOnlyList<BrowserContextCookiesResult>>();
-    }
-
-    internal Task AddCookiesAsync(IEnumerable<Cookie> cookies)
-        => Connection.SendMessageToServerAsync<PageChannel>(
-            Object,
-            "addCookies",
-            new Dictionary<string, object>
-            {
-                ["cookies"] = cookies,
-            });
-
-    internal Task GrantPermissionsAsync(IEnumerable<string> permissions, string origin)
-    {
-        var args = new Dictionary<string, object>
-        {
-            ["permissions"] = permissions?.ToArray(),
-            ["origin"] = origin,
-        };
-        return Connection.SendMessageToServerAsync<PageChannel>(Object, "grantPermissions", args);
-    }
-
-    internal Task ClearPermissionsAsync() => Connection.SendMessageToServerAsync<PageChannel>(Object, "clearPermissions");
-
-    internal Task SetGeolocationAsync(Geolocation geolocation)
-        => Connection.SendMessageToServerAsync<PageChannel>(
-            Object,
-            "setGeolocation",
-            new Dictionary<string, object>
-            {
-                ["geolocation"] = geolocation,
-            });
-
-    internal Task ClearCookiesAsync() => Connection.SendMessageToServerAsync<PageChannel>(Object, "clearCookies");
-
-    internal Task SetExtraHTTPHeadersAsync(IEnumerable<KeyValuePair<string, string>> headers)
-        => Connection.SendMessageToServerAsync(
-            Object,
-            "setExtraHTTPHeaders",
-            new Dictionary<string, object>
-            {
-                ["headers"] = headers.Select(kv => new HeaderEntry { Name = kv.Key, Value = kv.Value }),
-            });
-
-    internal Task<StorageState> GetStorageStateAsync()
-        => Connection.SendMessageToServerAsync<StorageState>(Object, "storageState", null);
-
-    internal async Task<Artifact> HarExportAsync(string harId)
-    {
-        var result = await Connection.SendMessageToServerAsync(
-        Object,
-        "harExport",
-        new Dictionary<string, object>
-        {
-            ["harId"] = harId,
-        }).ConfigureAwait(false);
-        return result.GetObject<Artifact>("artifact", Connection);
-    }
-
-    internal async Task<string> HarStartAsync(
-        Page page,
-        string path,
-        string recordHarUrlFilter,
-        string recordHarUrlFilterString,
-        Regex recordHarUrlFilterRegex,
-        HarContentPolicy? harContentPolicy,
-        HarMode? harMode)
-    {
-        var args = new Dictionary<string, object>
-            {
-                { "page", page?.Channel },
-                { "options", BrowserChannel.PrepareHarOptions(harContentPolicy ?? HarContentPolicy.Attach, harMode ?? HarMode.Minimal, path, null, recordHarUrlFilter, recordHarUrlFilterString, recordHarUrlFilterRegex) },
-            };
-        var result = await Connection.SendMessageToServerAsync(Object, "harStart", args).ConfigureAwait(false);
-        return result.GetString("harId", false);
-    }
-
-    internal async Task<WritableStream> CreateTempFileAsync(string name, long lastModifiedMs)
-    {
-        var args = new Dictionary<string, object>
-            {
-                { "name", name },
-                { "lastModifiedMs", lastModifiedMs },
-            };
-        var result = await Connection.SendMessageToServerAsync(Object, "createTempFile", args).ConfigureAwait(false);
-        return result.GetObject<WritableStream>("writableStream", Connection);
-    }
 }
diff --git a/src/Playwright/Transport/Channels/BrowserTypeChannel.cs b/src/Playwright/Transport/Channels/BrowserTypeChannel.cs
index d82430f998..bcf3e13fc0 100644
--- a/src/Playwright/Transport/Channels/BrowserTypeChannel.cs
+++ b/src/Playwright/Transport/Channels/BrowserTypeChannel.cs
@@ -22,12 +22,6 @@
  * SOFTWARE.
  */
 
-using System.Collections.Generic;
-using System.Text.Json;
-using System.Text.RegularExpressions;
-using System.Threading.Tasks;
-using Microsoft.Playwright.Helpers;
-
 namespace Microsoft.Playwright.Transport.Channels;
 
 internal class BrowserTypeChannel : Channel<Core.BrowserType>
@@ -35,186 +29,4 @@ internal class BrowserTypeChannel : Channel<Core.BrowserType>
     public BrowserTypeChannel(string guid, Connection connection, Core.BrowserType owner) : base(guid, connection, owner)
     {
     }
-
-    public Task<BrowserChannel> LaunchAsync(
-        bool? headless = default,
-        string channel = default,
-        string executablePath = default,
-        IEnumerable<string> passedArguments = default,
-        Proxy proxy = default,
-        string downloadsPath = default,
-        string tracesDir = default,
-        bool? chromiumSandbox = default,
-        IEnumerable<KeyValuePair<string, object>> firefoxUserPrefs = default,
-        bool? handleSIGINT = default,
-        bool? handleSIGTERM = default,
-        bool? handleSIGHUP = default,
-        float? timeout = default,
-        IEnumerable<KeyValuePair<string, string>> env = default,
-        bool? devtools = default,
-        float? slowMo = default,
-        IEnumerable<string> ignoreDefaultArgs = default,
-        bool? ignoreAllDefaultArgs = default)
-    {
-        var args = new Dictionary<string, object>
-            {
-                { "channel", channel },
-                { "executablePath", executablePath },
-                { "args", passedArguments },
-                { "ignoreAllDefaultArgs", ignoreAllDefaultArgs },
-                { "ignoreDefaultArgs", ignoreDefaultArgs },
-                { "handleSIGHUP", handleSIGHUP },
-                { "handleSIGINT", handleSIGINT },
-                { "handleSIGTERM", handleSIGTERM },
-                { "headless", headless },
-                { "devtools", devtools },
-                { "env", env.ToProtocol() },
-                { "proxy", proxy },
-                { "downloadsPath", downloadsPath },
-                { "tracesDir", tracesDir },
-                { "firefoxUserPrefs", firefoxUserPrefs },
-                { "chromiumSandbox", chromiumSandbox },
-                { "slowMo", slowMo },
-                { "timeout", timeout },
-            };
-
-        return Connection.SendMessageToServerAsync<BrowserChannel>(
-            Object,
-            "launch",
-            args);
-    }
-
-    internal Task<BrowserContextChannel> LaunchPersistentContextAsync(
-        string userDataDir,
-        bool? headless = default,
-        string channel = default,
-        string executablePath = default,
-        IEnumerable<string> args = default,
-        Proxy proxy = default,
-        string downloadsPath = default,
-        string tracesDir = default,
-        bool? chromiumSandbox = default,
-        IEnumerable<KeyValuePair<string, object>> firefoxUserPrefs = default,
-        bool? handleSIGINT = default,
-        bool? handleSIGTERM = default,
-        bool? handleSIGHUP = default,
-        float? timeout = default,
-        IEnumerable<KeyValuePair<string, string>> env = default,
-        bool? devtools = default,
-        float? slowMo = default,
-        bool? acceptDownloads = default,
-        bool? ignoreHTTPSErrors = default,
-        bool? bypassCSP = default,
-        ViewportSize viewportSize = default,
-        ScreenSize screenSize = default,
-        string userAgent = default,
-        float? deviceScaleFactor = default,
-        bool? isMobile = default,
-        bool? hasTouch = default,
-        bool? javaScriptEnabled = default,
-        string timezoneId = default,
-        Geolocation geolocation = default,
-        string locale = default,
-        IEnumerable<string> permissions = default,
-        IEnumerable<KeyValuePair<string, string>> extraHTTPHeaders = default,
-        bool? offline = default,
-        HttpCredentials httpCredentials = default,
-        ColorScheme? colorScheme = default,
-        ReducedMotion? reducedMotion = default,
-        ForcedColors? forcedColors = default,
-        HarContentPolicy? recordHarContent = default,
-        HarMode? recordHarMode = default,
-        string recordHarPath = default,
-        bool? recordHarOmitContent = default,
-        string recordHarUrlFilter = default,
-        string recordHarUrlFilterString = default,
-        Regex recordHarUrlFilterRegex = default,
-        Dictionary<string, object> recordVideo = default,
-        ServiceWorkerPolicy? serviceWorkers = default,
-        IEnumerable<string> ignoreDefaultArgs = default,
-        bool? ignoreAllDefaultArgs = default,
-        string baseUrl = default,
-        bool? strictSelectors = default)
-    {
-        var channelArgs = new Dictionary<string, object>
-        {
-            ["userDataDir"] = userDataDir,
-            ["headless"] = headless,
-            ["channel"] = channel,
-            ["executablePath"] = executablePath,
-            ["args"] = args,
-            ["downloadsPath"] = downloadsPath,
-            ["tracesDir"] = tracesDir,
-            ["proxy"] = proxy,
-            ["chromiumSandbox"] = chromiumSandbox,
-            ["firefoxUserPrefs"] = firefoxUserPrefs,
-            ["handleSIGINT"] = handleSIGINT,
-            ["handleSIGTERM"] = handleSIGTERM,
-            ["handleSIGHUP"] = handleSIGHUP,
-            ["timeout"] = timeout,
-            ["env"] = env.ToProtocol(),
-            ["devtools"] = devtools,
-            ["slowMo"] = slowMo,
-            ["ignoreHTTPSErrors"] = ignoreHTTPSErrors,
-            ["bypassCSP"] = bypassCSP,
-            ["strictSelectors"] = strictSelectors,
-            ["serviceWorkers"] = serviceWorkers,
-            ["screensize"] = screenSize,
-            ["userAgent"] = userAgent,
-            ["deviceScaleFactor"] = deviceScaleFactor,
-            ["isMobile"] = isMobile,
-            ["hasTouch"] = hasTouch,
-            ["javaScriptEnabled"] = javaScriptEnabled,
-            ["timezoneId"] = timezoneId,
-            ["geolocation"] = geolocation,
-            ["locale"] = locale,
-            ["permissions"] = permissions,
-            ["extraHTTPHeaders"] = extraHTTPHeaders.ToProtocol(),
-            ["offline"] = offline,
-            ["httpCredentials"] = httpCredentials,
-            ["colorScheme"] = colorScheme == ColorScheme.Null ? "no-override" : colorScheme,
-            ["reducedMotion"] = reducedMotion == ReducedMotion.Null ? "no-override" : reducedMotion,
-            ["forcedColors"] = forcedColors == ForcedColors.Null ? "no-override" : forcedColors,
-            ["recordVideo"] = recordVideo,
-            ["ignoreDefaultArgs"] = ignoreDefaultArgs,
-            ["ignoreAllDefaultArgs"] = ignoreAllDefaultArgs,
-            ["baseURL"] = baseUrl,
-            ["recordHar"] = BrowserChannel.PrepareHarOptions(
-                    recordHarContent: recordHarContent,
-                    recordHarMode: recordHarMode,
-                    recordHarPath: recordHarPath,
-                    recordHarOmitContent: recordHarOmitContent,
-                    recordHarUrlFilter: recordHarUrlFilter,
-                    recordHarUrlFilterString: recordHarUrlFilterString,
-                    recordHarUrlFilterRegex: recordHarUrlFilterRegex),
-        };
-
-        if (acceptDownloads.HasValue)
-        {
-            channelArgs.Add("acceptDownloads", acceptDownloads.Value ? "accept" : "deny");
-        }
-
-        if (viewportSize?.Width == -1)
-        {
-            channelArgs.Add("noDefaultViewport", true);
-        }
-        else
-        {
-            channelArgs.Add("viewport", viewportSize);
-        }
-
-        return Connection.SendMessageToServerAsync<BrowserContextChannel>(Object, "launchPersistentContext", channelArgs);
-    }
-
-    internal Task<JsonElement> ConnectOverCDPAsync(string endpointURL, IEnumerable<KeyValuePair<string, string>> headers = default, float? slowMo = default, float? timeout = default)
-    {
-        var channelArgs = new Dictionary<string, object>
-            {
-                { "endpointURL", endpointURL },
-                { "headers", headers.ToProtocol() },
-                { "slowMo", slowMo },
-                { "timeout", timeout },
-            };
-        return Connection.SendMessageToServerAsync<JsonElement>(Object, "connectOverCDP", channelArgs);
-    }
 }
diff --git a/src/Playwright/Transport/Channels/CDPChannel.cs b/src/Playwright/Transport/Channels/CDPChannel.cs
index 549a19a1e9..5ef3f51a15 100644
--- a/src/Playwright/Transport/Channels/CDPChannel.cs
+++ b/src/Playwright/Transport/Channels/CDPChannel.cs
@@ -21,9 +21,6 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  */
-using System.Collections.Generic;
-using System.Text.Json;
-using System.Threading.Tasks;
 using Microsoft.Playwright.Core;
 
 #nullable enable
@@ -35,26 +32,5 @@ internal class CDPChannel : Channel<CDPSession>
     public CDPChannel(string guid, Connection connection, CDPSession owner) : base(guid, connection, owner)
     {
     }
-
-    internal Task DetachAsync()
-    {
-        return Connection.SendMessageToServerAsync(
-           Object,
-           "detach");
-    }
-
-    internal async Task<JsonElement?> SendAsync(string method, Dictionary<string, object>? args = null)
-    {
-        var newArgs = new Dictionary<string, object>() { { "method", method } };
-        if (args != null)
-        {
-            newArgs["params"] = args;
-        }
-        var result = await Connection.SendMessageToServerAsync(
-           Object,
-           "send",
-           newArgs).ConfigureAwait(false);
-        return result?.GetProperty("result");
-    }
 }
 #nullable disable
diff --git a/src/Playwright/Transport/Channels/DialogChannel.cs b/src/Playwright/Transport/Channels/DialogChannel.cs
index d457f5aaac..4f6f8325fe 100644
--- a/src/Playwright/Transport/Channels/DialogChannel.cs
+++ b/src/Playwright/Transport/Channels/DialogChannel.cs
@@ -22,8 +22,6 @@
  * SOFTWARE.
  */
 
-using System.Collections.Generic;
-using System.Threading.Tasks;
 using Microsoft.Playwright.Core;
 
 namespace Microsoft.Playwright.Transport.Channels;
@@ -33,15 +31,4 @@ internal class DialogChannel : Channel<Dialog>
     public DialogChannel(string guid, Connection connection, Dialog owner) : base(guid, connection, owner)
     {
     }
-
-    internal Task AcceptAsync(string promptText)
-        => Connection.SendMessageToServerAsync<PageChannel>(
-            Object,
-            "accept",
-            new Dictionary<string, object>
-            {
-                ["promptText"] = promptText,
-            });
-
-    internal Task DismissAsync() => Connection.SendMessageToServerAsync<PageChannel>(Object, "dismiss");
 }
diff --git a/src/Playwright/Transport/Channels/ElementHandleChannel.cs b/src/Playwright/Transport/Channels/ElementHandleChannel.cs
index 30f201ef69..288d19ed8e 100644
--- a/src/Playwright/Transport/Channels/ElementHandleChannel.cs
+++ b/src/Playwright/Transport/Channels/ElementHandleChannel.cs
@@ -22,13 +22,7 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  */
-using System.Collections.Generic;
-using System.Linq;
-using System.Text.Json;
-using System.Threading.Tasks;
 using Microsoft.Playwright.Core;
-using Microsoft.Playwright.Helpers;
-using Microsoft.Playwright.Transport.Protocol;
 
 namespace Microsoft.Playwright.Transport.Channels;
 
@@ -40,399 +34,4 @@ public ElementHandleChannel(string guid, Connection connection, ElementHandle ow
     }
 
     public new ElementHandle Object { get; set; }
-
-    internal Task<ElementHandleChannel> WaitForSelectorAsync(string selector, WaitForSelectorState? state, float? timeout, bool? strict)
-    {
-        var args = new Dictionary<string, object>
-        {
-            ["selector"] = selector,
-            ["timeout"] = timeout,
-            ["state"] = state,
-            ["strict"] = strict,
-        };
-
-        return Connection.SendMessageToServerAsync<ElementHandleChannel>(
-            Object,
-            "waitForSelector",
-            args);
-    }
-
-    internal Task<ElementHandleChannel> QuerySelectorAsync(string selector)
-        => Connection.SendMessageToServerAsync<ElementHandleChannel>(
-            Object,
-            "querySelector",
-            new Dictionary<string, object>
-            {
-                ["selector"] = selector,
-            });
-
-    internal Task WaitForElementStateAsync(ElementState state, float? timeout)
-    {
-        var args = new Dictionary<string, object>
-        {
-            ["state"] = state,
-            ["timeout"] = timeout,
-        };
-
-        return Connection.SendMessageToServerAsync<ElementHandleChannel>(Object, "waitForElementState", args);
-    }
-
-    internal Task<ChannelBase[]> QuerySelectorAllAsync(string selector)
-        => Connection.SendMessageToServerAsync<ChannelBase[]>(
-            Object,
-            "querySelectorAll",
-            new Dictionary<string, object>
-            {
-                ["selector"] = selector,
-            });
-
-    internal async Task<byte[]> ScreenshotAsync(string path, bool? omitBackground, ScreenshotType? type, int? quality, IEnumerable<ILocator> mask, string maskColor, ScreenshotAnimations? animations, ScreenshotCaret? caret, ScreenshotScale? scale, float? timeout)
-    {
-        var args = new Dictionary<string, object>
-        {
-            ["type"] = type,
-            ["omitBackground"] = omitBackground,
-            ["path"] = path,
-            ["timeout"] = timeout,
-            ["animations"] = animations,
-            ["caret"] = caret,
-            ["scale"] = scale,
-            ["quality"] = quality,
-            ["maskColor"] = maskColor,
-        };
-        if (mask != null)
-        {
-            args["mask"] = mask.Select(locator => new Dictionary<string, object>
-            {
-                ["frame"] = ((Locator)locator)._frame._channel,
-                ["selector"] = ((Locator)locator)._selector,
-            }).ToArray();
-        }
-
-        return (await Connection.SendMessageToServerAsync(Object, "screenshot", args).ConfigureAwait(false))?.GetProperty("binary").GetBytesFromBase64();
-    }
-
-    internal Task<JsonElement?> EvalOnSelectorAsync(string selector, string script, object arg)
-        => Connection.SendMessageToServerAsync<JsonElement?>(
-            Object,
-            "evalOnSelector",
-            new Dictionary<string, object>
-            {
-                ["selector"] = selector,
-                ["expression"] = script,
-                ["arg"] = arg,
-            });
-
-    internal Task<JsonElement?> EvalOnSelectorAllAsync(string selector, string script, object arg)
-        => Connection.SendMessageToServerAsync<JsonElement?>(
-            Object,
-            "evalOnSelectorAll",
-            new Dictionary<string, object>
-            {
-                ["selector"] = selector,
-                ["expression"] = script,
-                ["arg"] = arg,
-            });
-
-    internal Task<FrameChannel> ContentFrameAsync() => Connection.SendMessageToServerAsync<FrameChannel>(Object, "contentFrame", null);
-
-    internal Task<FrameChannel> OwnerFrameAsync() => Connection.SendMessageToServerAsync<FrameChannel>(Object, "ownerFrame", null);
-
-    internal Task HoverAsync(
-        IEnumerable<KeyboardModifier> modifiers,
-        Position position,
-        float? timeout,
-        bool? force,
-        bool? noWaitAfter,
-        bool? trial)
-    {
-        var args = new Dictionary<string, object>
-        {
-            ["force"] = force,
-            ["position"] = position,
-            ["timeout"] = timeout,
-            ["trial"] = trial,
-            ["modifiers"] = modifiers?.Select(m => m.ToValueString()),
-            ["noWaitAfter"] = noWaitAfter,
-        };
-
-        return Connection.SendMessageToServerAsync<JsonElement?>(Object, "hover", args);
-    }
-
-    internal Task FocusAsync() => Connection.SendMessageToServerAsync(Object, "focus", null);
-
-    internal Task ClickAsync(
-        float? delay,
-        MouseButton? button,
-        int? clickCount,
-        IEnumerable<KeyboardModifier> modifiers,
-        Position position,
-        float? timeout,
-        bool? force,
-        bool? noWaitAfter,
-        bool? trial)
-    {
-        var args = new Dictionary<string, object>
-        {
-            ["delay"] = delay,
-            ["button"] = button,
-            ["clickCount"] = clickCount,
-            ["force"] = force,
-            ["noWaitAfter"] = noWaitAfter,
-            ["timeout"] = timeout,
-            ["trial"] = trial,
-            ["position"] = position,
-            ["modifiers"] = modifiers?.Select(m => m.ToValueString()),
-        };
-
-        return Connection.SendMessageToServerAsync(Object, "click", args);
-    }
-
-    internal Task DblClickAsync(
-        float? delay,
-        MouseButton? button,
-        IEnumerable<KeyboardModifier> modifiers,
-        Position position,
-        float? timeout,
-        bool? force,
-        bool? noWaitAfter,
-        bool? trial)
-    {
-        var args = new Dictionary<string, object>
-        {
-            ["delay"] = delay,
-            ["button"] = button,
-            ["force"] = force,
-            ["noWaitAfter"] = noWaitAfter,
-            ["timeout"] = timeout,
-            ["trial"] = trial,
-            ["position"] = position,
-            ["modifiers"] = modifiers?.Select(m => m.ToValueString()),
-        };
-
-        return Connection.SendMessageToServerAsync(Object, "dblclick", args);
-    }
-
-    internal async Task<ElementHandleBoundingBoxResult> BoundingBoxAsync()
-    {
-        var result = (await Connection.SendMessageToServerAsync(Object, "boundingBox").ConfigureAwait(false)).Value;
-
-        if (result.TryGetProperty("value", out var value))
-        {
-            return value.ToObject<ElementHandleBoundingBoxResult>();
-        }
-
-        return null;
-    }
-
-    internal Task ScrollIntoViewIfNeededAsync(float? timeout)
-    {
-        var args = new Dictionary<string, object>
-        {
-            ["timeout"] = timeout,
-        };
-
-        return Connection.SendMessageToServerAsync<ElementHandleChannel>(Object, "scrollIntoViewIfNeeded", args);
-    }
-
-    internal Task FillAsync(string value, bool? noWaitAfter, bool? force, float? timeout)
-    {
-        var args = new Dictionary<string, object>
-        {
-            ["value"] = value,
-            ["timeout"] = timeout,
-            ["force"] = force,
-            ["noWaitAfter"] = noWaitAfter,
-        };
-
-        return Connection.SendMessageToServerAsync(Object, "fill", args);
-    }
-
-    internal Task DispatchEventAsync(string type, object eventInit)
-    {
-        var args = new Dictionary<string, object>
-        {
-            ["type"] = type,
-            ["eventInit"] = eventInit,
-        };
-
-        return Connection.SendMessageToServerAsync<ElementHandleChannel>(Object, "dispatchEvent", args);
-    }
-
-    internal Task SetInputFilesAsync(SetInputFilesFiles files, bool? noWaitAfter, float? timeout)
-    {
-        var args = new Dictionary<string, object>
-        {
-            ["payloads"] = files.Payloads,
-            ["localPaths"] = files.LocalPaths,
-            ["streams"] = files.Streams,
-            ["timeout"] = timeout,
-            ["noWaitAfter"] = noWaitAfter,
-        };
-
-        return Connection.SendMessageToServerAsync(Object, "setInputFiles", args);
-    }
-
-    internal async Task<string> GetAttributeAsync(string name)
-    {
-        var args = new Dictionary<string, object>
-        {
-            ["name"] = name,
-        };
-
-        if ((await Connection.SendMessageToServerAsync(Object, "getAttribute", args).ConfigureAwait(false))?.TryGetProperty("value", out var value) ?? false)
-        {
-            return value.ToString();
-        }
-        return null;
-    }
-
-    internal async Task<string> InnerHTMLAsync()
-        => (await Connection.SendMessageToServerAsync(Object, "innerHTML").ConfigureAwait(false))?.GetProperty("value").ToString();
-
-    internal async Task<string> InnerTextAsync()
-        => (await Connection.SendMessageToServerAsync(Object, "innerText").ConfigureAwait(false))?.GetProperty("value").ToString();
-
-    internal async Task<string> TextContentAsync()
-        => (await Connection.SendMessageToServerAsync(Object, "textContent").ConfigureAwait(false))?.GetProperty("value").ToString();
-
-    internal Task SelectTextAsync(bool? force = null, float? timeout = null)
-    {
-        var args = new Dictionary<string, object>
-        {
-            ["force"] = force,
-            ["timeout"] = timeout,
-        };
-
-        return Connection.SendMessageToServerAsync<ElementHandleChannel>(Object, "selectText", args);
-    }
-
-    internal async Task<IReadOnlyList<string>> SelectOptionAsync(IEnumerable<SelectOptionValueProtocol> values, bool? noWaitAfter, bool? force, float? timeout)
-    {
-        var args = new Dictionary<string, object>
-        {
-            ["options"] = values,
-            ["noWaitAfter"] = noWaitAfter,
-            ["force"] = force,
-            ["timeout"] = timeout,
-        };
-
-        return (await Connection.SendMessageToServerAsync(Object, "selectOption", args).ConfigureAwait(false))?.GetProperty("values").ToObject<string[]>();
-    }
-
-    internal async Task<IReadOnlyList<string>> SelectOptionAsync(IEnumerable<IElementHandle> values, bool? noWaitAfter, bool? force, float? timeout)
-    {
-        var args = new Dictionary<string, object>
-        {
-            ["elements"] = values,
-            ["noWaitAfter"] = noWaitAfter,
-            ["force"] = force,
-            ["timeout"] = timeout,
-        };
-
-        return (await Connection.SendMessageToServerAsync(Object, "selectOption", args).ConfigureAwait(false))?.GetProperty("values").ToObject<string[]>();
-    }
-
-    internal async Task<bool> IsVisibleAsync()
-        => (await Connection.SendMessageToServerAsync(Object, "isVisible").ConfigureAwait(false))?.GetProperty("value").GetBoolean() ?? default;
-
-    internal async Task<bool> IsHiddenAsync()
-        => (await Connection.SendMessageToServerAsync(Object, "isHidden").ConfigureAwait(false))?.GetProperty("value").GetBoolean() ?? default;
-
-    internal async Task<bool> IsEnabledAsync()
-        => (await Connection.SendMessageToServerAsync(Object, "isEnabled").ConfigureAwait(false))?.GetProperty("value").GetBoolean() ?? default;
-
-    internal async Task<bool> IsEditableAsync()
-        => (await Connection.SendMessageToServerAsync(Object, "isEditable").ConfigureAwait(false))?.GetProperty("value").GetBoolean() ?? default;
-
-    internal async Task<bool> IsDisabledAsync()
-        => (await Connection.SendMessageToServerAsync(Object, "isDisabled").ConfigureAwait(false))?.GetProperty("value").GetBoolean() ?? default;
-
-    internal async Task<string> InputValueAsync(float? timeout)
-    {
-        var args = new Dictionary<string, object>()
-            {
-                { "timeout", timeout },
-            };
-
-        return (await Connection.SendMessageToServerAsync(Object, "inputValue", args).ConfigureAwait(false))?.GetProperty("value").GetString();
-    }
-
-    internal async Task<bool> IsCheckedAsync()
-        => (await Connection.SendMessageToServerAsync(Object, "isChecked").ConfigureAwait(false))?.GetProperty("value").GetBoolean() ?? default;
-
-    internal Task CheckAsync(Position position, float? timeout, bool? force, bool? noWaitAfter, bool? trial)
-    {
-        var args = new Dictionary<string, object>
-        {
-            ["force"] = force,
-            ["position"] = position,
-            ["trial"] = trial,
-            ["timeout"] = timeout,
-            ["noWaitAfter"] = noWaitAfter,
-        };
-
-        return Connection.SendMessageToServerAsync<ElementHandleChannel>(Object, "check", args);
-    }
-
-    internal Task UncheckAsync(Position position, float? timeout, bool? force, bool? noWaitAfter, bool? trial)
-    {
-        var args = new Dictionary<string, object>
-        {
-            ["force"] = force,
-            ["position"] = position,
-            ["trial"] = trial,
-            ["timeout"] = timeout,
-            ["noWaitAfter"] = noWaitAfter,
-        };
-
-        return Connection.SendMessageToServerAsync<ElementHandleChannel>(Object, "uncheck", args);
-    }
-
-    internal Task TypeAsync(string text, float? delay, float? timeout, bool? noWaitAfter)
-    {
-        var args = new Dictionary<string, object>
-        {
-            ["text"] = text,
-            ["delay"] = delay,
-            ["timeout"] = timeout,
-            ["noWaitAfter"] = noWaitAfter,
-        };
-
-        return Connection.SendMessageToServerAsync(Object, "type", args);
-    }
-
-    internal Task PressAsync(string key, float? delay, float? timeout, bool? noWaitAfter)
-    {
-        var args = new Dictionary<string, object>
-        {
-            ["key"] = key,
-            ["delay"] = delay,
-            ["timeout"] = timeout,
-            ["noWaitAfter"] = noWaitAfter,
-        };
-
-        return Connection.SendMessageToServerAsync(Object, "press", args);
-    }
-
-    internal Task TapAsync(
-        Position position,
-        IEnumerable<KeyboardModifier> modifiers,
-        float? timeout,
-        bool? force,
-        bool? noWaitAfter,
-        bool? trial)
-    {
-        var args = new Dictionary<string, object>
-        {
-            ["force"] = force,
-            ["noWaitAfter"] = noWaitAfter,
-            ["position"] = position,
-            ["modifiers"] = modifiers?.Select(m => m.ToValueString()),
-            ["trial"] = trial,
-            ["timeout"] = timeout,
-        };
-
-        return Connection.SendMessageToServerAsync(Object, "tap", args);
-    }
 }
diff --git a/src/Playwright/Transport/Channels/FrameChannel.cs b/src/Playwright/Transport/Channels/FrameChannel.cs
index 1764f495a8..b682ce2a0c 100644
--- a/src/Playwright/Transport/Channels/FrameChannel.cs
+++ b/src/Playwright/Transport/Channels/FrameChannel.cs
@@ -22,14 +22,7 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  */
-using System.Collections.Generic;
-using System.Linq;
-using System.Text.Json;
-using System.Text.Json.Serialization;
-using System.Threading.Tasks;
 using Microsoft.Playwright.Core;
-using Microsoft.Playwright.Helpers;
-using Microsoft.Playwright.Transport.Protocol;
 
 namespace Microsoft.Playwright.Transport.Channels;
 
@@ -38,713 +31,4 @@ internal class FrameChannel : Channel<Frame>
     public FrameChannel(string guid, Connection connection, Frame owner) : base(guid, connection, owner)
     {
     }
-
-
-    internal Task<ElementHandleChannel> QuerySelectorAsync(string selector, bool? strict)
-    {
-        var args = new Dictionary<string, object>
-        {
-            ["selector"] = selector,
-            ["strict"] = strict,
-        };
-
-        return Connection.SendMessageToServerAsync<ElementHandleChannel>(Object, "querySelector", args);
-    }
-
-    internal Task<ResponseChannel> GotoAsync(string url, float? timeout, WaitUntilState? waitUntil, string referer)
-    {
-        var args = new Dictionary<string, object>
-        {
-            ["url"] = url,
-            ["timeout"] = timeout,
-            ["waitUntil"] = waitUntil,
-            ["referer"] = referer,
-        };
-        return Connection.SendMessageToServerAsync<ResponseChannel>(Object, "goto", args);
-    }
-
-    internal Task<JSHandleChannel> EvaluateExpressionHandleAsync(
-        string script,
-        object arg)
-    {
-        return Connection.SendMessageToServerAsync<JSHandleChannel>(
-            Object,
-            "evaluateExpressionHandle",
-            new Dictionary<string, object>
-            {
-                ["expression"] = script,
-                ["arg"] = arg,
-            });
-    }
-
-    internal Task<JSHandleChannel> WaitForFunctionAsync(
-        string expression,
-        object arg,
-        float? timeout,
-        float? polling)
-    {
-        var args = new Dictionary<string, object>
-        {
-            ["expression"] = expression,
-            ["arg"] = arg,
-            ["timeout"] = timeout,
-            ["pollingInterval"] = polling,
-        };
-        return Connection.SendMessageToServerAsync<JSHandleChannel>(
-            Object,
-            "waitForFunction",
-            args);
-    }
-
-    internal Task<JsonElement?> EvaluateExpressionAsync(
-        string script,
-        object arg)
-    {
-        return Connection.SendMessageToServerAsync<JsonElement?>(
-            Object,
-            "evaluateExpression",
-            new Dictionary<string, object>
-            {
-                ["expression"] = script,
-                ["arg"] = arg,
-            });
-    }
-
-    internal Task<JsonElement?> EvalOnSelectorAsync(string selector, string script, object arg, bool? strict)
-        => Connection.SendMessageToServerAsync<JsonElement?>(
-            Object,
-            "evalOnSelector",
-            new Dictionary<string, object>
-            {
-                ["selector"] = selector,
-                ["expression"] = script,
-                ["arg"] = arg,
-                ["strict"] = strict,
-            });
-
-    internal Task<JsonElement?> EvalOnSelectorAllAsync(string selector, string script, object arg)
-        => Connection.SendMessageToServerAsync<JsonElement?>(
-            Object,
-            "evalOnSelectorAll",
-            new Dictionary<string, object>
-            {
-                ["selector"] = selector,
-                ["expression"] = script,
-                ["arg"] = arg,
-            });
-
-    internal Task<ElementHandleChannel> FrameElementAsync() => Connection.SendMessageToServerAsync<ElementHandleChannel>(Object, "frameElement");
-
-    internal async Task<string> TitleAsync()
-        => (await Connection.SendMessageToServerAsync(Object, "title").ConfigureAwait(false))?.GetProperty("value").ToString();
-
-    internal Task<ElementHandleChannel> WaitForSelectorAsync(string selector, WaitForSelectorState? state, float? timeout, bool? strict, bool? omitReturnValue = default)
-    {
-        var args = new Dictionary<string, object>
-        {
-            ["selector"] = selector,
-            ["timeout"] = timeout,
-            ["state"] = state,
-            ["strict"] = strict,
-            ["omitReturnValue"] = omitReturnValue,
-        };
-        return Connection.SendMessageToServerAsync<ElementHandleChannel>(
-            Object,
-            "waitForSelector",
-            args);
-    }
-
-    internal Task WaitForTimeoutAsync(float timeout)
-    {
-        var args = new Dictionary<string, object>
-        {
-            ["timeout"] = timeout,
-        };
-        return Connection.SendMessageToServerAsync<ElementHandleChannel>(
-            Object,
-            "waitForTimeout",
-            args);
-    }
-
-    internal Task<ElementHandleChannel> AddScriptTagAsync(string url, string path, string content, string type)
-    {
-        var args = new Dictionary<string, object>
-        {
-            ["url"] = url,
-            ["path"] = path,
-            ["content"] = content,
-            ["type"] = type,
-        };
-        return Connection.SendMessageToServerAsync<ElementHandleChannel>(Object, "addScriptTag", args);
-    }
-
-    internal Task BlurAsync(string selector, bool strict, float? timeout)
-    {
-        var args = new Dictionary<string, object>
-        {
-            ["selector"] = selector,
-            ["strict"] = strict,
-            ["timeout"] = timeout,
-        };
-        return Connection.SendMessageToServerAsync(Object, "blur", args);
-    }
-
-    internal Task<ElementHandleChannel> AddStyleTagAsync(string url, string path, string content)
-    {
-        var args = new Dictionary<string, object>
-        {
-            ["url"] = url,
-            ["path"] = path,
-            ["content"] = content,
-        };
-        return Connection.SendMessageToServerAsync<ElementHandleChannel>(Object, "addStyleTag", args);
-    }
-
-    internal Task<ResponseChannel> WaitForNavigationAsync(LoadState? waitUntil, string url, float? timeout)
-    {
-        var args = new Dictionary<string, object>
-        {
-            ["timeout"] = timeout,
-            ["url"] = url,
-            ["waitUntil"] = waitUntil,
-        };
-
-        return Connection.SendMessageToServerAsync<ResponseChannel>(Object, "waitForNavigation", args);
-    }
-
-    internal Task WaitForLoadStateAsync(LoadState? state, float? timeout)
-    {
-        var args = new Dictionary<string, object>
-        {
-            ["timeout"] = timeout,
-            ["state"] = state,
-        };
-
-        return Connection.SendMessageToServerAsync(
-            Object,
-            "waitForLoadState",
-            args);
-    }
-
-    internal async Task<int> QueryCountAsync(string selector)
-    {
-        var args = new Dictionary<string, object>
-        {
-            ["selector"] = selector,
-        };
-
-        var result = await Connection.SendMessageToServerAsync(Object, "queryCount", args).ConfigureAwait(false);
-        return result.Value.GetProperty("value").GetInt32();
-    }
-
-    internal Task SetContentAsync(string html, float? timeout, WaitUntilState? waitUntil)
-    {
-        var args = new Dictionary<string, object>
-        {
-            ["html"] = html,
-            ["waitUntil"] = waitUntil,
-            ["timeout"] = timeout,
-        };
-
-        return Connection.SendMessageToServerAsync(Object, "setContent", args);
-    }
-
-    internal Task ClickAsync(
-        string selector,
-        float? delay,
-        MouseButton? button,
-        int? clickCount,
-        IEnumerable<KeyboardModifier> modifiers,
-        Position position,
-        float? timeout,
-        bool? force,
-        bool? noWaitAfter,
-        bool? trial,
-        bool? strict)
-    {
-        var args = new Dictionary<string, object>
-        {
-            ["selector"] = selector,
-            ["button"] = button,
-            ["force"] = force,
-            ["delay"] = delay,
-            ["clickCount"] = clickCount,
-            ["modifiers"] = modifiers?.Select(m => m.ToValueString()),
-            ["position"] = position,
-            ["noWaitAfter"] = noWaitAfter,
-            ["trial"] = trial,
-            ["timeout"] = timeout,
-            ["strict"] = strict,
-        };
-
-        return Connection.SendMessageToServerAsync<ElementHandleChannel>(Object, "click", args);
-    }
-
-    internal Task DblClickAsync(
-        string selector,
-        float? delay,
-        MouseButton? button,
-        Position position,
-        IEnumerable<KeyboardModifier> modifiers,
-        float? timeout,
-        bool? force,
-        bool? noWaitAfter,
-        bool? trial,
-        bool? strict)
-    {
-        var args = new Dictionary<string, object>
-        {
-            ["selector"] = selector,
-            ["button"] = button,
-            ["delay"] = delay,
-            ["force"] = force,
-            ["modifiers"] = modifiers?.Select(m => m.ToValueString()),
-            ["position"] = position,
-            ["trial"] = trial,
-            ["timeout"] = timeout,
-            ["noWaitAfter"] = noWaitAfter,
-            ["strict"] = strict,
-        };
-
-        return Connection.SendMessageToServerAsync<ElementHandleChannel>(Object, "dblclick", args);
-    }
-
-    internal Task<ElementHandleChannel> QuerySelectorAsync(string selector)
-        => Connection.SendMessageToServerAsync<ElementHandleChannel>(
-            Object,
-            "querySelector",
-            new Dictionary<string, object>
-            {
-                ["selector"] = selector,
-            });
-
-    internal Task<ChannelBase[]> QuerySelectorAllAsync(string selector)
-        => Connection.SendMessageToServerAsync<ChannelBase[]>(
-            Object,
-            "querySelectorAll",
-            new Dictionary<string, object>
-            {
-                ["selector"] = selector,
-            });
-
-    internal Task FillAsync(string selector, string value, bool? force, float? timeout, bool? noWaitAfter, bool? strict)
-    {
-        var args = new Dictionary<string, object>
-        {
-            ["selector"] = selector,
-            ["value"] = value,
-            ["force"] = force,
-            ["timeout"] = timeout,
-            ["noWaitAfter"] = noWaitAfter,
-            ["strict"] = strict,
-        };
-
-        return Connection.SendMessageToServerAsync(Object, "fill", args);
-    }
-
-    internal Task CheckAsync(string selector, Position position, float? timeout, bool? force, bool? noWaitAfter, bool? trial, bool? strict)
-    {
-        var args = new Dictionary<string, object>
-        {
-            ["selector"] = selector,
-            ["force"] = force,
-            ["position"] = position,
-            ["noWaitAfter"] = noWaitAfter,
-            ["trial"] = trial,
-            ["timeout"] = timeout,
-            ["strict"] = strict,
-        };
-
-        return Connection.SendMessageToServerAsync<ElementHandleChannel>(Object, "check", args);
-    }
-
-    internal Task UncheckAsync(string selector, Position position, float? timeout, bool? force, bool? noWaitAfter, bool? trial, bool? strict)
-    {
-        var args = new Dictionary<string, object>
-        {
-            ["selector"] = selector,
-            ["force"] = force,
-            ["position"] = position,
-            ["noWaitAfter"] = noWaitAfter,
-            ["trial"] = trial,
-            ["timeout"] = timeout,
-            ["strict"] = strict,
-        };
-
-        return Connection.SendMessageToServerAsync<ElementHandleChannel>(Object, "uncheck", args);
-    }
-
-    internal Task DispatchEventAsync(string selector, string type, object eventInit, float? timeout, bool? strict)
-    {
-        var args = new Dictionary<string, object>
-        {
-            ["selector"] = selector,
-            ["type"] = type,
-            ["eventInit"] = eventInit,
-            ["timeout"] = timeout,
-            ["strict"] = strict,
-        };
-
-        return Connection.SendMessageToServerAsync(Object, "dispatchEvent", args);
-    }
-
-    internal Task HoverAsync(
-        string selector,
-        Position position,
-        IEnumerable<KeyboardModifier> modifiers,
-        bool? force,
-        bool? noWaitAfter,
-        float? timeout,
-        bool? trial,
-        bool? strict)
-    {
-        var args = new Dictionary<string, object>
-        {
-            ["selector"] = selector,
-            ["force"] = force,
-            ["modifiers"] = modifiers?.Select(m => m.ToValueString()),
-            ["position"] = position,
-            ["trial"] = trial,
-            ["timeout"] = timeout,
-            ["strict"] = strict,
-            ["noWaitAfter"] = noWaitAfter,
-        };
-
-        return Connection.SendMessageToServerAsync(Object, "hover", args);
-    }
-
-    internal Task PressAsync(string selector, string text, float? delay, float? timeout, bool? noWaitAfter, bool? strict)
-    {
-        var args = new Dictionary<string, object>
-        {
-            ["selector"] = selector,
-            ["key"] = text,
-            ["delay"] = delay,
-            ["timeout"] = timeout,
-            ["noWaitAfter"] = noWaitAfter,
-            ["strict"] = strict,
-        };
-
-        return Connection.SendMessageToServerAsync(Object, "press", args);
-    }
-
-    internal async Task<string[]> SelectOptionAsync(string selector, IEnumerable<SelectOptionValueProtocol> values, bool? noWaitAfter, bool? strict, bool? force, float? timeout)
-    {
-        var args = new Dictionary<string, object>
-        {
-            ["selector"] = selector,
-            ["options"] = values,
-            ["noWaitAfter"] = noWaitAfter,
-            ["strict"] = strict,
-            ["force"] = force,
-            ["timeout"] = timeout,
-        };
-
-        return (await Connection.SendMessageToServerAsync(Object, "selectOption", args).ConfigureAwait(false))?.GetProperty("values").ToObject<string[]>();
-    }
-
-    internal async Task<string[]> SelectOptionAsync(string selector, IEnumerable<ElementHandle> values, bool? noWaitAfter, bool? strict, bool? force, float? timeout)
-    {
-        var args = new Dictionary<string, object>
-        {
-            ["selector"] = selector,
-            ["elements"] = values,
-            ["noWaitAfter"] = noWaitAfter,
-            ["strict"] = strict,
-            ["force"] = force,
-            ["timeout"] = timeout,
-        };
-
-        return (await Connection.SendMessageToServerAsync(Object, "selectOption", args).ConfigureAwait(false))?.GetProperty("values").ToObject<string[]>();
-    }
-
-    internal async Task<string> GetAttributeAsync(string selector, string name, float? timeout, bool? strict)
-    {
-        var args = new Dictionary<string, object>
-        {
-            ["selector"] = selector,
-            ["name"] = name,
-            ["timeout"] = timeout,
-            ["strict"] = strict,
-        };
-
-        JsonElement retValue = default;
-        if ((await Connection.SendMessageToServerAsync(Object, "getAttribute", args).ConfigureAwait(false))?.TryGetProperty("value", out retValue) ?? false)
-        {
-            return retValue.ToString();
-        }
-
-        return null;
-    }
-
-    internal async Task<string> InnerHTMLAsync(string selector, float? timeout, bool? strict)
-    {
-        var args = new Dictionary<string, object>
-        {
-            ["selector"] = selector,
-            ["timeout"] = timeout,
-            ["strict"] = strict,
-        };
-
-        return (await Connection.SendMessageToServerAsync(Object, "innerHTML", args).ConfigureAwait(false))?.GetProperty("value").ToString();
-    }
-
-    internal Task TypeAsync(string selector, string text, float? delay, float? timeout, bool? noWaitAfter, bool? strict)
-    {
-        var args = new Dictionary<string, object>
-        {
-            ["selector"] = selector,
-            ["text"] = text,
-            ["delay"] = delay,
-            ["noWaitAfter"] = noWaitAfter,
-            ["timeout"] = timeout,
-            ["strict"] = strict,
-        };
-
-        return Connection.SendMessageToServerAsync(Object, "type", args);
-    }
-
-    internal async Task<string> ContentAsync()
-        => (await Connection.SendMessageToServerAsync(Object, "content").ConfigureAwait(false))?.GetProperty("value").ToString();
-
-    internal Task FocusAsync(string selector, float? timeout, bool? strict)
-    {
-        var args = new Dictionary<string, object>
-        {
-            ["selector"] = selector,
-            ["timeout"] = timeout,
-            ["strict"] = strict,
-        };
-
-        return Connection.SendMessageToServerAsync(Object, "focus", args);
-    }
-
-    internal async Task<string> InnerTextAsync(string selector, float? timeout, bool? strict)
-    {
-        var args = new Dictionary<string, object>
-        {
-            ["selector"] = selector,
-            ["timeout"] = timeout,
-            ["strict"] = strict,
-        };
-
-        return (await Connection.SendMessageToServerAsync(Object, "innerText", args).ConfigureAwait(false))?.GetProperty("value").ToString();
-    }
-
-    internal Task SetInputFilesAsync(string selector, SetInputFilesFiles files, bool? noWaitAfter, float? timeout, bool? strict)
-    {
-        var args = new Dictionary<string, object>
-        {
-            ["selector"] = selector,
-            ["payloads"] = files.Payloads,
-            ["localPaths"] = files.LocalPaths,
-            ["streams"] = files.Streams,
-            ["noWaitAfter"] = noWaitAfter,
-            ["timeout"] = timeout,
-            ["strict"] = strict,
-        };
-
-        return Connection.SendMessageToServerAsync(Object, "setInputFiles", args);
-    }
-
-    internal async Task<string> TextContentAsync(string selector, float? timeout, bool? strict)
-    {
-        var args = new Dictionary<string, object>
-        {
-            ["selector"] = selector,
-            ["timeout"] = timeout,
-            ["strict"] = strict,
-        };
-
-        return (await Connection.SendMessageToServerAsync(Object, "textContent", args).ConfigureAwait(false))?.GetProperty("value").ToString();
-    }
-
-    internal Task TapAsync(
-        string selector,
-        IEnumerable<KeyboardModifier> modifiers,
-        Position position,
-        float? timeout,
-        bool? force,
-        bool? noWaitAfter,
-        bool? trial,
-        bool? strict)
-    {
-        var args = new Dictionary<string, object>
-        {
-            ["selector"] = selector,
-            ["force"] = force,
-            ["modifiers"] = modifiers?.Select(m => m.ToValueString()),
-            ["noWaitAfter"] = noWaitAfter,
-            ["trial"] = trial,
-            ["timeout"] = timeout,
-            ["position"] = position,
-            ["strict"] = strict,
-        };
-
-        return Connection.SendMessageToServerAsync(Object, "tap", args);
-    }
-
-    internal async Task<bool> IsCheckedAsync(string selector, float? timeout, bool? strict)
-    {
-        var args = new Dictionary<string, object>
-        {
-            ["selector"] = selector,
-            ["timeout"] = timeout,
-            ["strict"] = strict,
-        };
-
-        return (await Connection.SendMessageToServerAsync(Object, "isChecked", args).ConfigureAwait(false))?.GetProperty("value").GetBoolean() ?? default;
-    }
-
-    internal async Task<bool> IsDisabledAsync(string selector, float? timeout, bool? strict)
-    {
-        var args = new Dictionary<string, object>
-        {
-            ["selector"] = selector,
-            ["timeout"] = timeout,
-            ["strict"] = strict,
-        };
-
-        return (await Connection.SendMessageToServerAsync(Object, "isDisabled", args).ConfigureAwait(false))?.GetProperty("value").GetBoolean() ?? default;
-    }
-
-    internal async Task<bool> IsEditableAsync(string selector, float? timeout, bool? strict)
-    {
-        var args = new Dictionary<string, object>
-        {
-            ["selector"] = selector,
-            ["timeout"] = timeout,
-            ["strict"] = strict,
-        };
-
-        return (await Connection.SendMessageToServerAsync(Object, "isEditable", args).ConfigureAwait(false))?.GetProperty("value").GetBoolean() ?? default;
-    }
-
-    internal async Task<bool> IsEnabledAsync(string selector, float? timeout, bool? strict)
-    {
-        var args = new Dictionary<string, object>
-        {
-            ["selector"] = selector,
-            ["timeout"] = timeout,
-            ["strict"] = strict,
-        };
-
-        return (await Connection.SendMessageToServerAsync(Object, "isEnabled", args).ConfigureAwait(false))?.GetProperty("value").GetBoolean() ?? default;
-    }
-
-    internal async Task<bool> IsHiddenAsync(string selector, float? timeout, bool? strict)
-    {
-        var args = new Dictionary<string, object>
-        {
-            ["selector"] = selector,
-            ["timeout"] = timeout,
-            ["strict"] = strict,
-        };
-
-        return (await Connection.SendMessageToServerAsync(Object, "isHidden", args).ConfigureAwait(false))?.GetProperty("value").GetBoolean() ?? default;
-    }
-
-    internal async Task<bool> IsVisibleAsync(string selector, float? timeout, bool? strict)
-    {
-        var args = new Dictionary<string, object>
-        {
-            ["selector"] = selector,
-            ["timeout"] = timeout,
-            ["strict"] = strict,
-        };
-
-        return (await Connection.SendMessageToServerAsync(Object, "isVisible", args).ConfigureAwait(false))?.GetProperty("value").GetBoolean() ?? default;
-    }
-
-    internal async Task<string> InputValueAsync(string selector, float? timeout, bool? strict)
-    {
-        var args = new Dictionary<string, object>
-        {
-            ["selector"] = selector,
-            ["timeout"] = timeout,
-            ["strict"] = strict,
-        };
-
-        return (await Connection.SendMessageToServerAsync(Object, "inputValue", args).ConfigureAwait(false))?.GetProperty("value").ToString();
-    }
-
-    internal Task DragAndDropAsync(string source, string target, bool? force, bool? noWaitAfter, float? timeout, bool? trial, bool? strict, SourcePosition sourcePosition, TargetPosition targetPosition)
-    {
-        var args = new Dictionary<string, object>
-        {
-            ["source"] = source,
-            ["target"] = target,
-            ["force"] = force,
-            ["noWaitAfter"] = noWaitAfter,
-            ["timeout"] = timeout,
-            ["trial"] = trial,
-            ["strict"] = strict,
-            ["sourcePosition"] = sourcePosition,
-            ["targetPosition"] = targetPosition,
-        };
-
-        return Connection.SendMessageToServerAsync(Object, "dragAndDrop", args);
-    }
-
-    internal async Task<FrameExpectResult> ExpectAsync(string selector, string expression, object expressionArg, ExpectedTextValue[] expectedText, float? expectedNumber, object expectedValue, bool? useInnerText, bool? isNot, float? timeout)
-    {
-        var args = new Dictionary<string, object>
-        {
-            ["selector"] = selector,
-            ["expression"] = expression,
-            ["expressionArg"] = expressionArg,
-            ["expectedText"] = expectedText,
-            ["expectedNumber"] = expectedNumber,
-            ["expectedValue"] = expectedValue,
-            ["useInnerText"] = useInnerText,
-            ["isNot"] = isNot,
-            ["timeout"] = timeout,
-        };
-        var result = await Connection.SendMessageToServerAsync(Object, "expect", args).ConfigureAwait(false);
-        var parsed = result.Value.ToObject<FrameExpectResult>();
-        if (result.Value.TryGetProperty("received", out var received))
-        {
-            var outs = ScriptsHelper.ParseEvaluateResult<object>(received);
-            parsed.Received = outs;
-        }
-        return parsed;
-    }
-
-    internal async Task HighlightAsync(string selector)
-    {
-        var args = new Dictionary<string, object>
-        {
-            ["selector"] = selector,
-        };
-
-        await Connection.SendMessageToServerAsync(Object, "highlight", args).ConfigureAwait(false);
-    }
-}
-
-internal class SelectOptionValueProtocol
-{
-
-#nullable enable
-    [JsonPropertyName("value")]
-    public string? Value { get; set; }
-
-    [JsonPropertyName("valueOrLabel")]
-    public string? ValueOrLabel { get; set; }
-
-    [JsonPropertyName("label")]
-    public string? Label { get; set; }
-
-    [JsonPropertyName("index")]
-    public int? Index { get; set; }
-#nullable disable
-
-    internal static SelectOptionValueProtocol From(SelectOptionValue value)
-    {
-        return new SelectOptionValueProtocol
-        {
-            Value = value.Value,
-            Label = value.Label,
-            Index = value.Index,
-        };
-    }
 }
diff --git a/src/Playwright/Transport/Channels/JSHandleChannel.cs b/src/Playwright/Transport/Channels/JSHandleChannel.cs
index 118be748fc..cce86cec0f 100644
--- a/src/Playwright/Transport/Channels/JSHandleChannel.cs
+++ b/src/Playwright/Transport/Channels/JSHandleChannel.cs
@@ -22,11 +22,7 @@
  * SOFTWARE.
  */
 
-using System.Collections.Generic;
-using System.Text.Json;
-using System.Threading.Tasks;
 using Microsoft.Playwright.Core;
-using Microsoft.Playwright.Helpers;
 
 namespace Microsoft.Playwright.Transport.Channels;
 
@@ -35,48 +31,4 @@ internal class JSHandleChannel : Channel<JSHandle>
     public JSHandleChannel(string guid, Connection connection, JSHandle owner) : base(guid, connection, owner)
     {
     }
-
-    internal Task<JsonElement?> EvaluateExpressionAsync(string script, object arg)
-        => Connection.SendMessageToServerAsync<JsonElement?>(
-            Object,
-            "evaluateExpression",
-            new Dictionary<string, object>
-            {
-                ["expression"] = script,
-                ["arg"] = arg,
-            });
-
-    internal Task<JSHandleChannel> EvaluateExpressionHandleAsync(string script, object arg)
-        => Connection.SendMessageToServerAsync<JSHandleChannel>(
-            Object,
-            "evaluateExpressionHandle",
-            new Dictionary<string, object>
-            {
-                ["expression"] = script,
-                ["arg"] = arg,
-            });
-
-    internal Task<JsonElement> JsonValueAsync() => Connection.SendMessageToServerAsync<JsonElement>(Object, "jsonValue");
-
-    internal Task DisposeAsync() => Connection.SendMessageToServerAsync(Object, "dispose");
-
-    internal Task<JSHandleChannel> GetPropertyAsync(string propertyName)
-        => Connection.SendMessageToServerAsync<JSHandleChannel>(
-            Object,
-            "getProperty",
-            new Dictionary<string, object>
-            {
-                ["name"] = propertyName,
-            });
-
-    internal async Task<List<JSElementProperty>> GetPropertiesAsync()
-        => (await Connection.SendMessageToServerAsync(Object, "getPropertyList").ConfigureAwait(false))?
-            .GetProperty("properties").ToObject<List<JSElementProperty>>(Connection.DefaultJsonSerializerOptions);
-
-    internal class JSElementProperty
-    {
-        public string Name { get; set; }
-
-        public JSHandleChannel Value { get; set; }
-    }
 }
diff --git a/src/Playwright/Transport/Channels/JsonPipeChannel.cs b/src/Playwright/Transport/Channels/JsonPipeChannel.cs
index b0c6a1e1bc..9750551390 100644
--- a/src/Playwright/Transport/Channels/JsonPipeChannel.cs
+++ b/src/Playwright/Transport/Channels/JsonPipeChannel.cs
@@ -22,8 +22,6 @@
  * SOFTWARE.
  */
 
-using System.Collections.Generic;
-using System.Threading.Tasks;
 using Microsoft.Playwright.Core;
 
 namespace Microsoft.Playwright.Transport.Channels;
@@ -33,12 +31,4 @@ internal class JsonPipeChannel : Channel<JsonPipe>
     public JsonPipeChannel(string guid, Connection connection, JsonPipe owner) : base(guid, connection, owner)
     {
     }
-
-    internal Task SendAsync(object message) =>
-        Connection.SendMessageToServerAsync(Object, "send", new Dictionary<string, object>
-        {
-                { "message", message },
-        });
-
-    internal Task CloseAsync() => Connection.SendMessageToServerAsync(Object, "close");
 }
diff --git a/src/Playwright/Transport/Channels/LocalUtilsChannel.cs b/src/Playwright/Transport/Channels/LocalUtilsChannel.cs
index fa917635dc..7cd10a43be 100644
--- a/src/Playwright/Transport/Channels/LocalUtilsChannel.cs
+++ b/src/Playwright/Transport/Channels/LocalUtilsChannel.cs
@@ -22,12 +22,7 @@
  * SOFTWARE.
  */
 
-using System;
-using System.Collections.Generic;
-using System.Threading.Tasks;
 using Microsoft.Playwright.Core;
-using Microsoft.Playwright.Helpers;
-using Microsoft.Playwright.Transport.Protocol;
 
 namespace Microsoft.Playwright.Transport.Channels;
 
@@ -36,97 +31,4 @@ internal class LocalUtilsChannel : Channel<LocalUtils>
     public LocalUtilsChannel(string guid, Connection connection, LocalUtils owner) : base(guid, connection, owner)
     {
     }
-
-    internal Task ZipAsync(string zipFile, List<NameValue> entries, string mode, string stacksId, bool includeSources) =>
-        Connection.SendMessageToServerAsync(Object, "zip", new Dictionary<string, object>
-        {
-                { "zipFile", zipFile },
-                { "entries", entries },
-                { "mode", mode },
-                { "stacksId", stacksId },
-                { "includeSources", includeSources },
-        });
-
-    internal async Task<(string HarId, string Error)> HarOpenAsync(string file)
-    {
-        var response = await Connection.SendMessageToServerAsync(Object, "harOpen", new Dictionary<string, object>
-            {
-                  { "file", file },
-            }).ConfigureAwait(false);
-        return (response.GetString("harId", true), response.GetString("error", true));
-    }
-
-    internal async Task<LocalUtilsHarLookupResult> HarLookupAsync(
-        string harId,
-        string url,
-        string method,
-        List<Header> headers,
-        byte[] postData,
-        bool isNavigationRequest)
-    {
-        var response = await Connection.SendMessageToServerAsync<LocalUtilsHarLookupResult>(Object, "harLookup", new Dictionary<string, object>
-            {
-                { "harId", harId },
-                { "url", url },
-                { "method", method },
-                { "headers", headers },
-                { "postData", postData != null ? Convert.ToBase64String(postData) : null },
-                { "isNavigationRequest", isNavigationRequest },
-            }).ConfigureAwait(false);
-        return response;
-    }
-
-    internal Task HarCloseAsync(string harId) =>
-        Connection.SendMessageToServerAsync(Object, "HarCloseAsync", new Dictionary<string, object>
-        {
-                  { "harId", harId },
-        });
-
-    internal Task HarUnzipAsync(string zipFile, string harFile) =>
-        Connection.SendMessageToServerAsync(Object, "harUnzip", new Dictionary<string, object>
-        {
-                  { "zipFile", zipFile },
-                  { "harFile", harFile },
-        });
-
-    internal async Task<JsonPipe> ConnectAsync(string wsEndpoint, IEnumerable<KeyValuePair<string, string>> headers, float? slowMo, float? timeout, string exposeNetwork)
-    {
-        var args = new Dictionary<string, object>
-            {
-                { "wsEndpoint", wsEndpoint },
-                { "headers", headers },
-                { "slowMo", slowMo },
-                { "timeout", timeout },
-                { "exposeNetwork", exposeNetwork },
-            };
-        return (await Connection.SendMessageToServerAsync(Object, "connect", args).ConfigureAwait(false)).Value.GetObject<JsonPipe>("pipe", Connection);
-    }
-
-    internal void AddStackToTracingNoReply(List<StackFrame> frames, int id)
-        => Connection.SendMessageToServerAsync(Object, "addStackToTracingNoReply", new Dictionary<string, object>
-        {
-            {
-                "callData", new ClientSideCallMetadata()
-                {
-                    Id = id,
-                    Stack = frames,
-                }
-            },
-        }).IgnoreException();
-
-    internal Task TraceDiscardedAsync(string stacksId)
-        => Connection.SendMessageToServerAsync(Object, "traceDiscarded", new Dictionary<string, object>
-        {
-            { "stacksId", stacksId },
-        });
-
-    internal async Task<string> TracingStartedAsync(string tracesDir, string traceName)
-    {
-        var response = await Connection.SendMessageToServerAsync(Object, "tracingStarted", new Dictionary<string, object>
-        {
-            { "tracesDir", tracesDir },
-            { "traceName", traceName },
-        }).ConfigureAwait(false);
-        return response.GetString("stacksId", true);
-    }
 }
diff --git a/src/Playwright/Transport/Channels/PageChannel.cs b/src/Playwright/Transport/Channels/PageChannel.cs
index ab7ac38c64..bb5b444de9 100644
--- a/src/Playwright/Transport/Channels/PageChannel.cs
+++ b/src/Playwright/Transport/Channels/PageChannel.cs
@@ -22,12 +22,7 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  */
-using System.Collections.Generic;
-using System.Linq;
-using System.Text.Json;
-using System.Threading.Tasks;
 using Microsoft.Playwright.Core;
-using Microsoft.Playwright.Transport.Protocol;
 
 namespace Microsoft.Playwright.Transport.Channels;
 
@@ -36,323 +31,4 @@ internal class PageChannel : Channel<Page>
     public PageChannel(string guid, Connection connection, Page owner) : base(guid, connection, owner)
     {
     }
-
-    internal Task SetDefaultTimeoutNoReplyAsync(float timeout)
-        => Connection.SendMessageToServerAsync<PageChannel>(
-            Object,
-            "setDefaultTimeoutNoReply",
-            new Dictionary<string, object>
-            {
-                ["timeout"] = timeout,
-            });
-
-    internal Task SetDefaultNavigationTimeoutNoReplyAsync(float timeout)
-        => Connection.SendMessageToServerAsync<PageChannel>(
-            Object,
-            "setDefaultNavigationTimeoutNoReply",
-            new Dictionary<string, object>
-            {
-                ["timeout"] = timeout,
-            });
-
-    internal Task CloseAsync(bool runBeforeUnload)
-        => Connection.SendMessageToServerAsync(
-            Object,
-            "close",
-            new Dictionary<string, object>
-            {
-                ["runBeforeUnload"] = runBeforeUnload,
-            });
-
-    internal Task ExposeBindingAsync(string name, bool needsHandle)
-        => Connection.SendMessageToServerAsync<PageChannel>(
-            Object,
-            "exposeBinding",
-            new Dictionary<string, object>
-            {
-                ["name"] = name,
-                ["needsHandle"] = needsHandle,
-            });
-
-    internal Task AddInitScriptAsync(string script)
-        => Connection.SendMessageToServerAsync<PageChannel>(
-            Object,
-            "addInitScript",
-            new Dictionary<string, object>
-            {
-                ["source"] = script,
-            });
-
-    internal Task BringToFrontAsync() => Connection.SendMessageToServerAsync(Object, "bringToFront");
-
-    internal Task<ResponseChannel> GoBackAsync(float? timeout, WaitUntilState? waitUntil)
-    {
-        var args = new Dictionary<string, object>
-        {
-            ["timeout"] = timeout,
-            ["waitUntil"] = waitUntil,
-        };
-        return Connection.SendMessageToServerAsync<ResponseChannel>(Object, "goBack", args);
-    }
-
-    internal Task<ResponseChannel> GoForwardAsync(float? timeout, WaitUntilState? waitUntil)
-    {
-        var args = new Dictionary<string, object>
-        {
-            ["timeout"] = timeout,
-            ["waitUntil"] = waitUntil,
-        };
-        return Connection.SendMessageToServerAsync<ResponseChannel>(Object, "goForward", args);
-    }
-
-    internal Task<ResponseChannel> ReloadAsync(float? timeout, WaitUntilState? waitUntil)
-    {
-        var args = new Dictionary<string, object>
-        {
-            ["timeout"] = timeout,
-            ["waitUntil"] = waitUntil,
-        };
-        return Connection.SendMessageToServerAsync<ResponseChannel>(Object, "reload", args);
-    }
-
-    internal Task SetNetworkInterceptionPatternsAsync(Dictionary<string, object> args)
-        => Connection.SendMessageToServerAsync(
-            Object,
-            "setNetworkInterceptionPatterns",
-            args);
-
-    internal async Task<JsonElement?> AccessibilitySnapshotAsync(bool? interestingOnly, IChannel<ElementHandle> root)
-    {
-        var args = new Dictionary<string, object>
-        {
-            ["interestingOnly"] = interestingOnly,
-            ["root"] = root,
-        };
-
-        if ((await Connection.SendMessageToServerAsync(Object, "accessibilitySnapshot", args).ConfigureAwait(false)).Value.TryGetProperty("rootAXNode", out var jsonElement))
-        {
-            return jsonElement;
-        }
-
-        return null;
-    }
-
-    internal Task SetViewportSizeAsync(PageViewportSizeResult viewport)
-        => Connection.SendMessageToServerAsync(
-            Object,
-            "setViewportSize",
-            new Dictionary<string, object>
-            {
-                ["viewportSize"] = viewport,
-            });
-
-    internal Task KeyboardDownAsync(string key)
-        => Connection.SendMessageToServerAsync(
-            Object,
-            "keyboardDown",
-            new Dictionary<string, object>
-            {
-                ["key"] = key,
-            });
-
-    internal Task EmulateMediaAsync(Dictionary<string, object> args)
-        => Connection.SendMessageToServerAsync(Object, "emulateMedia", args);
-
-    internal Task KeyboardUpAsync(string key)
-        => Connection.SendMessageToServerAsync(
-            Object,
-            "keyboardUp",
-            new Dictionary<string, object>
-            {
-                ["key"] = key,
-            });
-
-    internal Task TypeAsync(string text, float? delay)
-        => Connection.SendMessageToServerAsync(
-            Object,
-            "keyboardType",
-            new Dictionary<string, object>
-            {
-                ["text"] = text,
-                ["delay"] = delay,
-            });
-
-    internal Task PressAsync(string key, float? delay)
-        => Connection.SendMessageToServerAsync(
-            Object,
-            "keyboardPress",
-            new Dictionary<string, object>
-            {
-                ["key"] = key,
-                ["delay"] = delay,
-            });
-
-    internal Task InsertTextAsync(string text)
-        => Connection.SendMessageToServerAsync(
-            Object,
-            "keyboardInsertText",
-            new Dictionary<string, object>
-            {
-                ["text"] = text,
-            });
-
-    internal Task MouseDownAsync(MouseButton? button, int? clickCount)
-        => Connection.SendMessageToServerAsync(
-            Object,
-            "mouseDown",
-            new Dictionary<string, object>
-            {
-                ["button"] = button,
-                ["clickCount"] = clickCount,
-            });
-
-    internal Task MouseMoveAsync(float x, float y, int? steps)
-        => Connection.SendMessageToServerAsync(
-            Object,
-            "mouseMove",
-            new Dictionary<string, object>
-            {
-                ["x"] = x,
-                ["y"] = y,
-                ["steps"] = steps,
-            });
-
-    internal Task MouseUpAsync(MouseButton? button, int? clickCount)
-        => Connection.SendMessageToServerAsync(
-            Object,
-            "mouseUp",
-            new Dictionary<string, object>
-            {
-                ["button"] = button,
-                ["clickCount"] = clickCount,
-            });
-
-    internal Task MouseClickAsync(float x, float y, float? delay, MouseButton? button, int? clickCount)
-        => Connection.SendMessageToServerAsync(
-            Object,
-            "mouseClick",
-            new Dictionary<string, object>
-            {
-                ["x"] = x,
-                ["y"] = y,
-                ["delay"] = delay,
-                ["button"] = button,
-                ["clickCount"] = clickCount,
-            });
-
-    internal Task MouseWheelAsync(float deltaX, float deltaY)
-        => Connection.SendMessageToServerAsync(
-            Object,
-            "mouseWheel",
-            new Dictionary<string, object>
-            {
-                ["deltaX"] = deltaX,
-                ["deltaY"] = deltaY,
-            });
-
-    internal Task TouchscreenTapAsync(float x, float y)
-        => Connection.SendMessageToServerAsync(
-            Object,
-            "touchscreenTap",
-            new Dictionary<string, object>
-            {
-                ["x"] = x,
-                ["y"] = y,
-            });
-
-    internal Task SetExtraHTTPHeadersAsync(IEnumerable<KeyValuePair<string, string>> headers)
-        => Connection.SendMessageToServerAsync(
-            Object,
-            "setExtraHTTPHeaders",
-            new Dictionary<string, object>
-            {
-                ["headers"] = headers.Select(kv => new HeaderEntry { Name = kv.Key, Value = kv.Value }),
-            });
-
-    internal async Task<byte[]> ScreenshotAsync(
-        string path,
-        bool? fullPage,
-        Clip clip,
-        bool? omitBackground,
-        ScreenshotType? type,
-        int? quality,
-        IEnumerable<ILocator> mask,
-        string maskColor,
-        ScreenshotAnimations? animations,
-        ScreenshotCaret? caret,
-        ScreenshotScale? scale,
-        float? timeout)
-    {
-        var args = new Dictionary<string, object>
-        {
-            ["fullPage"] = fullPage,
-            ["omitBackground"] = omitBackground,
-            ["clip"] = clip,
-            ["path"] = path,
-            ["type"] = type,
-            ["timeout"] = timeout,
-            ["animations"] = animations,
-            ["caret"] = caret,
-            ["scale"] = scale,
-            ["quality"] = quality,
-            ["maskColor"] = maskColor,
-            ["mask"] = mask?.Select(locator => new Dictionary<string, object>
-            {
-                ["frame"] = ((Locator)locator)._frame._channel,
-                ["selector"] = ((Locator)locator)._selector,
-            }).ToArray(),
-        };
-        return (await Connection.SendMessageToServerAsync(Object, "screenshot", args).ConfigureAwait(false))?.GetProperty("binary").GetBytesFromBase64();
-    }
-
-    internal Task StartCSSCoverageAsync(bool resetOnNavigation)
-        => Connection.SendMessageToServerAsync(
-            Object,
-            "crStartCSSCoverage",
-            new Dictionary<string, object>
-            {
-                ["resetOnNavigation"] = resetOnNavigation,
-            });
-
-    internal Task StartJSCoverageAsync(bool resetOnNavigation, bool reportAnonymousScripts)
-        => Connection.SendMessageToServerAsync(
-            Object,
-            "crStartJSCoverage",
-            new Dictionary<string, object>
-            {
-                ["resetOnNavigation"] = resetOnNavigation,
-                ["reportAnonymousScripts"] = reportAnonymousScripts,
-            });
-
-    internal async Task<byte[]> PdfAsync(
-        float? scale,
-        bool? displayHeaderFooter,
-        string headerTemplate,
-        string footerTemplate,
-        bool? printBackground,
-        bool? landscape,
-        string pageRanges,
-        string format,
-        string width,
-        string height,
-        Margin margin,
-        bool? preferCSSPageSize)
-    {
-        var args = new Dictionary<string, object>
-        {
-            ["scale"] = scale,
-            ["displayHeaderFooter"] = displayHeaderFooter,
-            ["printBackground"] = printBackground,
-            ["landscape"] = landscape,
-            ["preferCSSPageSize"] = preferCSSPageSize,
-            ["pageRanges"] = pageRanges,
-            ["headerTemplate"] = headerTemplate,
-            ["footerTemplate"] = footerTemplate,
-            ["margin"] = margin,
-            ["width"] = width,
-            ["format"] = format,
-            ["height"] = height,
-        };
-        return (await Connection.SendMessageToServerAsync(Object, "pdf", args).ConfigureAwait(false))?.GetProperty("pdf").GetBytesFromBase64();
-    }
 }
diff --git a/src/Playwright/Transport/Channels/PlaywrightChannel.cs b/src/Playwright/Transport/Channels/PlaywrightChannel.cs
index ca50a602a4..763dac68fc 100644
--- a/src/Playwright/Transport/Channels/PlaywrightChannel.cs
+++ b/src/Playwright/Transport/Channels/PlaywrightChannel.cs
@@ -22,12 +22,7 @@
  * SOFTWARE.
  */
 
-using System.Collections.Generic;
-using System.IO;
-using System.Text.Json;
-using System.Threading.Tasks;
 using Microsoft.Playwright.Core;
-using Microsoft.Playwright.Helpers;
 
 namespace Microsoft.Playwright.Transport.Channels;
 
@@ -36,46 +31,4 @@ internal class PlaywrightChannel : Channel<PlaywrightImpl>
     public PlaywrightChannel(string guid, Connection connection, PlaywrightImpl owner) : base(guid, connection, owner)
     {
     }
-
-    internal async Task<APIRequestContext> NewRequestAsync(
-        string baseURL,
-        string userAgent,
-        bool? ignoreHTTPSErrors,
-        IEnumerable<KeyValuePair<string, string>> extraHTTPHeaders,
-        HttpCredentials httpCredentials = null,
-        Proxy proxy = null,
-        float? timeout = null,
-        string storageState = null,
-        string storageStatePath = null)
-    {
-        var args = new Dictionary<string, object>()
-        {
-            ["baseURL"] = baseURL,
-            ["userAgent"] = userAgent,
-            ["ignoreHTTPSErrors"] = ignoreHTTPSErrors,
-            ["extraHTTPHeaders"] = extraHTTPHeaders?.ToProtocol(),
-            ["httpCredentials"] = httpCredentials,
-            ["proxy"] = proxy,
-            ["timeout"] = timeout,
-        };
-        if (!string.IsNullOrEmpty(storageStatePath))
-        {
-            if (!File.Exists(storageStatePath))
-            {
-                throw new PlaywrightException($"The specified storage state file does not exist: {storageStatePath}");
-            }
-
-            storageState = File.ReadAllText(storageStatePath);
-        }
-        if (!string.IsNullOrEmpty(storageState))
-        {
-            args.Add("storageState", JsonSerializer.Deserialize<StorageState>(storageState, Helpers.JsonExtensions.DefaultJsonSerializerOptions));
-        }
-
-        var response = await Connection.SendMessageToServerAsync<APIRequestContextChannel>(
-            Object,
-            "newRequest",
-            args).ConfigureAwait(false);
-        return response.Object;
-    }
 }
diff --git a/src/Playwright/Transport/Channels/RequestChannel.cs b/src/Playwright/Transport/Channels/RequestChannel.cs
index ca2043633f..6a3ee7135e 100644
--- a/src/Playwright/Transport/Channels/RequestChannel.cs
+++ b/src/Playwright/Transport/Channels/RequestChannel.cs
@@ -22,11 +22,7 @@
  * SOFTWARE.
  */
 
-using System.Collections.Generic;
-using System.Threading.Tasks;
 using Microsoft.Playwright.Core;
-using Microsoft.Playwright.Helpers;
-using Microsoft.Playwright.Transport.Protocol;
 
 namespace Microsoft.Playwright.Transport.Channels;
 
@@ -35,9 +31,4 @@ internal class RequestChannel : Channel<Request>
     public RequestChannel(string guid, Connection connection, Request owner) : base(guid, connection, owner)
     {
     }
-
-    internal Task<ResponseChannel> GetResponseAsync() => Connection.SendMessageToServerAsync<ResponseChannel>(Object, "response");
-
-    internal async Task<List<NameValue>> GetRawRequestHeadersAsync() =>
-        (await Connection.SendMessageToServerAsync(Object, "rawRequestHeaders").ConfigureAwait(false))?.GetProperty("headers").ToObject<List<NameValue>>();
 }
diff --git a/src/Playwright/Transport/Channels/ResponseChannel.cs b/src/Playwright/Transport/Channels/ResponseChannel.cs
index 4bcff78f18..26815ac728 100644
--- a/src/Playwright/Transport/Channels/ResponseChannel.cs
+++ b/src/Playwright/Transport/Channels/ResponseChannel.cs
@@ -22,11 +22,7 @@
  * SOFTWARE.
  */
 
-using System.Collections.Generic;
-using System.Threading.Tasks;
 using Microsoft.Playwright.Core;
-using Microsoft.Playwright.Helpers;
-using Microsoft.Playwright.Transport.Protocol;
 
 namespace Microsoft.Playwright.Transport.Channels;
 
@@ -35,21 +31,4 @@ internal class ResponseChannel : Channel<Response>
     public ResponseChannel(string guid, Connection connection, Response owner) : base(guid, connection, owner)
     {
     }
-
-    internal async Task<byte[]> GetBodyAsync()
-        => (await Connection.SendMessageToServerAsync(Object, "body").ConfigureAwait(false))?.GetProperty("binary").GetBytesFromBase64();
-
-    internal async Task<ResponseServerAddrResult> ServerAddrAsync()
-        => (await Connection.SendMessageToServerAsync(Object, "serverAddr").ConfigureAwait(false))
-            ?.GetProperty("value").ToObject<ResponseServerAddrResult>(Connection.DefaultJsonSerializerOptions);
-
-    internal async Task<ResponseSecurityDetailsResult> SecurityDetailsAsync()
-        => (await Connection.SendMessageToServerAsync(Object, "securityDetails").ConfigureAwait(false))
-            ?.GetProperty("value").ToObject<ResponseSecurityDetailsResult>(Connection.DefaultJsonSerializerOptions);
-
-    internal async Task<RequestSizesResult> SizesAsync() =>
-        (await Connection.SendMessageToServerAsync(Object, "sizes").ConfigureAwait(false))?.GetProperty("sizes").ToObject<RequestSizesResult>();
-
-    internal async Task<List<NameValue>> GetRawHeadersAsync() =>
-        (await Connection.SendMessageToServerAsync(Object, "rawResponseHeaders").ConfigureAwait(false))?.GetProperty("headers").ToObject<List<NameValue>>();
 }
diff --git a/src/Playwright/Transport/Channels/Root.cs b/src/Playwright/Transport/Channels/Root.cs
index 0403ca36b8..fccc19d2e7 100644
--- a/src/Playwright/Transport/Channels/Root.cs
+++ b/src/Playwright/Transport/Channels/Root.cs
@@ -22,11 +22,6 @@
  * SOFTWARE.
  */
 
-using System.Collections.Generic;
-using System.Threading.Tasks;
-using Microsoft.Playwright.Core;
-using Microsoft.Playwright.Helpers;
-
 namespace Microsoft.Playwright.Transport.Channels;
 
 internal class Root : ChannelOwnerBase
@@ -34,15 +29,4 @@ internal class Root : ChannelOwnerBase
     internal Root(IChannelOwner parent, Connection connection, string guid) : base(parent, connection, guid)
     {
     }
-
-    internal async Task<PlaywrightImpl> InitializeAsync()
-    {
-        var args = new Dictionary<string, object>
-        {
-            ["sdkLanguage"] = "csharp",
-        };
-
-        var jsonElement = await _connection.SendMessageToServerAsync(this, "initialize", args).ConfigureAwait(false);
-        return jsonElement.GetObject<PlaywrightImpl>("playwright", _connection);
-    }
 }
diff --git a/src/Playwright/Transport/Channels/RouteChannel.cs b/src/Playwright/Transport/Channels/RouteChannel.cs
index bdd9fc9728..8366ab7cbe 100644
--- a/src/Playwright/Transport/Channels/RouteChannel.cs
+++ b/src/Playwright/Transport/Channels/RouteChannel.cs
@@ -22,12 +22,7 @@
  * SOFTWARE.
  */
 
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
 using Microsoft.Playwright.Core;
-using Microsoft.Playwright.Transport.Protocol;
 
 namespace Microsoft.Playwright.Transport.Channels;
 
@@ -36,47 +31,4 @@ internal class RouteChannel : Channel<Route>
     public RouteChannel(string guid, Connection connection, Route owner) : base(guid, connection, owner)
     {
     }
-
-    public Task AbortAsync(string requestUrl, string errorCode)
-        => Connection.SendMessageToServerAsync(
-            Object,
-            "abort",
-            new Dictionary<string, object>
-            {
-                ["requestUrl"] = requestUrl,
-                ["errorCode"] = string.IsNullOrEmpty(errorCode) ? RequestAbortErrorCode.Failed : errorCode,
-            });
-
-    public Task FulfillAsync(Dictionary<string, object> args)
-        => Connection.SendMessageToServerAsync(
-            Object,
-            "fulfill",
-            args);
-
-    public Task ContinueAsync(string requestUrl, string url, string method, byte[] postData, IEnumerable<KeyValuePair<string, string>> headers, bool isFallback)
-    {
-        var args = new Dictionary<string, object>
-        {
-            ["requestUrl"] = requestUrl,
-            ["url"] = url,
-            ["method"] = method,
-            ["postData"] = postData != null ? Convert.ToBase64String(postData) : null,
-            ["headers"] = headers?.Select(kv => new HeaderEntry { Name = kv.Key, Value = kv.Value }).ToArray(),
-            ["isFallback"] = isFallback,
-        };
-
-        return Connection.SendMessageToServerAsync(
-            Object,
-            "continue",
-            args);
-    }
-
-    internal Task RedirectNavigationRequestAsync(string url) =>
-        Connection.SendMessageToServerAsync(
-            Object,
-            "redirectNavigationRequest",
-            new Dictionary<string, object>
-            {
-                ["url"] = url,
-            });
 }
diff --git a/src/Playwright/Transport/Channels/SelectorsChannel.cs b/src/Playwright/Transport/Channels/SelectorsChannel.cs
index 0b37548d5f..19161abcde 100644
--- a/src/Playwright/Transport/Channels/SelectorsChannel.cs
+++ b/src/Playwright/Transport/Channels/SelectorsChannel.cs
@@ -22,9 +22,6 @@
 * SOFTWARE.
 */
 
-using System.Collections.Generic;
-using System.Text.Json;
-using System.Threading.Tasks;
 using Microsoft.Playwright.Core;
 
 namespace Microsoft.Playwright.Transport.Channels;
@@ -34,31 +31,4 @@ internal class SelectorsChannel : Channel<Selectors>
     public SelectorsChannel(string guid, Connection connection, Selectors owner) : base(guid, connection, owner)
     {
     }
-
-    internal Task RegisterAsync(SelectorsRegisterParams @params)
-        => Connection.SendMessageToServerAsync<JsonElement>(
-            Object,
-            "register",
-            new Dictionary<string, object>
-            {
-                ["name"] = @params.Name,
-                ["source"] = @params.Source,
-                ["contentScript"] = @params.ContentScript,
-            });
-
-    internal Task SetTestIdAttributeAsync(string name)
-        => Connection.SendMessageToServerAsync<JsonElement>(
-            Object,
-            "setTestIdAttributeName",
-            new Dictionary<string, object>
-            {
-                ["testIdAttributeName"] = name,
-            });
-}
-
-internal record SelectorsRegisterParams
-{
-    internal string Name;
-    internal string Source;
-    internal bool? ContentScript;
 }
diff --git a/src/Playwright/Transport/Channels/StreamChannel.cs b/src/Playwright/Transport/Channels/StreamChannel.cs
index ec6c5d33c0..982e499522 100644
--- a/src/Playwright/Transport/Channels/StreamChannel.cs
+++ b/src/Playwright/Transport/Channels/StreamChannel.cs
@@ -22,8 +22,6 @@
  * SOFTWARE.
  */
 
-using System.Collections.Generic;
-using System.Threading.Tasks;
 using Microsoft.Playwright.Core;
 
 namespace Microsoft.Playwright.Transport.Channels;
@@ -33,18 +31,4 @@ internal class StreamChannel : Channel<Stream>
     public StreamChannel(string guid, Connection connection, Stream owner) : base(guid, connection, owner)
     {
     }
-
-    internal async Task<byte[]> ReadAsync(int size)
-    {
-        var response = await Connection.SendMessageToServerAsync(
-            Object,
-            "read",
-            new Dictionary<string, object>
-            {
-                ["size"] = size,
-            }).ConfigureAwait(false);
-        return response.Value.GetProperty("binary").GetBytesFromBase64();
-    }
-
-    internal Task CloseAsync() => Connection.SendMessageToServerAsync(Object, "close");
 }
diff --git a/src/Playwright/Transport/Channels/TracingChannel.cs b/src/Playwright/Transport/Channels/TracingChannel.cs
index 49917a4048..c149c6369e 100644
--- a/src/Playwright/Transport/Channels/TracingChannel.cs
+++ b/src/Playwright/Transport/Channels/TracingChannel.cs
@@ -22,12 +22,7 @@
  * SOFTWARE.
  */
 
-using System.Collections.Generic;
-using System.Text.Json;
-using System.Threading.Tasks;
 using Microsoft.Playwright.Core;
-using Microsoft.Playwright.Helpers;
-using Microsoft.Playwright.Transport.Protocol;
 
 namespace Microsoft.Playwright.Transport.Channels;
 
@@ -36,48 +31,4 @@ internal class TracingChannel : Channel<Tracing>
     public TracingChannel(string guid, Connection connection, Tracing owner) : base(guid, connection, owner)
     {
     }
-
-    internal Task TracingStartAsync(string name, string title, bool? screenshots, bool? snapshots, bool? sources)
-        => Connection.SendMessageToServerAsync(
-            Object,
-            "tracingStart",
-            new Dictionary<string, object>
-            {
-                ["name"] = name,
-                ["title"] = title,
-                ["screenshots"] = screenshots,
-                ["snapshots"] = snapshots,
-                ["sources"] = sources,
-            });
-
-    internal Task TracingStopAsync()
-        => Connection.SendMessageToServerAsync(
-            Object,
-            "tracingStop");
-
-    internal async Task<string> StartChunkAsync(string title = null, string name = null)
-        => (await Connection.SendMessageToServerAsync(Object, "tracingStartChunk", new Dictionary<string, object>
-        {
-            ["title"] = title,
-            ["name"] = name,
-        }).ConfigureAwait(false))?.GetProperty("traceName").ToString();
-
-    internal async Task<(Artifact Artifact, List<NameValue> Entries)> TracingStopChunkAsync(string mode)
-    {
-        var result = await Connection.SendMessageToServerAsync(Object, "tracingStopChunk", new Dictionary<string, object>
-        {
-            ["mode"] = mode,
-        }).ConfigureAwait(false);
-
-        var artifact = result.GetObject<Artifact>("artifact", Connection);
-        List<NameValue> entries = new();
-        if (result.Value.TryGetProperty("entries", out var entriesElement))
-        {
-            foreach (var current in entriesElement.EnumerateArray())
-            {
-                entries.Add(current.Deserialize<NameValue>());
-            }
-        }
-        return (artifact, entries);
-    }
 }
diff --git a/src/Playwright/Transport/Channels/WorkerChannel.cs b/src/Playwright/Transport/Channels/WorkerChannel.cs
index 1e97a24efb..6e025b52ac 100644
--- a/src/Playwright/Transport/Channels/WorkerChannel.cs
+++ b/src/Playwright/Transport/Channels/WorkerChannel.cs
@@ -22,11 +22,7 @@
  * SOFTWARE.
  */
 
-using System.Collections.Generic;
-using System.Text.Json;
-using System.Threading.Tasks;
 using Microsoft.Playwright.Core;
-using Microsoft.Playwright.Helpers;
 
 namespace Microsoft.Playwright.Transport.Channels;
 
@@ -35,34 +31,4 @@ internal class WorkerChannel : Channel<Worker>
     public WorkerChannel(string guid, Connection connection, Worker owner) : base(guid, connection, owner)
     {
     }
-
-    internal async Task<JsonElement> EvaluateExpressionAsync(
-        string expression,
-        bool? isFunction,
-        object arg)
-            => (await Connection.SendMessageToServerAsync<JsonElement>(
-                Object,
-                "evaluateExpression",
-                new Dictionary<string, object>
-                {
-                    ["expression"] = expression,
-                    ["isFunction"] = isFunction,
-                    ["arg"] = arg,
-                })
-                .ConfigureAwait(false)).GetProperty("value");
-
-    internal async Task<JSHandle> EvaluateExpressionHandleAsync(
-        string expression,
-        bool? isFunction,
-        object arg)
-        => (await Connection.SendMessageToServerAsync<JsonElement>(
-            Object,
-            "evaluateExpressionHandle",
-            new Dictionary<string, object>
-            {
-                ["expression"] = expression,
-                ["isFunction"] = isFunction,
-                ["arg"] = arg,
-            })
-            .ConfigureAwait(false)).GetObject<JSHandle>("handle", Connection);
 }
diff --git a/src/Playwright/Transport/Channels/WritableStreamChannel.cs b/src/Playwright/Transport/Channels/WritableStreamChannel.cs
index 55d139090e..fe947b5d3f 100644
--- a/src/Playwright/Transport/Channels/WritableStreamChannel.cs
+++ b/src/Playwright/Transport/Channels/WritableStreamChannel.cs
@@ -22,8 +22,6 @@
  * SOFTWARE.
  */
 
-using System.Collections.Generic;
-using System.Threading.Tasks;
 using Microsoft.Playwright.Core;
 
 namespace Microsoft.Playwright.Transport.Channels;
@@ -33,17 +31,4 @@ internal class WritableStreamChannel : Channel<WritableStream>
     public WritableStreamChannel(string guid, Connection connection, WritableStream owner) : base(guid, connection, owner)
     {
     }
-
-    internal async Task WriteAsync(string binary)
-    {
-        await Connection.SendMessageToServerAsync(
-            Object,
-            "write",
-            new Dictionary<string, object>
-            {
-                ["binary"] = binary,
-            }).ConfigureAwait(false);
-    }
-
-    internal Task CloseAsync() => Connection.SendMessageToServerAsync(Object, "close");
 }
diff --git a/src/Playwright/Transport/Connection.cs b/src/Playwright/Transport/Connection.cs
index c79db9055d..e1174ce3e7 100644
--- a/src/Playwright/Transport/Connection.cs
+++ b/src/Playwright/Transport/Connection.cs
@@ -144,7 +144,7 @@ private async Task<T> InnerSendMessageToServerAsync<T>(
         {
             throw _closedError;
         }
-        if (@object._wasCollected)
+        if (@object?._wasCollected == true)
         {
             throw new PlaywrightException("The object has been collected to prevent unbounded heap growth.");
         }
@@ -195,7 +195,7 @@ await _queue.EnqueueAsync(() =>
             var message = new MessageRequest
             {
                 Id = id,
-                Guid = @object.Guid,
+                Guid = @object == null ? string.Empty : @object.Guid,
                 Method = method,
                 Params = sanitizedArgs,
                 Metadata = metadata,
@@ -238,9 +238,15 @@ internal IChannelOwner GetObject(string guid)
 
     internal void MarkAsRemote() => IsRemote = true;
 
-    internal Task<PlaywrightImpl> InitializePlaywrightAsync()
+    internal async Task<PlaywrightImpl> InitializePlaywrightAsync()
     {
-        return _rootObject.InitializeAsync();
+        var args = new Dictionary<string, object>
+        {
+            ["sdkLanguage"] = "csharp",
+        };
+
+        var jsonElement = await SendMessageToServerAsync(null, "initialize", args).ConfigureAwait(false);
+        return jsonElement.GetObject<PlaywrightImpl>("playwright", this);
     }
 
     internal void Dispatch(PlaywrightServerMessage message)