refactor(kernel-browser-runtime): Simplify kernel worker initialization

The kernel worker initialization was using a convoluted pattern where every incoming message had to traverse a promise chain, even after the server was initialized.

This refactoring updates receiveInternalConnections to accept either a direct handler function or a promise that resolves to a handler, implements a lazy cache pattern where subsequent messages use the cached handler directly with zero promise overhead, and simplifies kernel-worker.ts to pass a handler promise instead of wrapping every message in a promise chain.

The synchronous listener setup is preserved to avoid missing early connections, while eliminating the performance overhead of promise chaining on every message after initialization.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

Author: rekmarks

packages/kernel-browser-runtime/src/internal-comms/internal-connections.ts

@@ -103,7 +103,7 @@ const connectToInternalProcess = async (
 };
 
 type ReceiveConnectionsOptions = Omit<Options, 'label'> & {
-  handleInternalMessage: HandleInternalMessage;
+  handleInternalMessage: HandleInternalMessage | Promise<HandleInternalMessage>;
 };
 
 /**
@@ -112,7 +112,9 @@ type ReceiveConnectionsOptions = Omit<Options, 'label'> & {
  * processes have attempted to connect.
  *
  * @param options - The options for the connection.
- * @param options.handleInternalMessage - The function to handle the internal message.
+ * @param options.handleInternalMessage - The function to handle the internal message,
+ * or a promise that resolves to such a function. If a promise is provided, messages will
+ * be buffered until the handler is ready, then subsequent messages are handled directly.
  * @param options.logger - The logger instance.
  * @param options.controlChannelName - The name of the control channel. Must match
  * the name used by {@link connectToKernel} on the other end.
@@ -122,6 +124,22 @@ export const receiveInternalConnections = ({
   logger,
   controlChannelName = COMMS_CONTROL_CHANNEL_NAME,
 }: ReceiveConnectionsOptions): void => {
+  // Support both direct handler and promise-based handler
+  let handler: HandleInternalMessage | null = null;
+  let handlerReady: Promise<HandleInternalMessage>;
+
+  if (typeof handleInternalMessage === 'function') {
+    // Direct handler - use immediately
+    handler = handleInternalMessage;
+    handlerReady = Promise.resolve(handleInternalMessage);
+  } else {
+    // Promise-based handler - cache once resolved
+    handlerReady = handleInternalMessage.then((resolvedHandler) => {
+      handler = resolvedHandler;
+      return resolvedHandler;
+    });
+  }
+
   const seenChannels = new Set<string>();
   new BroadcastChannel(controlChannelName).onmessage = (event) => {
     if (!isCommsControlMessage(event.data)) {
@@ -148,7 +166,9 @@ export const receiveInternalConnections = ({
             `Received message from internal process "${channelName}": ${JSON.stringify(message)}`,
           );
 
-          const reply = await handleInternalMessage(message);
+          // Use cached handler if available, otherwise await once
+          const messageHandler = handler ?? (await handlerReady);
+          const reply = await messageHandler(message);
           if (reply !== undefined) {
             await kernelRpcStream.write(reply);
           }

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

@@ -54,18 +54,18 @@ async function main(): Promise<void> {
       resetStorage,
     },
   );
-  const serverP = kernelP.then((kernel) => {
-    return new JsonRpcServer({
+  const handlerP = kernelP.then((kernel) => {
+    const server = new JsonRpcServer({
       middleware: [
         makeLoggingMiddleware(logger.subLogger('kernel-command')),
         makePanelMessageMiddleware(kernel, kernelDatabase),
       ],
     });
+    return async (request: JsonRpcCall) => server.handle(request);
   });
 
   receiveInternalConnections({
-    handleInternalMessage: async (request) =>
-      serverP.then(async (rpcServer) => rpcServer.handle(request)),
+    handleInternalMessage: handlerP,
     logger,
   });