fix: Make handleAck fire-and-forget to avoid RPC deadlock

In the browser runtime, when the kernel worker calls sendRemoteMessage,
the offscreen document awaits sendWithAck which waits for an ACK. When
the ACK arrives via remoteDeliver, the kernel worker calls handleAck
back to the offscreen. If handleAck awaited, this creates a deadlock
because the offscreen's RPC message handler is blocked on the original
sendRemoteMessage request.

Making handleAck fire-and-forget breaks the deadlock while still
ensuring ACKs are processed correctly.

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

Author: FUDCo

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

@@ -273,13 +273,20 @@ export class PlatformServicesClient implements PlatformServices {
 
   /**
    * Handle an acknowledgment from a peer for sent messages.
+   * This is fire-and-forget to avoid deadlock: when the offscreen is awaiting
+   * sendWithAck (waiting for ACK), the kernel worker may receive the ACK via
+   * remoteDeliver and call handleAck back. If handleAck awaited, it would
+   * deadlock because the offscreen can't process new RPC requests while
+   * blocked on sendWithAck.
    *
    * @param peerId - The peer ID.
    * @param ackSeq - The sequence number being acknowledged.
-   * @returns A promise that resolves when the acknowledgment has been processed.
    */
-  async handleAck(peerId: string, ackSeq: number): Promise<void> {
-    await this.#rpcClient.call('handleAck', { peerId, ackSeq });
+  handleAck(peerId: string, ackSeq: number): void {
+    // Fire-and-forget RPC call to avoid deadlock
+    this.#rpcClient.call('handleAck', { peerId, ackSeq }).catch((error) => {
+      this.#logger.error('Error handling ACK:', error);
+    });
   }
 
   /**

packages/nodejs/src/kernel/PlatformServices.ts

@@ -336,16 +336,19 @@ export class NodejsPlatformServices implements PlatformServices {
 
   /**
    * Handle an acknowledgment from a peer for sent messages.
+   * Fire-and-forget to match browser runtime semantics.
    *
    * @param peerId - The peer ID.
    * @param ackSeq - The sequence number being acknowledged.
-   * @returns A promise that resolves when the acknowledgment has been processed.
    */
-  async handleAck(peerId: string, ackSeq: number): Promise<void> {
+  handleAck(peerId: string, ackSeq: number): void {
     if (!this.#handleAckFunc) {
       throw Error('remote comms not initialized');
     }
-    await this.#handleAckFunc(peerId, ackSeq);
+    // Fire-and-forget - don't await
+    this.#handleAckFunc(peerId, ackSeq).catch((error) => {
+      this.#logger.error('Error handling ACK:', error);
+    });
   }
 
   /**

packages/ocap-kernel/src/remotes/RemoteHandle.ts

@@ -447,9 +447,9 @@ export class RemoteHandle implements EndpointHandle {
     // Track received sequence number for piggyback ACK
     this.#remoteComms.updateReceivedSeq(this.#peerId, seq);
 
-    // Handle piggyback ACK if present
+    // Handle piggyback ACK if present (fire-and-forget to avoid deadlock in browser runtime)
     if (ack !== undefined) {
-      await this.#remoteComms.handleAck(this.#peerId, ack);
+      this.#remoteComms.handleAck(this.#peerId, ack);
     }
 
     let result = '';

packages/ocap-kernel/src/remotes/types.ts

@@ -24,7 +24,7 @@ export type StopRemoteComms = () => Promise<void>;
 export type RemoteComms = {
   getPeerId: () => string;
   sendRemoteMessage: SendRemoteMessage;
-  handleAck: (peerId: string, ackSeq: number) => Promise<void>;
+  handleAck: (peerId: string, ackSeq: number) => void;
   updateReceivedSeq: (peerId: string, seq: number) => void;
   issueOcapURL: (kref: string) => Promise<string>;
   redeemLocalOcapURL: (ocapURL: string) => Promise<string>;

packages/ocap-kernel/src/types.ts

@@ -367,12 +367,12 @@ export type PlatformServices = {
   /**
    * Handle acknowledgment of received messages.
    * Implements cumulative ACK - acknowledges all messages with sequence <= ackSeq.
+   * Fire-and-forget in browser runtime to avoid deadlock.
    *
    * @param peerId - The peer ID that sent the acknowledgment.
    * @param ackSeq - The highest sequence number being acknowledged.
-   * @returns A promise that resolves when the acknowledgment has been processed.
    */
-  handleAck: (peerId: string, ackSeq: number) => Promise<void>;
+  handleAck: (peerId: string, ackSeq: number) => void;
   /**
    * Update the highest received sequence number for a peer.
    * Used for tracking received messages to generate piggyback ACKs.