fix(replay): Handle WorkerHandler edge cases from review

- Wrap worker.postMessage in try/catch so a synchronous throw (e.g.
  DataCloneError, terminated worker) cleans up the pending entry and
  rejects the returned promise instead of leaking.
- Skip messages without a numeric id in _onMessage. The worker emits
  { id: undefined, method: 'init', ... } on load; this was already
  handled implicitly via Map.get(undefined), but a typeof guard makes
  the contract explicit and is robust against future malformed messages.

Author: logaretm

packages/replay-internal/src/eventBuffer/WorkerHandler.ts

@@ -92,12 +92,25 @@ export class WorkerHandler {
         resolve: resolve as (value: unknown) => void,
         reject,
       });
-      this._worker.postMessage({ id, method, arg });
+      try {
+        this._worker.postMessage({ id, method, arg });
+      } catch (error) {
+        // If postMessage throws synchronously (e.g. DataCloneError, worker
+        // already terminated), drop the pending entry so it doesn't leak.
+        this._pending.delete(id);
+        reject(error);
+      }
     });
   }
 
   private _onMessage = ({ data }: MessageEvent): void => {
     const response = data as WorkerResponse;
+    // The worker emits an init message with `id: undefined` on load, which is
+    // handled by `ensureReady()` via its own listener. Ignore anything that
+    // doesn't carry a numeric id we issued.
+    if (typeof response.id !== 'number') {
+      return;
+    }
     const pending = this._pending.get(response.id);
     if (!pending || pending.method !== response.method) {
       return;

packages/replay-internal/test/unit/eventBuffer/WorkerHandler.test.ts

@@ -57,6 +57,11 @@ class MockWorker implements Pick<Worker, 'addEventListener' | 'removeEventListen
     while (this._pendingRequests.length > 0) this.flushOne();
   }
 
+  /** Dispatch a message that doesn't correspond to a queued request. */
+  public dispatchRaw(response: Partial<WorkerResponse>): void {
+    this._dispatch('message', { data: response } as MessageEvent);
+  }
+
   public get pendingCount(): number {
     return this._pendingRequests.length;
   }
@@ -122,6 +127,37 @@ describe('Unit | eventBuffer | WorkerHandler', () => {
     await expect(promise).rejects.toThrow('Error in compression worker');
   });
 
+  it('rejects and cleans up the pending entry when worker.postMessage throws synchronously', async () => {
+    const { worker, handler } = makeHandler();
+    const error = new Error('DataCloneError');
+    worker.postMessage = () => {
+      throw error;
+    };
+
+    await expect(handler.postMessage('addEvent', 'a')).rejects.toBe(error);
+
+    // A subsequent successful call should still work — the previous failure
+    // didn't leave a stale entry behind.
+    worker.postMessage = MockWorker.prototype.postMessage.bind(worker);
+    const promise = handler.postMessage<string>('addEvent', 'b');
+    worker.flushOne();
+    await expect(promise).resolves.toBe('result-1');
+  });
+
+  it('ignores messages without a numeric id (e.g. the worker init message)', async () => {
+    const { worker, handler } = makeHandler();
+
+    const promise = handler.postMessage<string>('addEvent', 'a');
+
+    // Simulate the init message the worker emits on load. Should be ignored
+    // and not crash.
+    worker.dispatchRaw({ id: undefined, method: 'init', success: true });
+
+    // The legitimate response still resolves.
+    worker.flushOne();
+    await expect(promise).resolves.toBe('result-0');
+  });
+
   it('destroy() rejects pending requests and detaches the listener', async () => {
     const { worker, handler } = makeHandler();