@zgeoff/atc 3.4.0 → 3.4.2

package/src/test-utils/create-stub-shared-server-codex.ts

@@ -0,0 +1,56 @@
+import { join } from 'node:path';
+import { createStubBin } from './create-stub-bin';
+
+interface StubSharedServerCodexConfig {
+  // The command atc runs as; the stub reports each hook through its
+  // `hook-report --agent codex`, as the hook entries atc prints for Codex do.
+  readonly atc: readonly string[];
+
+  // The composer script the stub finishes in.
+  readonly composer: string;
+}
+
+/**
+ * Creates a stand-in for a Codex CLI that shares one background server
+ * between its terminals, as `fake-codex` under the directory, and returns
+ * its path. Without `--no-daemon`, the first start records its own
+ * `ATC_SESSION_ID` and `ATC_SOCKET` in `codex-shared-server.env` under the
+ * directory, as the server it starts keeps its environment, and every start
+ * runs its hooks with the recorded pair, as Codex runs hooks inside that
+ * server. With `--no-daemon`, a start runs its hooks with its own pair. The
+ * stub prints its arguments, reports a `SessionStart` for its thread, which
+ * is `fake-thread-<its own ATC_SESSION_ID>` or the id after `resume`, then
+ * a `Stop` whose last message is `done <thread>`, then runs the composer.
+ */
+export function createStubSharedServerCodex(
+  dir: string,
+  config: StubSharedServerCodexConfig,
+): string {
+  const report = `${config.atc.map((part) => `"${part}"`).join(' ')} hook-report --agent codex`;
+  const server = join(dir, 'codex-shared-server.env');
+
+  return createStubBin(
+    dir,
+    'fake-codex',
+    `#!/usr/bin/env bash
+echo "FAKE_CODEX_UP args: $*"
+thread="fake-thread-$ATC_SESSION_ID"
+source=startup
+prev=''
+for arg in "$@"; do
+  if [ "$prev" = resume ]; then thread="$arg"; source=resume; fi
+  prev="$arg"
+done
+case " $* " in
+  *' --no-daemon '*) ;;
+  *)
+    (set -o noclobber; printf 'ATC_SESSION_ID=%q\\nATC_SOCKET=%q\\n' "$ATC_SESSION_ID" "$ATC_SOCKET" > '${server}') 2>/dev/null
+    . '${server}'
+    ;;
+esac
+printf '{"hook_event_name":"SessionStart","session_id":"%s","source":"%s"}' "$thread" "$source" | ${report}
+printf '{"hook_event_name":"Stop","session_id":"%s","last_assistant_message":"done %s"}' "$thread" "$thread" | ${report}
+exec "${process.execPath}" "${config.composer}"
+`,
+  );
+}

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

@@ -1,6 +1,7 @@
 import { chmodSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
+import { registerTestCleanup } from './register-test-cleanup';
 
 interface StubSystemd {
   // The directory that holds the stand-in `systemctl` and `systemd-run`, to put
@@ -34,10 +35,17 @@ interface StubSystemd {
  * `atcCommand daemon` in the background. `systemd-run` runs the command after
  * `--` 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.
+ * 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
+ * sooner, and a second removal does nothing.
  */
 export function createStubSystemd(atcCommand: readonly string[]): StubSystemd {
   const root = mkdtempSync(join(tmpdir(), 'atc-stub-systemd-'));
+
+  const remove = registerTestCleanup(() => {
+    rmSync(root, { recursive: true, force: true });
+  });
+
   const binDir = join(root, 'bin');
   const procRoot = join(root, 'proc');
   const atcLine = atcCommand.map((part) => `"${part}"`).join(' ');
@@ -118,8 +126,6 @@ exit 0
         `0::/user.slice/user-${process.getuid?.() ?? 0}.slice/user@${process.getuid?.() ?? 0}.service/app.slice/${unit}\n`,
       );
     },
-    [Symbol.dispose]: () => {
-      rmSync(root, { recursive: true, force: true });
-    },
+    [Symbol.dispose]: remove,
   };
 }

package/src/test-utils/get-only-imp-name.ts

