fix(kernel-browser-runtime): unblock drain so reentrant RPC doesn't deadlock

The drain loop awaited each request handler before pulling the next
message, including responses. That serialization deadlocked any
request handler that fired an outbound RPC back to the other side and
awaited its response — the response could not be processed by the
drain until the request handler returned, but the request handler was
waiting for the response.

This bit the new `onIncarnationChange` callback the transport invokes
during the handshake: kernel-worker sends `sendRemoteMessage` →
offscreen runs the handler → handshake calls `onIncarnationChange` RPC
back to kernel-worker → kernel-worker returns a verdict → response
arrives at offscreen but its drain is still awaiting the original
request handler. Hung until the 40s URL redemption timeout.

Fix: dispatch request handlers in the background (no await inside the
drain). Responses still process synchronously. Apply on both sides
since either drain can hit the same shape.

The new `onIncarnationChange` round-trip during every handshake makes
this latent issue actually surface in the e2e — the original
asymmetry (kernel-worker drain rarely blocked, offscreen drain
frequently blocked while sendRemoteMessage was in flight) is what
made it hide for so long.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: sirtimid

packages/kernel-browser-runtime/src/PlatformServicesClient.ts

@@ -25,6 +25,7 @@ import type {
   PostMessageTarget,
 } from '@metamask/streams/browser';
 import { isJsonRpcResponse, isJsonRpcRequest } from '@metamask/utils';
+import type { JsonRpcRequest } from '@metamask/utils';
 import type { JsonRpcId } from '@metamask/utils';
 
 // Appears in the docs.
@@ -415,22 +416,34 @@ export class PlatformServicesClient implements PlatformServices {
 
       this.#rpcClient.handleResponse(id, event.data);
     } else if (isJsonRpcRequest(event.data)) {
-      const { id, method, params } = event.data;
-      try {
-        this.#rpcServer.assertHasMethod(method);
-        const result = await this.#rpcServer.execute(method, params);
-        await this.#sendMessage({
-          id,
-          result,
-          jsonrpc: '2.0',
-        });
-      } catch (error) {
-        await this.#sendMessage({
-          id,
-          error: serializeError(error),
-          jsonrpc: '2.0',
-        });
-      }
+      // Run the request handler in the background instead of awaiting it
+      // inside the drain. The drain processes responses too, and a request
+      // handler that fires an outbound RPC back to the other side would
+      // deadlock waiting for its response — the drain can't get to that
+      // response until the request handler returns.
+      this.#executeRequest(event.data).catch(() => undefined);
+    }
+  }
+
+  /**
+   * Execute a JSON-RPC request and write the response back. Errors during
+   * execution are serialized into a JSON-RPC error response; errors during
+   * response delivery are swallowed.
+   *
+   * @param request - The JSON-RPC request to execute.
+   */
+  async #executeRequest(request: JsonRpcRequest): Promise<void> {
+    const { id, method, params } = request;
+    try {
+      this.#rpcServer.assertHasMethod(method);
+      const result = await this.#rpcServer.execute(method, params);
+      await this.#sendMessage({ id, result, jsonrpc: '2.0' });
+    } catch (error) {
+      await this.#sendMessage({
+        id,
+        error: serializeError(error),
+        jsonrpc: '2.0',
+      }).catch(() => undefined);
     }
   }
 }

packages/kernel-browser-runtime/src/PlatformServicesServer.ts

@@ -25,6 +25,7 @@ import type {
   PostMessageTarget,
 } from '@metamask/streams/browser';
 import { isJsonRpcRequest, isJsonRpcResponse } from '@metamask/utils';
+import type { JsonRpcRequest } from '@metamask/utils';
 
 // Appears in the docs.
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
@@ -179,23 +180,41 @@ export class PlatformServicesServer {
       const message = event.data;
       this.#rpcClient.handleResponse(message.id as string, message);
     } else if (isJsonRpcRequest(event.data)) {
-      const { id, method, params } = event.data;
-      try {
-        this.#rpcServer.assertHasMethod(method);
-        // Ridiculous cast to bypass TypeScript vs. JsonRpc tug-o-war
-        const port: MessagePort | undefined = (await this.#rpcServer.execute(
-          method,
-          params,
-        )) as unknown as MessagePort | undefined;
-        await this.#sendMessage({ id, result: null, jsonrpc: '2.0' }, port);
-      } catch (error) {
-        this.#logger.error(`Error handling "${method}" request:`, error);
-        this.#sendMessage({
-          id,
-          error: serializeError(error),
-          jsonrpc: '2.0',
-        }).catch(() => undefined);
-      }
+      // Run the request handler in the background instead of awaiting it
+      // inside the drain. The drain processes responses too, and a request
+      // handler that fires an outbound RPC back to the other side (e.g.
+      // transport.sendRemoteMessage's handshake calling onIncarnationChange)
+      // would deadlock waiting for its response — the drain can't get to
+      // that response until the request handler returns.
+      this.#executeRequest(event.data).catch(() => undefined);
+    }
+  }
+
+  /**
+   * Execute a JSON-RPC request and write the response back. Errors during
+   * execution are serialized into a JSON-RPC error response; errors during
+   * response delivery are logged and swallowed (the caller has nowhere to
+   * surface them).
+   *
+   * @param request - The JSON-RPC request to execute.
+   */
+  async #executeRequest(request: JsonRpcRequest): Promise<void> {
+    const { id, method, params } = request;
+    try {
+      this.#rpcServer.assertHasMethod(method);
+      // Ridiculous cast to bypass TypeScript vs. JsonRpc tug-o-war
+      const port: MessagePort | undefined = (await this.#rpcServer.execute(
+        method,
+        params,
+      )) as unknown as MessagePort | undefined;
+      await this.#sendMessage({ id, result: null, jsonrpc: '2.0' }, port);
+    } catch (error) {
+      this.#logger.error(`Error handling "${method}" request:`, error);
+      this.#sendMessage({
+        id,
+        error: serializeError(error),
+        jsonrpc: '2.0',
+      }).catch(() => undefined);
     }
   }