@zgeoff/atc 3.4.1 → 3.5.0

package/src/test-utils/build-stub-terminal.ts

@@ -1,7 +1,7 @@
 /**
  * A terminal that keeps every chunk written to it, in order, and draws
- * nothing. `getText` returns everything written. `mark` returns a position
- * at the end of what is written so far, and `getTextSince` returns only
+ * nothing. `getText` returns everything written. `countChunks` returns how
+ * many chunks are written so far, and `getTextSince` returns only
  * what was written after that position, so a test reads only the output of
  * the action it checks.
  */
@@ -13,7 +13,7 @@ export function buildStubTerminal() {
       chunks.push(chunk);
     },
     getText: (): string => chunks.join(''),
-    mark: (): number => chunks.length,
+    countChunks: (): number => chunks.length,
     getTextSince: (mark: number): string => chunks.slice(mark).join(''),
   };
 }

package/src/test-utils/create-git-fixture.ts

@@ -23,7 +23,7 @@ interface GitFixtureConfig {
  * The first call in a process builds a template pair under the test home,
  * and each call copies it, so a fixture costs a copy instead of a run of
  * git commands. The directory is removed once the current test finishes,
- * so it must run inside a test; disposal removes it sooner, and a second
+ * so it must run inside a test; `remove` removes it sooner, and a second
  * removal does nothing.
  */
 export async function createGitFixture(config: GitFixtureConfig = {}) {
@@ -56,7 +56,7 @@ export async function createGitFixture(config: GitFixtureConfig = {}) {
     upstream,
     work,
     sha: template.sha,
-    [Symbol.asyncDispose]: tmp[Symbol.asyncDispose],
+    remove: tmp.teardown,
   };
 }
 

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

@@ -29,7 +29,8 @@ interface StubClaudeConfig {
  * first stub to find it removes it; `fake-claude-tap` runs `atc tap` into
  * `$HOME/tap.jsonl`; `fake-claude-events.jsonl` holds more hook payloads to
  * report, one per line, after the `Notification`; `fake-claude-exit` exits
- * once they are reported.
+ * once they are reported; `fake-claude-composer-last` runs the composer once
+ * they are reported.
  */
 export function createStubClaude(dir: string, config: StubClaudeConfig): string {
   const atc = config.atc.map((part) => `"${part}"`).join(' ');
@@ -69,6 +70,7 @@ if [ -f "$HOME/fake-claude-events.jsonl" ]; then
   done < "$HOME/fake-claude-events.jsonl"
 fi
 if [ -f "$HOME/fake-claude-exit" ]; then exit 0; fi
+if [ -f "$HOME/fake-claude-composer-last" ]; then exec "${process.execPath}" "${config.composer}"; fi
 while read -r line; do echo "GOT:$line"; done
 `,
   );

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;
 }
 
 /**
@@ -121,6 +119,9 @@ class StubImpPort implements ImpPort {
   // Feature reads still to fail as an unreachable impd before they answer.
   private featureFailures = 0;
 
+  // Feature reads that failed as an unreachable impd.
+  private failedFeatureReads = 0;
+
   // Session connections whose opening still throws before it returns, as
   // an invalid authorization header makes the socket's constructor throw.
   private openFailures = 0;
@@ -198,6 +199,7 @@ class StubImpPort implements ImpPort {
 
     if (this.featureFailures > 0) {
       this.featureFailures -= 1;
+      this.failedFeatureReads += 1;
 
       return Promise.reject(new ImpPortError('UNREACHABLE', 'impd did not answer'));
     }
@@ -471,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 };
 
@@ -500,7 +502,7 @@ class StubImpPort implements ImpPort {
       sent: 0,
       finished: false,
       process: null,
-      finish: (result) => {
+      stop: (result) => {
         if (connection.finished) {
           return;
         }
@@ -519,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;
       }
@@ -544,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();
@@ -571,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 });
       },
     };
   }
@@ -848,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 });
   }
 
   /**
@@ -1063,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.
@@ -1109,6 +1111,11 @@ class StubImpPort implements ImpPort {
     this.featureFailures = count;
   }
 
+  // How many feature reads failed as an unreachable impd.
+  countFailedFeatureReads(): number {
+    return this.failedFeatureReads;
+  }
+
   /**
    * Refuses the next session request with an impd code and its data, or the
    * message of the refusal when it carries one instead.
@@ -1163,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()) {
@@ -1178,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.
@@ -1269,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');
@@ -1302,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,
@@ -1316,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})`,
@@ -1329,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}`,
@@ -1340,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}`,
@@ -1360,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}`,
@@ -1373,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}`,
@@ -1505,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 });
       }
     });
 
@@ -1534,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',
@@ -1557,7 +1567,7 @@ class StubImpPort implements ImpPort {
       prelude = PRELUDE;
     }
 
-    proc.connection?.finish({
+    proc.connection?.stop({
       kind: 'detached',
       reason: 'taken_over',
       offset: proc.connection.sent,
@@ -1610,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;
     }
@@ -1641,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 {
@@ -1694,7 +1703,7 @@ interface StubConnection {
   sent: number;
   finished: boolean;
   process: StubProcess | null;
-  readonly finish: (outcome: ImpSessionOutcome) => void;
+  readonly stop: (outcome: ImpSessionOutcome) => void;
 }
 
 interface StubRelay {
@@ -1734,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),
     });
@@ -1743,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/{run-legacy-daemon.ts → run-stub-legacy-daemon.ts}

@@ -20,7 +20,7 @@ function main() {
   const stateDir = process.argv.at(3);
 
   if (socketPath === undefined || stateDir === undefined) {
-    throw new Error('usage: run-legacy-daemon.ts <socket path> <state dir>');
+    throw new Error('usage: run-stub-legacy-daemon.ts <socket path> <state dir>');
   }
 
   startStubLegacyDaemon(socketPath, { protocol: PROTOCOL_V + 1, owner: 'caller' });

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