refactor(kernel-browser-runtime): Simplify error handling in internal-connections

Remove overly complex error handling logic that differentiated between
handler initialization errors and message handling errors. Replace with
simple one-liner handler resolution and single catch block.

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

Author: rekmarks

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

@@ -526,9 +526,11 @@ describe('internal-connections', () => {
 
     it('should queue messages until handlerPromise resolves', async () => {
       let resolveHandler: (handler: typeof mockHandleMessage) => void;
-      const handlerPromise = new Promise<typeof mockHandleMessage>((resolve) => {
-        resolveHandler = resolve;
-      });
+      const handlerPromise = new Promise<typeof mockHandleMessage>(
+        (resolve) => {
+          resolveHandler = resolve;
+        },
+      );
 
       receiveInternalConnections({
         handlerPromise,
@@ -592,6 +594,8 @@ describe('internal-connections', () => {
     it('should handle handlerPromise rejection', async () => {
       const handlerError = new Error('Handler initialization failed');
       const handlerPromise = Promise.reject(handlerError);
+      // Prevent unhandled rejection warning - error is handled by receiveInternalConnections
+      handlerPromise.catch(() => undefined);
 
       receiveInternalConnections({
         handlerPromise,
@@ -629,7 +633,7 @@ describe('internal-connections', () => {
       await delay();
 
       expect(logger.error).toHaveBeenCalledWith(
-        'Error initializing message handler for internal process "internal-process-channel":',
+        'Error handling message from internal process "internal-process-channel":',
         handlerError,
       );
     });

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

@@ -123,39 +123,18 @@ type ReceiveConnectionsOptions = Omit<Options, 'label'> &
  * @param options.handler - The function to handle internal messages. Mutually exclusive
  * with `handlerPromise`.
  * @param options.handlerPromise - A promise that resolves to the handler function.
- * Incoming messages await handler initialization once, then the resolved handler is
- * cached and used directly for all subsequent messages. Mutually exclusive with `handler`.
+ * Mutually exclusive with `handler`.
  * @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.
  */
 export const receiveInternalConnections = ({
-  handler: directHandler,
+  handler,
   handlerPromise,
   logger,
   controlChannelName = COMMS_CONTROL_CHANNEL_NAME,
 }: ReceiveConnectionsOptions): void => {
-  // Support both direct handler and promise-based handler
-  let handler: HandleInternalMessage | null = null;
-  let handlerResolution: Promise<HandleInternalMessage>;
-
-  if (directHandler !== undefined) {
-    // Direct handler - use immediately
-    handler = directHandler;
-    handlerResolution = Promise.resolve(directHandler);
-  } else {
-    // Promise-based handler - cache once resolved
-    handlerResolution = handlerPromise.then(
-      (resolvedHandler) => {
-        handler = resolvedHandler;
-        return resolvedHandler;
-      },
-      (error) => {
-        // Re-throw to propagate initialization errors to message handlers
-        throw error;
-      },
-    );
-  }
+  const handlerResolution = handler ? Promise.resolve(handler) : handlerPromise;
 
   const seenChannels = new Set<string>();
   new BroadcastChannel(controlChannelName).onmessage = (event) => {
@@ -183,39 +162,18 @@ export const receiveInternalConnections = ({
             `Received message from internal process "${channelName}": ${JSON.stringify(message)}`,
           );
 
-          try {
-            // Use cached handler if available, otherwise await once
-            const messageHandler = handler ?? (await handlerResolution);
-            const reply = await messageHandler(message);
-            if (reply !== undefined) {
-              await kernelRpcStream.write(reply);
-            }
-          } catch (error) {
-            // Check if this is a handler initialization error
-            if (handler === null) {
-              logger.error(
-                `Error initializing message handler for internal process "${channelName}":`,
-                error,
-              );
-            } else {
-              logger.error(
-                `Error handling message from internal process "${channelName}":`,
-                error,
-              );
-            }
-            throw error;
+          const messageHandler = await handlerResolution;
+          const reply = await messageHandler(message);
+          if (reply !== undefined) {
+            await kernelRpcStream.write(reply);
           }
         });
       })
       .catch((error) => {
-        // This catch handles connection errors and re-thrown handler errors
-        if (handler !== null) {
-          logger.error(
-            `Error handling message from internal process "${channelName}":`,
-            error,
-          );
-        }
-        // Initialization errors are already logged in the try-catch above
+        logger.error(
+          `Error handling message from internal process "${channelName}":`,
+          error,
+        );
       })
       .finally(() => {
         logger.debug(`Closed connection to internal process "${channelName}"`);