@@ -1,4 +1,4 @@
-import type { buildStubImpPort } from './build-stub-imp-port';
+import type { createStubImpPort } from './create-stub-imp-port';
 
 /**
  * Returns the name of the one imp a stub imp port holds, and throws when
@@ -6,7 +6,7 @@ import type { buildStubImpPort } from './build-stub-imp-port';
  * reads another's.
  */
 export function getOnlyImpName(
-  port: Readonly<Pick<ReturnType<typeof buildStubImpPort>, 'collectImpNames'>>,
+  port: Readonly<Pick<ReturnType<typeof createStubImpPort>, 'collectImpNames'>>,
 ): string {
   const names = port.collectImpNames();
   const [name] = names;

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

@@ -0,0 +1,63 @@
+import { onTestFinished } from 'bun:test';
+
+// The releases the current test registered, in registration order; null
+// before its first registration and once its hook has started.
+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.
+ */
+export function registerTestCleanup<T>(release: () => T): () => T {
+  let released: { readonly value: T } | null = null;
+
+  const releaseOnce = (): T => {
+    released ??= { value: release() };
+
+    return released.value;
+  };
+
+  if (pending === null) {
+    onTestFinished(releasePending);
+
+    pending = [];
+  }
+
+  pending.push(releaseOnce);
+
+  return releaseOnce;
+}
+
+async function releasePending(): Promise<void> {
+  const releases = pending ?? [];
+
+  pending = null;
+
+  const errors: unknown[] = [];
+
+  for (const release of releases.toReversed()) {
+    try {
+      await release();
+    } catch (error) {
+      errors.push(error);
+    }
+  }
+
+  if (errors.length === 1) {
+    throw errors[0];
+  }
+
+  if (errors.length > 1) {
+    throw new AggregateError(errors, 'more than one test cleanup failed');
+  }
+}

package/src/test-utils/run-mcp-authorization.ts

@@ -18,6 +18,9 @@ interface MCPAuthorizationRequest {
 }
 
 interface MCPAuthorization {
+  // The consent page the approval code sent the browser to.
+  readonly consent: URL;
+
   // Where the consent page sent the browser back to.
   readonly callback: URL;
   readonly code: string;
@@ -29,9 +32,9 @@ interface MCPAuthorization {
  * browser and the operator do: opens the authorization request with PKCE,
  * types the approval code the server printed into the login page, and ticks
  * the given scopes on the consent page. Each request starts with no cookies,
- * as a fresh browser would. Returns where the browser landed and what a token
- * request needs, and throws when any step's response lacks the value the next
- * step depends on.
+ * as a fresh browser would. Returns the consent page it passed, where the
+ * browser landed, and what a token request needs, and throws when any step's
+ * response lacks the value the next step depends on.
  */
 export async function runMCPAuthorization(
   server: MCPAuthorizationServer,
@@ -114,5 +117,5 @@ export async function runMCPAuthorization(
     throw new Error(`the consent redirect holds no authorization code: ${location}`);
   }
 
-  return { callback, code, verifier };
+  return { consent, callback, code, verifier };
 }

package/src/test-utils/{run-legacy-daemon.ts → run-stub-legacy-daemon.ts}

@@ -20,10 +20,10 @@ 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 });
+  startStubLegacyDaemon(socketPath, { protocol: PROTOCOL_V + 1, owner: 'caller' });
 
   const session = Bun.spawn(['sleep', '60']);
 

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

@@ -5,6 +5,7 @@ import { stopDaemonProcess } from '../stop-daemon-process';
 import { buildStubMCPClaude } from './build-stub-mcp-claude';
 import { buildStubMCPGrok } from './build-stub-mcp-grok';
 import { createStubBin } from './create-stub-bin';
+import { registerTestCleanup } from './register-test-cleanup';
 import { setupTempDir } from './setup-temp-dir';
 import { waitFor } from './wait-for';
 
@@ -17,13 +18,33 @@ import { waitFor } from './wait-for';
  * home. Disposal 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. Hold the
- * result with `await using`.
+ * 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.
  */
 export function setupMCPHome() {
   const tmp = setupTempDir('atc-mcp-');
+
+  // Registered after the home, so it releases first: the daemon and the
+  // stand-ins stop before the home that records them is removed.
+  const stack = new AsyncDisposableStack();
+
+  const dispose = registerTestCleanup(() => stack.disposeAsync());
+
+  stack.use(tmp);
+
   const home = tmp.dir;
 
+  stack.defer(async () => {
+    const pid = findPidFilePID(join(home, 'atc-daemon.pid'));
+
+    if (pid !== null) {
+      await stopDaemonProcess(pid);
+    }
+
+    await killProcessGroups([...(pid === null ? [] : [pid]), ...readStubPIDs(home)]);
+  });
+
   mkdirSync(join(home, '.config', 'atc'), { recursive: true });
   mkdirSync(join(home, '.local', 'state', 'atc'), { recursive: true });
 
@@ -39,17 +60,7 @@ export function setupMCPHome() {
     home,
     claudeBin,
     grokBin,
-    async [Symbol.asyncDispose]() {
-      const pid = findPidFilePID(join(home, 'atc-daemon.pid'));
-
-      if (pid !== null) {
-        await stopDaemonProcess(pid);
-      }
-
-      await killProcessGroups([...(pid === null ? [] : [pid]), ...readStubPIDs(home)]);
-
-      tmp[Symbol.dispose]();
-    },
+    [Symbol.asyncDispose]: dispose,
   };
 }
 

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

@@ -7,6 +7,7 @@ import { openMCPAuth } from '../mcp/open-mcp-auth';
 import { ReconnectingCaller } from '../mcp/reconnecting-caller';
 import { startMCPHTTPServer } from '../mcp/start-mcp-http-server';
 import { buildMockAgentAdapter } from './build-mock-agent-adapter';
+import { registerTestCleanup } from './register-test-cleanup';
 import { setupTempDir } from './setup-temp-dir';
 
 interface MCPHTTPSetupOptions {
@@ -24,13 +25,22 @@ interface MCPHTTPSetupOptions {
  * 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. Hold the result with
- * `await using`.
+ * 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
+ * does nothing.
  */
 export async function setupMCPHTTP(options: MCPHTTPSetupOptions = {}) {
-  await using stack = new AsyncDisposableStack();
+  const tmp = setupTempDir('atc-mcp-http-');
+
+  // Registered after the directory, so it releases first: each part stops
+  // before the one it depends on, and the directory goes last.
+  const stack = new AsyncDisposableStack();
+
+  const dispose = registerTestCleanup(() => stack.disposeAsync());
+
+  stack.use(tmp);
 
-  const tmp = stack.use(setupTempDir('atc-mcp-http-'));
   const socketPath = join(tmp.dir, 'daemon.sock');
   const stateDir = join(tmp.dir, '.local', 'state', 'atc');
 
@@ -83,8 +93,6 @@ export async function setupMCPHTTP(options: MCPHTTPSetupOptions = {}) {
 
   stack.defer(() => store.close());
 
-  const owned = stack.move();
-
   return {
     home: tmp.dir,
     url: server.url,
@@ -109,6 +117,6 @@ export async function setupMCPHTTP(options: MCPHTTPSetupOptions = {}) {
 
       daemon = await startTestDaemon(principals);
     },
-    [Symbol.asyncDispose]: () => owned.disposeAsync(),
+    [Symbol.asyncDispose]: dispose,
   };
 }

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

@@ -1,6 +1,7 @@
 import { mkdtempSync, rmSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
+import { registerTestCleanup } from './register-test-cleanup';
 
 interface TempDir {
   readonly dir: string;
@@ -9,17 +10,17 @@ interface TempDir {
 }
 
 /**
- * Creates a disposable directory under the system temp root, named by the
- * prefix. Disposal removes the tree; hold the result with `using` in a
- * synchronous test and `await using` in an asynchronous one, so the
- * directory outlives exactly the test that made it.
+ * 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
+ * second does nothing.
  */
 export function setupTempDir(prefix: string): TempDir {
   const dir = mkdtempSync(join(tmpdir(), prefix));
 
-  const remove = () => {
+  const remove = registerTestCleanup(() => {
     rmSync(dir, { recursive: true, force: true });
-  };
+  });
 
   return {
     dir,

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

@@ -1,4 +1,5 @@
 import type { Socket } from 'bun';
+import { registerTestCleanup } from './register-test-cleanup';
 
 interface CutProxyOptions {
   // The address the proxy forwards to.
@@ -47,6 +48,9 @@ interface ProxyLink {
  * connection byte for byte, except that for the first `cuts` requests of
  * 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.
  */
 export function startCutProxy(options: CutProxyOptions): CutProxy {
   let cutsLeft = options.cuts;
@@ -121,14 +125,14 @@ export function startCutProxy(options: CutProxyOptions): CutProxy {
     },
   });
 
-  const stop = () => {
+  const stop = registerTestCleanup(() => {
     for (const client of links) {
       client.end();
       client.data.upstream?.end();
     }
 
     server.stop(true);
-  };
+  });
 
   return {
     port: server.port,

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

@@ -3,6 +3,7 @@ import { join } from 'node:path';
 import type { Subprocess } from 'bun';
 import { DaemonClient } from '../client/daemon-client';
 import { findDaemonRecord } from '../shared/find-daemon-record';
+import { registerTestCleanup } from './register-test-cleanup';
 import { waitFor } from './wait-for';
 
 interface DaemonProcessConfig {
@@ -41,7 +42,9 @@ interface DaemonBoot {
  * same config. `readStderr` reads what the current boot printed. Disposal
  * 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; a second disposal does nothing.
+ * 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.
  */
 export function startDaemonProcess(config: Readonly<DaemonProcessConfig>) {
   const socketPath = join(config.home, 'atc-daemon.sock');
@@ -76,6 +79,26 @@ export function startDaemonProcess(config: Readonly<DaemonProcessConfig>) {
 
   let current = boot();
 
+  const dispose = registerTestCleanup(async () => {
+    disposed = true;
+
+    for (const client of clients) {
+      client.stop();
+    }
+
+    current.proc.kill('SIGKILL');
+
+    await current.proc.exited;
+
+    const recorded = findDaemonRecord(join(stateDir, 'daemon.json'));
+
+    if (recorded !== null && recorded.pid !== current.proc.pid) {
+      try {
+        process.kill(recorded.pid, 'SIGKILL');
+      } catch {}
+    }
+  });
+
   const readStderr = () => {
     try {
       return readFileSync(current.stderrPath, 'utf8');
@@ -165,28 +188,6 @@ export function startDaemonProcess(config: Readonly<DaemonProcessConfig>) {
 
       current = boot();
     },
-    async [Symbol.asyncDispose](): Promise<void> {
-      if (disposed) {
-        return;
-      }
-
-      disposed = true;
-
-      for (const client of clients) {
-        client.stop();
-      }
-
-      current.proc.kill('SIGKILL');
-
-      await current.proc.exited;
-
-      const recorded = findDaemonRecord(join(stateDir, 'daemon.json'));
-
-      if (recorded !== null && recorded.pid !== current.proc.pid) {
-        try {
-          process.kill(recorded.pid, 'SIGKILL');
-        } catch {}
-      }
-    },
+    [Symbol.asyncDispose]: dispose,
   };
 }

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

@@ -1,3 +1,5 @@
+import { registerTestCleanup } from './register-test-cleanup';
+
 interface GitHTTPServer {
   // The base URL a repository under the root is served at, ending in `/`.
   readonly url: string;
@@ -27,7 +29,9 @@ interface GitHTTPServerOptions {
  * authenticated request waits that long before it is served, which makes a
  * 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. Stop it with `stop`, or hold it with `await using`.
+ * 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.
  */
 export function startGitHTTPServer(
   root: string,
@@ -87,11 +91,13 @@ export function startGitHTTPServer(
     },
   });
 
+  const stop = registerTestCleanup(() => server.stop(true));
+
   return {
     url: `http://127.0.0.1:${server.port}/`,
     authorizations,
-    stop: () => server.stop(true),
-    [Symbol.asyncDispose]: () => server.stop(true),
+    stop,
+    [Symbol.asyncDispose]: stop,
   };
 }
 

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

@@ -1,5 +1,6 @@
 import { join } from 'node:path';
 import { isRecord } from '../shared/report';
+import { registerTestCleanup } from './register-test-cleanup';
 
 const CLI_PATH = join(import.meta.dir, '..', 'cli.ts');
 
@@ -37,9 +38,10 @@ interface MCPToolResult {
  * an object. `spawnSession` spawns through `atc_session_spawn` and resolves
  * 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. Disposal stops the server and waits for it to exit,
- * and a second disposal waits for the same exit; the daemon stays up for
- * the home to stop.
+ * 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
+ * stays up for the home to stop.
  */
 export async function startMCPStdio(options: MCPStdioOptions) {
   const proc = Bun.spawn([...(options.command ?? [process.execPath, CLI_PATH, 'mcp'])], {
@@ -56,6 +58,13 @@ export async function startMCPStdio(options: MCPStdioOptions) {
     stderr: 'ignore',
   });
 
+  const stopServer = registerTestCleanup(async (): Promise<void> => {
+    void proc.stdin.end();
+    proc.kill();
+
+    await proc.exited;
+  });
+
   const pending = new Map<number, PromiseWithResolvers<Readonly<Record<string, unknown>>>>();
 
   void readResponses(proc.stdout, pending);
@@ -90,23 +99,6 @@ export async function startMCPStdio(options: MCPStdioOptions) {
     return toToolResult(response);
   };
 
-  let stopped = false;
-
-  const stopServer = async (): Promise<void> => {
-    if (!stopped) {
-      stopped = true;
-      void proc.stdin.end();
-      proc.kill();
-    }
-
-    await proc.exited;
-  };
-
-  // A failed initialize stops the server here, before the caller holds it.
-  await using stack = new AsyncDisposableStack();
-
-  stack.defer(stopServer);
-
   const server = {
     sendRequest,
     sendToolCall,
@@ -124,13 +116,16 @@ export async function startMCPStdio(options: MCPStdioOptions) {
     [Symbol.asyncDispose]: stopServer,
   };
 
+  // A failed initialize stops the server here, before the start rejects.
   await sendRequest('initialize', {
     protocolVersion: '2025-06-18',
     capabilities: {},
     clientInfo: { name: 'atc-test' },
-  });
+  }).catch(async (error: unknown) => {
+    await stopServer();
 
-  stack.move();
+    throw error;
+  });
 
   return server;
 }

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

@@ -0,0 +1,65 @@
+import { createServer } from 'node:net';
+import type { Socket } from 'node:net';
+import { registerTestCleanup } from './register-test-cleanup';
+
+interface StubAnsweringListener {
+  // The server's side of each connection it accepted, in order.
+  readonly peers: readonly Socket[];
+
+  // The first read each connection sent, decoded, in arrival order.
+  readonly lines: readonly string[];
+  readonly [Symbol.asyncDispose]: () => Promise<void>;
+}
+
+/**
+ * A stand-in for a daemon socket that answers a handshake: it listens on
+ * the unix socket path, records each connection it accepts and the first
+ * 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
+ * sooner and resolves once the server has closed, and a second stop does
+ * nothing.
+ */
+export async function startStubAnsweringListener(path: string): Promise<StubAnsweringListener> {
+  const peers: Socket[] = [];
+  const lines: string[] = [];
+
+  const server = createServer((peer) => {
+    peers.push(peer);
+
+    peer.once('data', (data) => {
+      peer.pause();
+      lines.push(data.toString());
+      peer.write('answer\n');
+    });
+  });
+
+  const listening = Promise.withResolvers<void>();
+
+  server.listen(path, () => {
+    listening.resolve();
+  });
+
+  await listening.promise;
+
+  const stop = registerTestCleanup(async () => {
+    for (const peer of peers) {
+      peer.destroy();
+    }
+
+    const closed = Promise.withResolvers<void>();
+
+    server.close(() => {
+      closed.resolve();
+    });
+
+    await closed.promise;
+  });
+
+  return {
+    peers,
+    lines,
+    [Symbol.asyncDispose]: stop,
+  };
+}

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

@@ -0,0 +1,31 @@
+import { registerTestCleanup } from './register-test-cleanup';
+
+interface StubClosingListener {
+  readonly [Symbol.dispose]: () => 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
+ * stops it sooner, and a second stop does nothing.
+ */
+export function startStubClosingListener(path: string): StubClosingListener {
+  const server = Bun.listen({
+    unix: path,
+    socket: {
+      open(socket) {
+        socket.end();
+      },
+      data() {},
+    },
+  });
+
+  const stop = registerTestCleanup(() => {
+    server.stop(true);
+  });
+
+  return {
+    [Symbol.dispose]: stop,
+  };
+}