fix(ios-snapshot): remove the stop listener when a detached wait settles

waitForDetachedAttempt added an abort listener to stop but only ever removed
the one on signal, so every call with no explicit stop leaked one listener
onto the module-level NO_STOP signal per production caller (lifecycle.ts's
bridge-connect retry sleep and every bridge request's waitForSimulatorTurn).
Make stop optional, remove its listener on every settle path, and delete
NO_STOP now that the wait tolerates a missing stop directly.

Author: thymikee

packages/platform-apple/src/detached-attempt.test.ts

@@ -1,6 +1,7 @@
 import assert from 'node:assert/strict';
-import { test } from 'vitest';
-import { createDetachedAttempts } from './detached-attempt.ts';
+import { getEventListeners } from 'node:events';
+import { test, vi } from 'vitest';
+import { createDetachedAttempts, waitForDetachedAttempt } from './detached-attempt.ts';
 
 const PENDING = new Error('still-running');
 
@@ -249,6 +250,49 @@ test('a caller answered by the attempt stops the wait it left running', async ()
   assert.equal(waitState, 'resolved');
 });
 
+test('a wait that settles by its own timeout releases the stop listener it added', async () => {
+  vi.useFakeTimers();
+  try {
+    const stop = new AbortController();
+    const waiting = waitForDetachedAttempt({
+      waitMs: 20,
+      signal: undefined,
+      stop: stop.signal,
+      cancelled: () => new Error('unreachable'),
+    });
+
+    await vi.advanceTimersByTimeAsync(20);
+    await waiting;
+
+    assert.equal(getEventListeners(stop.signal, 'abort').length, 0);
+  } finally {
+    vi.useRealTimers();
+  }
+});
+
+test('a caller signal already aborted rejects at once, without spending waitMs', async () => {
+  vi.useFakeTimers();
+  try {
+    const controller = new AbortController();
+    const stop = new AbortController();
+    const reason = new Error('already-cancelled');
+    controller.abort(reason);
+
+    const waiting = waitForDetachedAttempt({
+      waitMs: 60_000,
+      signal: controller.signal,
+      stop: stop.signal,
+      cancelled: () => reason,
+    });
+
+    await assert.rejects(waiting, (error) => error === reason);
+    assert.equal(vi.getTimerCount(), 0);
+    assert.equal(getEventListeners(stop.signal, 'abort').length, 0);
+  } finally {
+    vi.useRealTimers();
+  }
+});
+
 function identity(error: unknown): unknown {
   return error;
 }

packages/platform-apple/src/detached-attempt.ts

@@ -68,16 +68,16 @@ type Attempt<Value> = {
  * this module describes: sleeps `waitMs`, resolves when that sleep is spent or when `stop` says the
  * answer arrived elsewhere, and rejects only on the caller's own abort so that stays typed.
  *
- * `stop` needs neither cleanup nor an already-aborted check: `value()` creates it moments before
- * calling and aborts it in a `finally`, which releases the `{ once: true }` listener. The caller's
- * signal outlives the wait and does have its listener removed.
+ * Every listener this adds to a signal it did not create is removed once the wait settles, on every
+ * path (timeout, `stop`, or the caller's own abort) — `stop` is optional for a caller with no signal
+ * to end the wait early.
  */
 export function waitForDetachedAttempt(
   params: Readonly<{
     waitMs: number;
     /** The caller's own deadline signal; a wait inside it keeps a client abort a client abort. */
     signal: AbortSignal | undefined;
-    stop: AbortSignal;
+    stop: AbortSignal | undefined;
     /** The rejection for the caller aborting, so each owner keeps its own error type. */
     cancelled: () => unknown;
   }>,
@@ -90,11 +90,12 @@ export function waitForDetachedAttempt(
     function finish(settle: () => void): void {
       clearTimeout(timer);
       signal?.removeEventListener('abort', onAbort);
+      stop?.removeEventListener('abort', onStop);
       settle();
     }
     signal?.addEventListener('abort', onAbort, { once: true });
+    stop?.addEventListener('abort', onStop, { once: true });
     if (signal?.aborted) onAbort();
-    stop.addEventListener('abort', onStop, { once: true });
   });
 }
 

packages/platform-apple/src/snapshot-source/deadline.test.ts

@@ -1,3 +1,4 @@
+import { getEventListeners } from 'node:events';
 import { expect, test, vi } from 'vitest';
 import { createSnapshotSourceDeadline, waitForSnapshotSourceDelay } from './deadline.ts';
 import { SnapshotSourceError } from './errors.ts';
@@ -47,3 +48,22 @@ test('an aborted caller signal stays typed cancellation next to a stop', async (
     vi.useRealTimers();
   }
 });
+
+test('a delay called with no stop, the way every lifecycle site sends it, leaves no listener behind', async () => {
+  vi.useFakeTimers();
+  try {
+    const caller = new AbortController();
+    const deadline = createSnapshotSourceDeadline(60_000, caller.signal);
+
+    for (let attempt = 0; attempt < 3; attempt += 1) {
+      const waiting = waitForSnapshotSourceDelay(deadline, 1_000, WAIT_CODE);
+      await vi.advanceTimersByTimeAsync(1_000);
+      await waiting;
+    }
+
+    expect(getEventListeners(caller.signal, 'abort').length).toBe(0);
+    expect(vi.getTimerCount()).toBe(0);
+  } finally {
+    vi.useRealTimers();
+  }
+});

packages/platform-apple/src/snapshot-source/deadline.ts

@@ -25,9 +25,6 @@ export function remainingSnapshotSourceMs(deadline: SnapshotSourceDeadline, code
   return Math.max(1, Math.floor(remainingMs));
 }
 
-/** A sleep nobody has asked to end early. */
-const NO_STOP = new AbortController().signal;
-
 /**
  * Sleeps inside the caller's own deadline, so a client abort stays a typed `cancelled` instead of
  * arriving as a fresh timeout. `stop` is for a caller that no longer needs the sleep because the work
@@ -43,7 +40,7 @@ export async function waitForSnapshotSourceDelay(
   await waitForDetachedAttempt({
     waitMs: delayMs,
     signal: deadline.signal,
-    stop: stop ?? NO_STOP,
+    stop,
     cancelled: () => snapshotSourceError('cancelled', 'abort-signal'),
   });
 }