@zgeoff/atc 3.4.2 → 3.5.0

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,7 +10,7 @@ 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-stub-source-daemon.ts')], {
@@ -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,
   };
 }

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

@@ -42,31 +42,67 @@ interface TestDaemonConfig {
   // The temp directory's name prefix.
   readonly prefix?: string;
   readonly options?: TestDaemonOptionsBuilder;
+
+  // Whether each boot opens the main client; it does unless this is false.
+  readonly mainClient?: boolean;
+}
+
+/**
+ * A running test daemon and the calls that drive it.
+ */
+interface TestDaemon extends TestDaemonPaths {
+  readonly build: string;
+  readonly logs: string[];
+  readonly events: EventMsg[];
+  readonly daemon: DaemonHandle;
+  readonly client: DaemonClient;
+  readonly openClient: (hello?: Readonly<Record<string, unknown>>) => Promise<DaemonClient>;
+  readonly openTCPClient: () => Promise<DaemonClient>;
+  readonly sendHookLines: (...lines: readonly Readonly<Record<string, unknown>>[]) => Promise<void>;
+  readonly stop: () => Promise<void>;
+  readonly restart: (options?: TestDaemonOptionsBuilder) => Promise<void>;
+  readonly dispose: () => Promise<void>;
+}
+
+/**
+ * The harness a config starts: one that opens no main client has neither
+ * that client nor the events it would collect.
+ */
+type StartedTestDaemon<Config extends TestDaemonConfig> = Config extends {
+  readonly mainClient: false;
 }
+  ? Omit<TestDaemon, 'client' | 'events'>
+  : TestDaemon;
 
 // The build string the daemon and every client the harness opens send in
 // their handshake.
 const BUILD = 'atc/test-build';
 
 /**
- * A real daemon in a fresh temp directory, with a client that has already
- * sent its handshake. The options builder chooses what the daemon wires;
- * the harness sets the paths and the build, and collects the daemon's log
- * lines unless the options set their own log. `events` collects every event
- * the main client receives, across restarts. `openClient` opens another
- * client over the unix socket and sends its handshake with the given
- * params; `openTCPClient` connects to the TCP listener and sends nothing, so
- * the test drives that handshake itself. `sendHookLines` writes reporter
- * lines to the reporter socket and resolves once the daemon has closed the
- * connection. `stop` closes every client and stops the daemon; `restart`
- * does the same, then boots on the same paths and state with the options
- * given or the last ones, and opens a new main client. Disposal stops what
- * is running and removes the directory. 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. A first boot that fails runs it
+ * A real daemon in a fresh temp directory, with a main client that has
+ * already sent its handshake unless the config turns that client off, which
+ * leaves every connection the daemon counts to the test. The options
+ * builder chooses what the daemon wires; the harness sets the paths and the
+ * build, and collects the daemon's log lines unless the options set their
+ * own log. `events` collects every event the main client receives, across
+ * restarts. `openClient` opens another client over the unix socket and
+ * sends its handshake with the given params; `openTCPClient` connects to
+ * the TCP listener and sends nothing, so the test drives that handshake
+ * itself. `sendHookLines` writes reporter lines to the reporter socket and
+ * resolves once the daemon has closed the connection. `stop` closes every
+ * client and stops the daemon; `restart` does the same, then boots on the
+ * same paths and state with the options given or the last ones, and opens
+ * a new main client unless the config turns it off. `dispose` stops what is
+ * running and removes the directory. It runs once the current test
+ * finishes, so the harness must start inside a test; calling it sooner runs
+ * it then, and a second call does nothing. A first boot that fails runs it
  * before the start rejects.
  */
-export async function startTestDaemon(config: TestDaemonConfig = {}) {
+export function startTestDaemon<const Config extends TestDaemonConfig = TestDaemonConfig>(
+  config?: Config,
+): Promise<StartedTestDaemon<Config>>;
+
+export async function startTestDaemon(config: TestDaemonConfig = {}): Promise<TestDaemon> {
   const tmp = setupTempDir(config.prefix ?? 'atc-test-daemon-');
 
   // Registered after the directory, so it releases first: the daemon stops
@@ -75,7 +111,7 @@ export async function startTestDaemon(config: TestDaemonConfig = {}) {
 
   const dispose = registerTestCleanup(() => stack.disposeAsync());
 
-  stack.use(tmp);
+  stack.defer(tmp.teardown);
 
   const paths: TestDaemonPaths = {
     dir: tmp.dir,
@@ -142,6 +178,10 @@ export async function startTestDaemon(config: TestDaemonConfig = {}) {
 
     live = daemon;
 
+    if (config.mainClient === false) {
+      return { daemon, client: null };
+    }
+
     const client = await openClient();
 
     client.onEvent = (event) => {
@@ -168,6 +208,10 @@ export async function startTestDaemon(config: TestDaemonConfig = {}) {
       return current.daemon;
     },
     get client(): DaemonClient {
+      if (current.client === null) {
+        throw new Error('the test daemon started without a main client');
+      }
+
       return current.client;
     },
     openClient,
@@ -224,6 +268,6 @@ export async function startTestDaemon(config: TestDaemonConfig = {}) {
 
       current = await boot();
     },
-    [Symbol.asyncDispose]: dispose,
+    dispose,
   };
 }