@zgeoff/atc 3.4.2 → 3.5.0

package/src/test-utils/create-stub-imp-port.ts

@@ -43,12 +43,10 @@ const GUEST_PATH = '/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
 
 // A hold on the commands whose argv holds its text: entered resolves with
 // the argv of the first command it holds, and stop lets every command it
-// holds run. Disposing the hold stops it, so a test that holds it with
-// `using` after its daemon lets the daemon stop even when the test fails.
+// holds run.
 interface StubCommandHold {
   readonly entered: Promise<string>;
   readonly stop: () => void;
-  readonly [Symbol.dispose]: () => void;
 }
 
 /**
@@ -475,7 +473,7 @@ class StubImpPort implements ImpPort {
     }
 
     for (const proc of imp.sessions.values()) {
-      proc.connection?.finish({ kind: 'closed', reason: 'imp destroyed', closeCode: 1000 });
+      proc.connection?.stop({ kind: 'closed', reason: 'imp destroyed', closeCode: 1000 });
       proc.connection = null;
       proc.exited ??= { code: null };
 
@@ -504,7 +502,7 @@ class StubImpPort implements ImpPort {
       sent: 0,
       finished: false,
       process: null,
-      finish: (result) => {
+      stop: (result) => {
         if (connection.finished) {
           return;
         }
@@ -523,7 +521,7 @@ class StubImpPort implements ImpPort {
     // lets it go; a closed gate sends nothing.
     const sendToImpd = () => {
       if (gate !== undefined && !tryPassGate(gate)) {
-        connection.finish({ kind: 'closed', reason: 'closed before sending', closeCode: 1000 });
+        connection.stop({ kind: 'closed', reason: 'closed before sending', closeCode: 1000 });
 
         return;
       }
@@ -548,7 +546,7 @@ class StubImpPort implements ImpPort {
       this.upgradeFailures -= 1;
 
       setTimeout(() => {
-        connection.finish({ kind: 'unreachable', detail: 'the upgrade failed' });
+        connection.stop({ kind: 'unreachable', detail: 'the upgrade failed' });
       }, 0);
     } else if (this.upgrades === null) {
       sendToImpd();
@@ -575,7 +573,7 @@ class StubImpPort implements ImpPort {
         }
       },
       close: () => {
-        connection.finish({ kind: 'closed', reason: 'closed by the client', closeCode: 1000 });
+        connection.stop({ kind: 'closed', reason: 'closed by the client', closeCode: 1000 });
       },
     };
   }
@@ -852,7 +850,7 @@ class StubImpPort implements ImpPort {
   stopConnection(name: string, session: string, closeCode: number): void {
     const proc = this.getImp(name).sessions.get(session);
 
-    proc?.connection?.finish({ kind: 'closed', reason: `code ${closeCode}`, closeCode });
+    proc?.connection?.stop({ kind: 'closed', reason: `code ${closeCode}`, closeCode });
   }
 
   /**
@@ -1067,7 +1065,7 @@ class StubImpPort implements ImpPort {
       hold.done.resolve();
     };
 
-    return { entered: hold.entered.promise, stop, [Symbol.dispose]: stop };
+    return { entered: hold.entered.promise, stop };
   }
 
   // How many commands wait for their command hold to stop.
@@ -1172,7 +1170,10 @@ class StubImpPort implements ImpPort {
     return proc.end;
   }
 
-  [Symbol.dispose](): void {
+  // Kills every process and stops every forward the stand-in holds. It runs
+  // once the current test finishes; calling it sooner runs it then, and a
+  // second call does nothing.
+  readonly stop: () => void = registerTestCleanup(() => {
     this.stopCommandHold();
 
     for (const imp of this.imps.values()) {
@@ -1187,7 +1188,7 @@ class StubImpPort implements ImpPort {
     }
 
     this.imps.clear();
-  }
+  });
 
   // impd's refusal of a grant or revoke: the scope and pattern checks run
   // before anything is looked up, then a missing imp or secret.
@@ -1278,13 +1279,13 @@ class StubImpPort implements ImpPort {
 
     for (const proc of imp.sessions.values()) {
       tryKill(proc.pty, 'SIGSTOP');
-      proc.connection?.finish({ kind: 'detached', reason: 'lost', offset: proc.end });
+      proc.connection?.stop({ kind: 'detached', reason: 'lost', offset: proc.end });
     }
   }
 
   private bootCold(imp: StubImp, cause: ColdBootCause): void {
     for (const proc of imp.sessions.values()) {
-      proc.connection?.finish({ kind: 'detached', reason: 'lost', offset: proc.end });
+      proc.connection?.stop({ kind: 'detached', reason: 'lost', offset: proc.end });
       proc.ended = true;
 
       tryKill(proc.pty, 'SIGCONT');
@@ -1311,7 +1312,7 @@ class StubImpPort implements ImpPort {
     if (this.drops.count > 0) {
       this.drops.count -= 1;
 
-      connection.finish({
+      connection.stop({
         kind: 'closed',
         reason: `code ${this.drops.closeCode}`,
         closeCode: this.drops.closeCode,
@@ -1325,7 +1326,7 @@ class StubImpPort implements ImpPort {
     if (failure !== null) {
       this.nextFailure = null;
 
-      connection.finish({
+      connection.stop({
         kind: 'failed',
         code: failure.code,
         message: failure.message ?? `impd refused the session (${failure.code})`,
@@ -1338,7 +1339,7 @@ class StubImpPort implements ImpPort {
     const imp = this.imps.get(request.name);
 
     if (imp === undefined) {
-      connection.finish({
+      connection.stop({
         kind: 'failed',
         code: 'NOT_FOUND',
         message: `no imp ${request.name}`,
@@ -1349,7 +1350,7 @@ class StubImpPort implements ImpPort {
     }
 
     if (imp.state !== 'running' && request.kind === 'attach' && !request.wake) {
-      connection.finish({
+      connection.stop({
         kind: 'failed',
         code: 'INVALID_STATE',
         message: `imp ${imp.name} is ${imp.state}`,
@@ -1369,7 +1370,7 @@ class StubImpPort implements ImpPort {
     const brokerProblem = this.findBrokerProblem(imp, request, running);
 
     if (brokerProblem !== null) {
-      connection.finish({
+      connection.stop({
         kind: 'failed',
         code: 'PRECONDITION_FAILED',
         message: `the broker is not ready in imp ${imp.name}`,
@@ -1382,7 +1383,7 @@ class StubImpPort implements ImpPort {
     if (running === undefined && request.kind === 'attach') {
       const previous = imp.previous.get(request.session);
 
-      connection.finish({
+      connection.stop({
         kind: 'failed',
         code: 'NO_SESSION',
         message: `no session ${request.session}`,
@@ -1514,7 +1515,7 @@ class StubImpPort implements ImpPort {
       // delivers it.
       if (connection !== null) {
         imp.sessions.delete(request.session);
-        connection.finish({ kind: 'exit', code: exitCode, signal: null, offset: proc.end });
+        connection.stop({ kind: 'exit', code: exitCode, signal: null, offset: proc.end });
       }
     });
 
@@ -1543,7 +1544,7 @@ class StubImpPort implements ImpPort {
           firstOffset: bufferStart,
         };
       } else if (resumeFrom.offset > proc.end) {
-        connection.finish({
+        connection.stop({
           kind: 'failed',
           code: 'INVALID_RESUME',
           message: 'the resume offset is past the end',
@@ -1566,7 +1567,7 @@ class StubImpPort implements ImpPort {
       prelude = PRELUDE;
     }
 
-    proc.connection?.finish({
+    proc.connection?.stop({
       kind: 'detached',
       reason: 'taken_over',
       offset: proc.connection.sent,
@@ -1619,8 +1620,13 @@ class StubImpPort implements ImpPort {
     }
 
     if (proc.exited !== null) {
-      imp.sessions.delete(findSessionName(imp, proc));
-      connection.finish({ kind: 'exit', code: proc.exited.code, signal: null, offset: proc.end });
+      const name = findSessionName(imp, proc);
+
+      if (name !== undefined) {
+        imp.sessions.delete(name);
+      }
+
+      connection.stop({ kind: 'exit', code: proc.exited.code, signal: null, offset: proc.end });
 
       return;
     }
@@ -1650,16 +1656,10 @@ class StubImpPort implements ImpPort {
  * broker variable, and when it would join a process that started without
  * the broker required. Once the current test finishes, the stand-in kills
  * every process and stops every forward it holds, so it must be created inside
- * a test; disposal does so sooner, and a second disposal does nothing.
+ * a test; `stop` does so sooner, and a second stop does nothing.
  */
 export function createStubImpPort(principal = 'token:atc'): StubImpPort {
-  const port = new StubImpPort(principal);
-
-  registerTestCleanup(() => {
-    port[Symbol.dispose]();
-  });
-
-  return port;
+  return new StubImpPort(principal);
 }
 
 interface StubLease {
@@ -1703,7 +1703,7 @@ interface StubConnection {
   sent: number;
   finished: boolean;
   process: StubProcess | null;
-  readonly finish: (outcome: ImpSessionOutcome) => void;
+  readonly stop: (outcome: ImpSessionOutcome) => void;
 }
 
 interface StubRelay {
@@ -1743,7 +1743,7 @@ function tryEmit(connection: StubConnection, emit: () => void): boolean {
 
     return true;
   } catch (error) {
-    connection.finish({
+    connection.stop({
       kind: 'local_error',
       detail: error instanceof Error ? error.message : String(error),
     });
@@ -1752,14 +1752,14 @@ function tryEmit(connection: StubConnection, emit: () => void): boolean {
   }
 }
 
-function findSessionName(imp: StubImp, proc: StubProcess): string {
+function findSessionName(imp: StubImp, proc: StubProcess): string | undefined {
   for (const [name, held] of imp.sessions) {
     if (held === proc) {
       return name;
     }
   }
 
-  return '';
+  return undefined;
 }
 
 function toSignal(name: string): NodeJS.Signals {

package/src/test-utils/create-stub-systemd.ts

@@ -8,7 +8,7 @@ interface StubSystemd {
   // first on the PATH of every process that could reach a real one.
   readonly binDir: string;
 
-  // The directory `ATC_PROC_ROOT` points at, where `placeInUnit` writes.
+  // The directory `ATC_PROC_ROOT` points at, where `writeUnitCgroup` writes.
   readonly procRoot: string;
 
   // The arguments of every `systemctl` call, one line per call.
@@ -22,9 +22,9 @@ interface StubSystemd {
 
   // Places the pid in a user service of the given name, as the cgroup of a
   // daemon run by a user manager reads.
-  readonly placeInUnit: (pid: number, unit: string) => void;
+  readonly writeUnitCgroup: (pid: number, unit: string) => void;
 
-  readonly [Symbol.dispose]: () => void;
+  readonly remove: () => void;
 }
 
 /**
@@ -36,7 +36,7 @@ interface StubSystemd {
  * `--` in the background with only the `--setenv` variables, as a transient
  * unit sees them, and appends its output to the `StandardOutput=append:`
  * file. Every call is logged. The stand-ins' directory is removed once the
- * current test finishes, so it must run inside a test; disposal removes it
+ * current test finishes, so it must run inside a test; `remove` removes it
  * sooner, and a second removal does nothing.
  */
 export function createStubSystemd(atcCommand: readonly string[]): StubSystemd {
@@ -118,7 +118,7 @@ exit 0
     writeMainPID: (pid) => {
       writeFileSync(join(root, 'mainpid'), String(pid));
     },
-    placeInUnit: (pid, unit) => {
+    writeUnitCgroup: (pid, unit) => {
       mkdirSync(join(procRoot, String(pid)), { recursive: true });
 
       writeFileSync(
@@ -126,6 +126,6 @@ exit 0
         `0::/user.slice/user-${process.getuid?.() ?? 0}.slice/user@${process.getuid?.() ?? 0}.service/app.slice/${unit}\n`,
       );
     },
-    [Symbol.dispose]: remove,
+    remove,
   };
 }

package/src/test-utils/isolate-home.ts

@@ -16,7 +16,7 @@ if (marker === undefined) {
   stopRun('a bare `bun test` runs against your real home; run `bun run test` instead');
 }
 
-assertTestHome(marker);
+requireTestHome(marker);
 
 afterEach(() => {
   removeEnvOverrides();
@@ -26,7 +26,7 @@ afterEach(() => {
 // points under it and no enclosing session's variables remain; a stale or
 // hand-set marker stops the run before any test imports atc. An inherited
 // CLAUDE_CONFIG_DIR would move the Claude config folder out of the home.
-function assertTestHome(root: string): void {
+function requireTestHome(root: string): void {
   const expected: Readonly<Record<string, string>> = {
     HOME: join(root, 'home'),
     XDG_RUNTIME_DIR: join(root, 'runtime'),
@@ -42,9 +42,12 @@ function assertTestHome(root: string): void {
     .filter(([name, path]) => normalize(process.env[name] ?? '') !== path)
     .map(([name]) => name);
 
-  const leftover = ['ATC_SESSION_ID', 'ATC_SOCKET', 'CLAUDE_CONFIG_DIR'].filter(
-    (name) => name in process.env,
-  );
+  const leftover = [
+    'ATC_SESSION_ID',
+    'ATC_SOCKET',
+    'ATC_SESSION_RECORD',
+    'CLAUDE_CONFIG_DIR',
+  ].filter((name) => name in process.env);
 
   if (mismatched.length > 0 || leftover.length > 0) {
     stopRun(

package/src/test-utils/read-query-plan.ts

@@ -9,14 +9,18 @@ import type { CompiledQuery } from 'kysely';
  * before returning, so the query never runs and nothing is written.
  */
 export function readQueryPlan(dbPath: string, query: CompiledQuery): string {
-  using db = new Database(dbPath, { readonly: true });
+  const db = new Database(dbPath, { readonly: true });
 
   // oxlint-disable-next-line no-unsafe-type-assertion -- kysely's sqlite compiler only ever binds bun:sqlite-legal values
   const bindings = query.parameters as SQLQueryBindings[];
 
-  return db
-    .query<{ detail: string }, SQLQueryBindings[]>(`EXPLAIN QUERY PLAN ${query.sql}`)
-    .all(...bindings)
-    .map((row) => row.detail)
-    .join('\n');
+  try {
+    return db
+      .query<{ detail: string }, SQLQueryBindings[]>(`EXPLAIN QUERY PLAN ${query.sql}`)
+      .all(...bindings)
+      .map((row) => row.detail)
+      .join('\n');
+  } finally {
+    db.close();
+  }
 }

package/src/test-utils/register-test-cleanup.ts

@@ -7,16 +7,16 @@ let pending: (() => unknown)[] | null = null;
 /**
  * Registers the release of a resource a test just acquired, to run once the
  * current test finishes, and returns that release for the resource's own
- * stop and dispose members. Every release a test registers runs from one
- * hook, last registered first, as `using` declarations release, so a
- * directory made before a process that lives in it is removed only after
- * that process stops. A release that throws stops none of the others: the
- * hook rethrows once every release has run, as an `AggregateError` when
- * more than one threw. The returned release runs its callback once: every
- * later call, from the hook or from the test, returns what the first call
- * returned. Bun runs the hook after every `afterEach`, so a release works
- * from the paths and handles it captured. Throws outside a test, where
- * nothing would run the hook.
+ * early release, such as a `stop` member. Every release a test registers
+ * runs from one hook, last registered first, so a directory made before a
+ * process that lives in it is removed only after that process stops. A
+ * release that throws stops none of the others: the hook rethrows once
+ * every release has run, as an `AggregateError` when more than one threw.
+ * The returned release runs its callback once: every later call, from the
+ * hook or from the test, returns what the first call returned. Bun runs the
+ * hook after every `afterEach`, so a release works from the paths and
+ * handles it captured. Throws outside a test, where nothing would run the
+ * hook.
  */
 export function registerTestCleanup<T>(release: () => T): () => T {
   let released: { readonly value: T } | null = null;

package/src/test-utils/setup-mcp-home.ts

@@ -15,12 +15,13 @@ import { waitFor } from './wait-for';
  * no extra arguments. A server started with this home as its `HOME` and
  * `XDG_RUNTIME_DIR` boots its daemon here. Each stand-in appends its pid,
  * which is its process group as a session leader, to `stub-pids` in the
- * home. Disposal stops the daemon, when one wrote its pid file here, and
+ * home. `teardown` stops the daemon, when one wrote its pid file here, and
  * waits for it to exit; then it kills the daemon's process group and every
  * group `stub-pids` records, such as a reporter a stopped session left
  * behind, waits until each group is empty, and removes the home. 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.
+ * teardown runs once the current test finishes, so it must run inside a
+ * test; calling `teardown` sooner runs it then, and a second teardown does
+ * nothing.
  */
 export function setupMCPHome() {
   const tmp = setupTempDir('atc-mcp-');
@@ -29,9 +30,9 @@ export function setupMCPHome() {
   // stand-ins stop before the home that records them is removed.
   const stack = new AsyncDisposableStack();
 
-  const dispose = registerTestCleanup(() => stack.disposeAsync());
+  const teardown = registerTestCleanup(() => stack.disposeAsync());
 
-  stack.use(tmp);
+  stack.defer(tmp.teardown);
 
   const home = tmp.dir;
 
@@ -60,7 +61,7 @@ export function setupMCPHome() {
     home,
     claudeBin,
     grokBin,
-    [Symbol.asyncDispose]: dispose,
+    teardown,
   };
 }
 

package/src/test-utils/setup-mcp-http.ts

@@ -21,13 +21,13 @@ interface MCPHTTPSetupOptions {
  * collected. The authorization server's database sits where atc keeps it
  * under `home`, so a CLI run with that home opens the same file. `store` is
  * the authorization server's database opened a second time the way
- * `atc clients` and `atc grants` open it, and `addClient` adds a client
+ * `atc clients` and `atc grants` open it, and `createClient` adds a client
  * through it and returns the client id. `restartDaemon` stops the daemon and
  * starts a fresh one on the same socket and database, the way an operator
  * restarts it, with the principals it is given; `countDaemonClients` reads
  * how many connections the current daemon holds open. Everything it starts
  * stops, and the directory is removed, once the current test finishes, so it
- * must run inside a test; disposal does so sooner, and a second disposal
+ * must run inside a test; `teardown` does so sooner, and a second teardown
  * does nothing.
  */
 export async function setupMCPHTTP(options: MCPHTTPSetupOptions = {}) {
@@ -37,9 +37,9 @@ export async function setupMCPHTTP(options: MCPHTTPSetupOptions = {}) {
   // before the one it depends on, and the directory goes last.
   const stack = new AsyncDisposableStack();
 
-  const dispose = registerTestCleanup(() => stack.disposeAsync());
+  const teardown = registerTestCleanup(() => stack.disposeAsync());
 
-  stack.use(tmp);
+  stack.defer(tmp.teardown);
 
   const socketPath = join(tmp.dir, 'daemon.sock');
   const stateDir = join(tmp.dir, '.local', 'state', 'atc');
@@ -102,7 +102,7 @@ export async function setupMCPHTTP(options: MCPHTTPSetupOptions = {}) {
     requests,
     caller,
     store,
-    async addClient(name: string, redirectURIs: readonly string[]): Promise<string> {
+    async createClient(name: string, redirectURIs: readonly string[]): Promise<string> {
       const created = await store.auth.api.createFixedClient({
         body: { name, redirectURIs: [...redirectURIs] },
       });
@@ -117,6 +117,6 @@ export async function setupMCPHTTP(options: MCPHTTPSetupOptions = {}) {
 
       daemon = await startTestDaemon(principals);
     },
-    [Symbol.asyncDispose]: dispose,
+    teardown,
   };
 }

package/src/test-utils/setup-temp-dir.ts

@@ -5,30 +5,24 @@ import { registerTestCleanup } from './register-test-cleanup';
 
 interface TempDir {
   readonly dir: string;
-  readonly [Symbol.dispose]: () => void;
-  readonly [Symbol.asyncDispose]: () => Promise<void>;
+  readonly teardown: () => void;
 }
 
 /**
  * Creates a directory under the system temp root, named by the prefix, and
  * registers its removal to run once the current test finishes, so it must
- * run inside a test. Disposal removes the tree sooner; whichever comes
+ * run inside a test. `teardown` removes the tree sooner; whichever comes
  * second does nothing.
  */
 export function setupTempDir(prefix: string): TempDir {
   const dir = mkdtempSync(join(tmpdir(), prefix));
 
-  const remove = registerTestCleanup(() => {
+  const teardown = registerTestCleanup(() => {
     rmSync(dir, { recursive: true, force: true });
   });
 
   return {
     dir,
-    [Symbol.dispose]: remove,
-    [Symbol.asyncDispose]: () => {
-      remove();
-
-      return Promise.resolve();
-    },
+    teardown,
   };
 }

package/src/test-utils/start-cut-proxy.ts

@@ -25,7 +25,6 @@ export interface CutProxy {
   // How many answers the proxy has swallowed in hold mode.
   readonly countHeld: () => number;
   readonly stop: () => void;
-  readonly [Symbol.dispose]: () => void;
 }
 
 // One proxied connection: the target side once it is connected, what the
@@ -49,8 +48,8 @@ interface ProxyLink {
  * the method it loses the target's next answer after the request reached
  * the target: the request runs, and the client never sees its response.
  * It stops, ending every link, once the current test finishes, so it must
- * run inside a test; `stop` or disposal stops it sooner, and a second stop
- * does nothing.
+ * run inside a test; `stop` stops it sooner, and a second stop does
+ * nothing.
  */
 export function startCutProxy(options: CutProxyOptions): CutProxy {
   let cutsLeft = options.cuts;
@@ -139,7 +138,6 @@ export function startCutProxy(options: CutProxyOptions): CutProxy {
     countRequests: () => requests,
     countHeld: () => held,
     stop,
-    [Symbol.dispose]: stop,
   };
 }
 

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,
   };
 }