@zgeoff/atc 3.4.1 → 3.5.0

package/src/test-utils/start-daemon-process.ts

@@ -39,12 +39,12 @@ interface DaemonBoot {
  * sending no handshake, and fails at once with the daemon's stderr when the
  * daemon exits before it listens. `restart` stops the daemon with the given
  * signal, waits for it to exit, and starts another on the same home with the
- * same config. `readStderr` reads what the current boot printed. Disposal
+ * same config. `readStderr` reads what the current boot printed. `stop`
  * closes every client it opened, kills the daemon and waits for it to exit,
  * then kills the daemon the home's state directory records, which a restart
- * the test asked atc for may have started. That disposal runs once the
- * current test finishes, so it must run inside a test; disposing sooner
- * runs it then, and a second disposal does nothing.
+ * the test asked atc for may have started. That stop runs once the current
+ * test finishes, so it must run inside a test; calling `stop` sooner runs it
+ * then, and a second stop does nothing.
  */
 export function startDaemonProcess(config: Readonly<DaemonProcessConfig>) {
   const socketPath = join(config.home, 'atc-daemon.sock');
@@ -53,7 +53,7 @@ export function startDaemonProcess(config: Readonly<DaemonProcessConfig>) {
   const clients = new Set<DaemonClient>();
 
   let boots = 0;
-  let disposed = false;
+  let stopped = false;
 
   const boot = (): DaemonBoot => {
     boots++;
@@ -79,8 +79,8 @@ export function startDaemonProcess(config: Readonly<DaemonProcessConfig>) {
 
   let current = boot();
 
-  const dispose = registerTestCleanup(async () => {
-    disposed = true;
+  const stop = registerTestCleanup(async () => {
+    stopped = true;
 
     for (const client of clients) {
       client.stop();
@@ -107,12 +107,12 @@ export function startDaemonProcess(config: Readonly<DaemonProcessConfig>) {
     }
   };
 
-  // A client that opens after the wait for it ended, or after disposal,
+  // A client that opens after the wait for it ended, or after the stop,
   // closes at once, so nothing outlives the daemon it reached.
   const openTrackedClient = async (isAbandoned: () => boolean) => {
     const client = await DaemonClient.open(socketPath);
 
-    if (disposed || isAbandoned()) {
+    if (stopped || isAbandoned()) {
       client.stop();
       throw new Error('the wait for the daemon ended before this client opened');
     }
@@ -132,7 +132,7 @@ export function startDaemonProcess(config: Readonly<DaemonProcessConfig>) {
     const openAfterExit = async () => {
       await watched.exited;
 
-      if (settled || disposed) {
+      if (settled || stopped) {
         return null;
       }
 
@@ -146,10 +146,10 @@ export function startDaemonProcess(config: Readonly<DaemonProcessConfig>) {
     };
 
     // Polls the socket while the daemon runs. Once the other wait settles or
-    // the daemon is disposed, each attempt resolves empty, which ends the
+    // the daemon stops, each attempt resolves empty, which ends the
     // polling.
     const openWhenListening = () =>
-      waitFor(() => (settled || disposed ? null : openTrackedClient(isSettled)), {
+      waitFor(() => (settled || stopped ? null : openTrackedClient(isSettled)), {
         timeoutMs: 15_000,
         intervalMs: 50,
       });
@@ -188,6 +188,6 @@ export function startDaemonProcess(config: Readonly<DaemonProcessConfig>) {
 
       current = boot();
     },
-    [Symbol.asyncDispose]: dispose,
+    stop,
   };
 }

package/src/test-utils/start-git-http-server.ts

@@ -7,7 +7,6 @@ interface GitHTTPServer {
   // Every Authorization header a request carried, in arrival order.
   readonly authorizations: string[];
   readonly stop: () => Promise<void>;
-  readonly [Symbol.asyncDispose]: () => Promise<void>;
 }
 
 interface GitHTTPServerOptions {
@@ -30,8 +29,8 @@ interface GitHTTPServerOptions {
  * clone through it slow. An `onRequest` callback runs, and is awaited, while
  * each authenticated request is held, so it sees the client that sent the
  * request still running. It stops once the current test finishes, so it
- * must run inside a test; `stop` or disposal stops it sooner, and a second
- * stop does nothing.
+ * must run inside a test; `stop` stops it sooner, and a second stop does
+ * nothing.
  */
 export function startGitHTTPServer(
   root: string,
@@ -97,7 +96,6 @@ export function startGitHTTPServer(
     url: `http://127.0.0.1:${server.port}/`,
     authorizations,
     stop,
-    [Symbol.asyncDispose]: stop,
   };
 }
 

package/src/test-utils/start-mcp-stdio.ts

@@ -39,8 +39,8 @@ interface MCPToolResult {
  * with the new session's id. A request still unanswered when the server's
  * stdout ends rejects. When `initialize` fails, the server is stopped
  * before the start rejects. The server stops once the current test
- * finishes, so it must run inside a test; disposal stops it sooner and waits
- * for it to exit, and a second disposal waits for the same exit. The daemon
+ * finishes, so it must run inside a test; `stop` stops it sooner and waits
+ * for it to exit, and a second stop waits for the same exit. The daemon
  * stays up for the home to stop.
  */
 export async function startMCPStdio(options: MCPStdioOptions) {
@@ -58,7 +58,7 @@ export async function startMCPStdio(options: MCPStdioOptions) {
     stderr: 'ignore',
   });
 
-  const stopServer = registerTestCleanup(async (): Promise<void> => {
+  const stop = registerTestCleanup(async (): Promise<void> => {
     void proc.stdin.end();
     proc.kill();
 
@@ -113,7 +113,7 @@ export async function startMCPStdio(options: MCPStdioOptions) {
 
       return id;
     },
-    [Symbol.asyncDispose]: stopServer,
+    stop,
   };
 
   // A failed initialize stops the server here, before the start rejects.
@@ -122,7 +122,7 @@ export async function startMCPStdio(options: MCPStdioOptions) {
     capabilities: {},
     clientInfo: { name: 'atc-test' },
   }).catch(async (error: unknown) => {
-    await stopServer();
+    await stop();
 
     throw error;
   });

package/src/test-utils/start-stub-answering-listener.ts

@@ -8,7 +8,7 @@ interface StubAnsweringListener {
 
   // The first read each connection sent, decoded, in arrival order.
   readonly lines: readonly string[];
-  readonly [Symbol.asyncDispose]: () => Promise<void>;
+  readonly stop: () => Promise<void>;
 }
 
 /**
@@ -17,7 +17,7 @@ interface StubAnsweringListener {
  * read each one sends, answers that read with the line `answer`, and
  * leaves every later byte unread on the connection. Resolves once it
  * listens. Once the current test finishes, it destroys every connection it
- * accepted and closes, so it must run inside a test; disposal does so
+ * accepted and closes, so it must run inside a test; `stop` does so
  * sooner and resolves once the server has closed, and a second stop does
  * nothing.
  */
@@ -60,6 +60,6 @@ export async function startStubAnsweringListener(path: string): Promise<StubAnsw
   return {
     peers,
     lines,
-    [Symbol.asyncDispose]: stop,
+    stop,
   };
 }

package/src/test-utils/start-stub-closing-listener.ts

@@ -1,13 +1,13 @@
 import { registerTestCleanup } from './register-test-cleanup';
 
 interface StubClosingListener {
-  readonly [Symbol.dispose]: () => void;
+  readonly stop: () => void;
 }
 
 /**
  * A stand-in for a daemon that hangs up: it listens on the unix socket path
  * and ends every connection as soon as it opens, reading nothing. It stops
- * once the current test finishes, so it must run inside a test; disposal
+ * once the current test finishes, so it must run inside a test; `stop`
  * stops it sooner, and a second stop does nothing.
  */
 export function startStubClosingListener(path: string): StubClosingListener {
@@ -26,6 +26,6 @@ export function startStubClosingListener(path: string): StubClosingListener {
   });
 
   return {
-    [Symbol.dispose]: stop,
+    stop,
   };
 }

package/src/test-utils/start-stub-dropping-daemon.ts

@@ -25,8 +25,8 @@ interface DroppingDaemonOptions {
  * idempotency key each of those requests carried, `undefined` for one that
  * carried none. `reads` counts the reads it has taken from every connection,
  * so a test can wait until one piece of a split write has arrived. It stops
- * once the current test finishes, so it must run inside a test; `stop` or
- * disposal stops it sooner, and a second stop does nothing.
+ * once the current test finishes, so it must run inside a test; `stop`
+ * stops it sooner, and a second stop does nothing.
  */
 export function startStubDroppingDaemon(socketPath: string, options: DroppingDaemonOptions) {
   const keys: unknown[] = [];
@@ -100,6 +100,5 @@ export function startStubDroppingDaemon(socketPath: string, options: DroppingDae
       return reads;
     },
     stop,
-    [Symbol.dispose]: stop,
   };
 }

package/src/test-utils/start-stub-impd-info.ts

@@ -6,9 +6,8 @@ import { registerTestCleanup } from './register-test-cleanup';
  * `{ json: info }`, so a client reads `info.features` as impd's features;
  * the test sets `info.features` to what impd should report. `paths` holds
  * the request path of each call, in order. The server stops once the
- * current test finishes, so it must run inside a test; disposal stops it
- * sooner, the asynchronous form resolving once it has stopped, and a second
- * stop does nothing.
+ * current test finishes, so it must run inside a test; `stop` stops it
+ * sooner and resolves once it has stopped, and a second stop does nothing.
  */
 export function startStubImpdInfo() {
   const paths: string[] = [];
@@ -30,9 +29,6 @@ export function startStubImpdInfo() {
     url: `http://127.0.0.1:${String(server.port)}`,
     paths,
     info,
-    [Symbol.dispose]: () => {
-      void stop();
-    },
-    [Symbol.asyncDispose]: stop,
+    stop,
   };
 }

package/src/test-utils/start-stub-impd.ts

@@ -18,8 +18,8 @@ type StubExecReply = 'refuse' | 'count' | 'exit-early';
  * whose broker is not ready by default. It takes no WebSocket message over
  * 2 MiB, as impd refuses one over its own limit. The server stops, dropping
  * every open connection at once, when the current test finishes, so it must
- * run inside a test; disposal stops it sooner, and a second stop does
- * nothing.
+ * run inside a test; `stop` stops it sooner and resolves once it has
+ * stopped, and a second stop does nothing.
  */
 export function startStubImpd() {
   const authorizations: (string | null)[] = [];
@@ -136,8 +136,6 @@ export function startStubImpd() {
     controls,
     execOpens,
     exec,
-    [Symbol.dispose]: () => {
-      void stop();
-    },
+    stop,
   };
 }

package/src/test-utils/start-stub-legacy-daemon.ts

@@ -47,8 +47,8 @@ interface StubLegacyDaemonOptions {
  * `connections` counts the connections it accepted and those still open.
  * `port` holds the TCP port it bound, `null` on a unix socket. It stops
  * once the current test finishes, so it must run inside a test, unless the
- * options make the caller its owner; `stop` or disposal stops it sooner, and
- * a second stop does nothing.
+ * options make the caller its owner; `stop` stops it sooner, and a second
+ * stop does nothing.
  */
 export function startStubLegacyDaemon(
   address: string | StubLegacyDaemonTCPAddress,
@@ -135,7 +135,6 @@ export function startStubLegacyDaemon(
     connections,
     port: server.port,
     stop,
-    [Symbol.dispose]: stop,
   };
 }
 

package/src/test-utils/start-stub-mcp-server.ts

@@ -14,7 +14,7 @@ interface StubMCPServer {
   // Every request the stand-in received, in arrival order.
   readonly requests: readonly StubMCPRequest[];
 
-  readonly [Symbol.dispose]: () => void;
+  readonly stop: () => Promise<void>;
 }
 
 /**
@@ -22,7 +22,7 @@ interface StubMCPServer {
  * request with the JSON body given, and records each request's method,
  * path, authorization and content-type headers, and JSON body. `url` holds
  * its origin. It stops once the current test finishes, so it must run
- * inside a test; disposal stops it sooner, and a second stop does nothing.
+ * inside a test; `stop` stops it sooner, and a second stop does nothing.
  */
 export function startStubMCPServer(answer: unknown): StubMCPServer {
   const requests: StubMCPRequest[] = [];
@@ -48,8 +48,6 @@ export function startStubMCPServer(answer: unknown): StubMCPServer {
   return {
     url: `http://127.0.0.1:${String(server.port)}`,
     requests,
-    [Symbol.dispose]: () => {
-      void stop();
-    },
+    stop,
   };
 }

package/src/test-utils/start-stub-recording-listener.ts

@@ -7,7 +7,7 @@ interface StubRecordingListener {
 
   // What each read took from any connection, decoded, in arrival order.
   readonly received: readonly string[];
-  readonly [Symbol.dispose]: () => void;
+  readonly stop: () => void;
 }
 
 /**
@@ -15,7 +15,7 @@ interface StubRecordingListener {
  * socket path, hands the test the server's side of the first connection it
  * accepts, records what each read takes from any connection, and sends
  * nothing of its own. It stops, dropping every connection it holds, once
- * the current test finishes, so it must run inside a test; disposal stops it
+ * the current test finishes, so it must run inside a test; `stop` stops it
  * sooner, and a second stop does nothing.
  */
 export function startStubRecordingListener(path: string): StubRecordingListener {
@@ -42,6 +42,6 @@ export function startStubRecordingListener(path: string): StubRecordingListener
   return {
     accepted: accepted.promise,
     received,
-    [Symbol.dispose]: stop,
+    stop,
   };
 }

package/src/test-utils/start-stub-refusing-listener.ts

@@ -6,7 +6,7 @@ interface StubRefusingListener {
   // What each read took from any connection, decoded, in arrival order.
   readonly received: readonly string[];
 
-  readonly [Symbol.dispose]: () => void;
+  readonly stop: () => void;
 }
 
 /**
@@ -14,7 +14,7 @@ interface StubRefusingListener {
  * line is not a handshake: on a loopback port, it records what each read
  * takes from a connection and ends that connection, answering nothing.
  * It stops once the current test finishes, so it must run inside a test;
- * disposal stops it sooner, and a second stop does nothing.
+ * `stop` stops it sooner, and a second stop does nothing.
  */
 export function startStubRefusingListener(): StubRefusingListener {
   const received: string[] = [];
@@ -38,6 +38,6 @@ export function startStubRefusingListener(): StubRefusingListener {
   return {
     port: server.port,
     received,
-    [Symbol.dispose]: stop,
+    stop,
   };
 }

package/src/test-utils/start-stub-reporter-socket.ts

@@ -9,8 +9,7 @@ interface StubReporterSocket {
   // can wait until one piece of a split write has arrived.
   readonly reads: number;
   readonly waitForLine: (timeoutMs?: number) => Promise<string>;
-  readonly [Symbol.dispose]: () => void;
-  readonly [Symbol.asyncDispose]: () => Promise<void>;
+  readonly stop: () => void;
 }
 
 /**
@@ -21,7 +20,7 @@ interface StubReporterSocket {
  * connection for the sender to close. `waitForLine` resolves with the first
  * line once one has arrived, and rejects naming the socket when none arrives
  * within `timeoutMs`, 5 seconds by default. The listener stops once the
- * current test finishes, so it must run inside a test; disposal stops it
+ * current test finishes, so it must run inside a test; `stop` stops it
  * sooner, and a second stop does nothing.
  */
 export function startStubReporterSocket(path: string): StubReporterSocket {
@@ -69,11 +68,6 @@ export function startStubReporterSocket(path: string): StubReporterSocket {
         },
         { timeoutMs },
       ),
-    [Symbol.dispose]: stop,
-    [Symbol.asyncDispose]: () => {
-      stop();
-
-      return Promise.resolve();
-    },
+    stop,
   };
 }

package/src/test-utils/start-stub-restore-daemon.ts

@@ -9,7 +9,7 @@ import { registerTestCleanup } from './register-test-cleanup';
  * onto `lists`, and withholds the answer to any request that finds `lists`
  * empty. `methods` holds the method of each request it took, in order.
  * The listener stops once the current test finishes, so it must run inside
- * a test; disposal stops it sooner, and a second stop does nothing.
+ * a test; `stop` stops it sooner, and a second stop does nothing.
  */
 export function startStubRestoreDaemon(socketPath: string) {
   const lists: Readonly<Record<string, unknown>>[] = [];
@@ -49,11 +49,6 @@ export function startStubRestoreDaemon(socketPath: string) {
   return {
     lists,
     methods,
-    [Symbol.dispose]: stop,
-    [Symbol.asyncDispose]: () => {
-      stop();
-
-      return Promise.resolve();
-    },
+    stop,
   };
 }

package/src/test-utils/start-stub-session-bridge.ts

@@ -16,8 +16,7 @@ interface StubSessionBridge {
   // How many reads the stand-in has taken from its connections, so a test
   // can wait until one piece of a split write has arrived.
   readonly reads: number;
-  readonly [Symbol.dispose]: () => void;
-  readonly [Symbol.asyncDispose]: () => Promise<void>;
+  readonly stop: () => void;
 }
 
 /**
@@ -28,7 +27,7 @@ interface StubSessionBridge {
  * does once it attaches the tap, and hands every other request to the
  * responder, writing back each line it returns. A line that is not a JSON
  * object reaches the responder as an empty request. The listener stops once
- * the current test finishes, so it must run inside a test; disposal stops it
+ * the current test finishes, so it must run inside a test; `stop` stops it
  * sooner, and a second stop does nothing.
  */
 export function startStubSessionBridge(path: string, respond: BridgeResponder): StubSessionBridge {
@@ -80,12 +79,7 @@ export function startStubSessionBridge(path: string, respond: BridgeResponder):
     get reads() {
       return reads;
     },
-    [Symbol.dispose]: stop,
-    [Symbol.asyncDispose]: () => {
-      stop();
-
-      return Promise.resolve();
-    },
+    stop,
   };
 }
 

package/src/test-utils/start-stub-silent-server.ts

@@ -5,8 +5,8 @@ import { registerTestCleanup } from './register-test-cleanup';
  * the loopback address, takes every request, and never answers one. `paths`
  * holds the request path of each request it took, in order. The server
  * stops, dropping the connections it holds, once the current test finishes,
- * so it must run inside a test; disposal stops it sooner, the asynchronous
- * form resolving once it has stopped, and a second stop does nothing.
+ * so it must run inside a test; `stop` stops it sooner and resolves once it
+ * has stopped, and a second stop does nothing.
  */
 export function startStubSilentServer() {
   const paths: string[] = [];
@@ -30,9 +30,6 @@ export function startStubSilentServer() {
   return {
     url: `http://127.0.0.1:${String(server.port)}/`,
     paths,
-    [Symbol.dispose]: () => {
-      void stop();
-    },
-    [Symbol.asyncDispose]: stop,
+    stop,
   };
 }

package/src/test-utils/start-stub-source-daemon.ts

@@ -10,10 +10,10 @@ import { registerTestCleanup } from './register-test-cleanup';
  * `none`; `ATC_TEST_FIXTURE_URL` holds the repository the fixture source
  * lists, and `ATC_TEST_SOURCE_LOG` a file it appends each listing to.
  * The process stops once the current test finishes, so it must run inside
- * a test; disposal stops it sooner, and a second stop does nothing.
+ * a test; `stop` stops it sooner, and a second stop does nothing.
  */
 export async function startStubSourceDaemon(env: Readonly<Record<string, string | undefined>>) {
-  const daemon = Bun.spawn([process.execPath, join(import.meta.dir, 'run-source-daemon.ts')], {
+  const daemon = Bun.spawn([process.execPath, join(import.meta.dir, 'run-stub-source-daemon.ts')], {
     env: { ATC_TEST_SOURCES: 'fixture', ...env },
     stdout: 'pipe',
     stderr: 'ignore',
@@ -37,5 +37,5 @@ export async function startStubSourceDaemon(env: Readonly<Record<string, string
     throw new Error('the source daemon exited before it listened');
   }
 
-  return { pid: daemon.pid, [Symbol.asyncDispose]: stop };
+  return { pid: daemon.pid, stop };
 }

package/src/test-utils/start-stub-stalled-client.ts

@@ -8,7 +8,7 @@ interface StubStalledClient {
 
   // How many bytes have arrived on the connection and wait unread.
   readonly countUnreadBytes: () => number;
-  readonly [Symbol.dispose]: () => void;
+  readonly stop: () => void;
 }
 
 /**
@@ -18,7 +18,7 @@ interface StubStalledClient {
  * a promise that never resolves, so whatever the daemon sends it after
  * that backs up. Resolves once that first chunk arrives. The connection is
  * destroyed once the current test finishes, so it must run inside a test;
- * disposal destroys it sooner, and a second stop does nothing.
+ * `stop` destroys it sooner, and a second stop does nothing.
  */
 export async function startStubStalledClient(
   socketPath: string,
@@ -56,6 +56,6 @@ export async function startStubStalledClient(
   return {
     chunks,
     countUnreadBytes: () => socket.readableLength,
-    [Symbol.dispose]: stop,
+    stop,
   };
 }

package/src/test-utils/start-stub-stalled-listener.ts

@@ -3,7 +3,7 @@ import type { Socket } from 'node:net';
 import { registerTestCleanup } from './register-test-cleanup';
 
 interface StubStalledListener {
-  readonly [Symbol.dispose]: () => void;
+  readonly stop: () => void;
 }
 
 /**
@@ -11,7 +11,7 @@ interface StubStalledListener {
  * path and accepts every connection but never reads from it, so what the
  * kernel does not buffer stays queued on the sender's side. Resolves once
  * it listens. Once the current test finishes, it destroys every connection
- * it accepted and stops, so it must run inside a test; disposal does so
+ * it accepted and stops, so it must run inside a test; `stop` does so
  * sooner, and a second stop does nothing.
  */
 export async function startStubStalledListener(path: string): Promise<StubStalledListener> {
@@ -39,6 +39,6 @@ export async function startStubStalledListener(path: string): Promise<StubStalle
   });
 
   return {
-    [Symbol.dispose]: stop,
+    stop,
   };
 }

package/src/test-utils/start-stub-tcp-daemon.ts

@@ -12,7 +12,7 @@ interface StubTCPDaemon {
   // can wait until one piece of a split write has arrived before it sends
   // the next.
   readonly reads: number;
-  readonly [Symbol.dispose]: () => void;
+  readonly stop: () => void;
 }
 
 // The two request fields the stand-in reads; every other field passes
@@ -25,7 +25,7 @@ const REQUEST = z.object({ id: z.number(), m: z.string() });
  * the request's method, recording every method in `seen`. It sends no
  * handshake of its own and checks no token. `reads` counts the reads it has
  * taken from every connection. It stops once the current test finishes, so
- * it must run inside a test; disposal stops it sooner, and a second stop
+ * it must run inside a test; `stop` stops it sooner, and a second stop
  * does nothing.
  */
 export function startStubTCPDaemon(): StubTCPDaemon {
@@ -70,6 +70,6 @@ export function startStubTCPDaemon(): StubTCPDaemon {
     get reads() {
       return reads;
     },
-    [Symbol.dispose]: stop,
+    stop,
   };
 }

package/src/test-utils/start-stub-telemetry-collector.ts

@@ -5,7 +5,7 @@ import { registerTestCleanup } from './register-test-cleanup';
  * loopback address. A process whose `BETTER_AUTH_TELEMETRY_ENDPOINT` holds
  * `url` sends its telemetry here. Every request is answered with HTTP 204,
  * and `received` holds the URL of each request, in order. The server stops
- * once the current test finishes, so it must run inside a test; disposal
+ * once the current test finishes, so it must run inside a test; `stop`
  * stops it sooner and resolves once it has stopped, and a second stop does
  * nothing.
  */
@@ -27,6 +27,6 @@ export function startStubTelemetryCollector() {
   return {
     url: `http://127.0.0.1:${String(server.port)}/`,
     received,
-    [Symbol.asyncDispose]: stop,
+    stop,
   };
 }

package/src/test-utils/start-stub-unanswering-listener.ts

@@ -6,7 +6,7 @@ interface StubUnansweringListener {
   // What each read took from any connection, decoded, in arrival order.
   readonly received: readonly string[];
 
-  readonly [Symbol.dispose]: () => void;
+  readonly stop: () => void;
 }
 
 /**
@@ -14,7 +14,7 @@ interface StubUnansweringListener {
  * on a loopback port, it records what each read takes from a connection,
  * sends nothing back, and keeps the connection open. It stops, dropping
  * every connection it holds, once the current test finishes, so it must run
- * inside a test; disposal stops it sooner, and a second stop does nothing.
+ * inside a test; `stop` stops it sooner, and a second stop does nothing.
  */
 export function startStubUnansweringListener(): StubUnansweringListener {
   const received: string[] = [];
@@ -36,6 +36,6 @@ export function startStubUnansweringListener(): StubUnansweringListener {
   return {
     port: server.port,
     received,
-    [Symbol.dispose]: stop,
+    stop,
   };
 }

package/src/test-utils/start-stub-unanswering-unix-listener.ts

@@ -4,7 +4,7 @@ interface StubUnansweringUnixListener {
   // What each read took from any connection, decoded, in arrival order.
   readonly received: readonly string[];
 
-  readonly [Symbol.dispose]: () => void;
+  readonly stop: () => void;
 }
 
 /**
@@ -12,7 +12,7 @@ interface StubUnansweringUnixListener {
  * it: it listens on the unix socket path, records what each read takes from
  * a connection, sends nothing back, and keeps the connection open. It
  * stops, dropping every connection it holds, once the current test
- * finishes, so it must run inside a test; disposal stops it sooner, and a
+ * finishes, so it must run inside a test; `stop` stops it sooner, and a
  * second stop does nothing.
  */
 export function startStubUnansweringUnixListener(path: string): StubUnansweringUnixListener {
@@ -33,6 +33,6 @@ export function startStubUnansweringUnixListener(path: string): StubUnansweringU
 
   return {
     received,
-    [Symbol.dispose]: stop,
+    stop,
   };
 }