@lostgradient/weft 0.2.0

package/dist/testing/mocks.d.ts

@@ -0,0 +1,145 @@
+/**
+ * Type-safe activity mocking with call recording for testing.
+ *
+ * Provides an `ActivityMockRegistry` to register mock implementations
+ * of activity functions, inspect call history, and configure per-call
+ * overrides (one-shot return values, one-shot rejections).
+ *
+ * @module testing/mocks
+ */
+/**
+ * A single recorded call on a mock activity.
+ *
+ * @example
+ * ```ts
+ * import { TestEngine, type MockCall } from '@lostgradient/weft/testing';
+ *
+ * const engine = new TestEngine();
+ * async function sendEmail(input: unknown): Promise<string> { return ''; }
+ * const mockHandle = engine.mock(sendEmail, async (input: unknown) => 'sent');
+ * await engine.start('notify', { to: 'user@example.com' });
+ * const call: MockCall<unknown, string> = mockHandle.calls[0]!;
+ * console.log(call.input); // { to: 'user@example.com' }
+ * ```
+ */
+export interface MockCall<TInput, TResult> {
+    readonly input: TInput;
+    readonly result: TResult | undefined;
+    readonly error: Error | undefined;
+    readonly timestamp: number;
+}
+export type MockActivityFunction<TInput, TResult> = [TInput] extends [void] ? (input?: TInput) => TResult | Promise<TResult> : (input: TInput) => TResult | Promise<TResult>;
+/**
+ * Handle returned by {@link ActivityMockRegistry.mock} that lets tests inspect
+ * call history and configure one-shot overrides.
+ *
+ * Call `mockReturnValueOnce` or `mockRejectionOnce` to inject a specific
+ * outcome for the next invocation, then check `calls` to assert what arguments
+ * were passed.  Use `restore()` to remove the mock and revert to the real
+ * implementation.
+ *
+ * @example
+ * ```ts
+ * import { TestEngine, type MockHandle } from '@lostgradient/weft/testing';
+ *
+ * const engine = new TestEngine();
+ * async function sendEmail(input: unknown): Promise<string> { return 'real'; }
+ *
+ * const handle: MockHandle<unknown, string> =
+ *   engine.mock(sendEmail, async (input: unknown) => 'mocked');
+ *
+ * handle.mockReturnValueOnce('override');
+ * console.log(handle.callCount); // 0
+ * await engine.start('notify', { to: 'user@example.com' });
+ * ```
+ */
+export interface MockHandle<TInput, TResult> {
+    readonly calls: ReadonlyArray<MockCall<TInput, TResult>>;
+    readonly callCount: number;
+    readonly lastCall: MockCall<TInput, TResult> | undefined;
+    /** The current base implementation (excludes one-time overrides). */
+    readonly currentImplementation: MockActivityFunction<TInput, TResult>;
+    mockImplementation(implementation: MockActivityFunction<TInput, TResult>): void;
+    mockReturnValueOnce(value: TResult): MockHandle<TInput, TResult>;
+    mockRejectionOnce(error: Error): MockHandle<TInput, TResult>;
+    resetCalls(): void;
+    restore(): void;
+}
+/**
+ * Internal record held by {@link ActivityMockRegistry} for each mocked
+ * activity.
+ *
+ * Contains the current `implementation` function (which records calls and
+ * applies one-time overrides) and the typed `handle` through which tests
+ * inspect and configure the mock.  Most consumers interact with
+ * {@link MockHandle} instead of `MockedActivity` directly.
+ *
+ * @example
+ * ```ts
+ * import { ActivityMockRegistry, type MockedActivity } from '@lostgradient/weft/testing';
+ *
+ * const registry = new ActivityMockRegistry();
+ * async function fetchUser(id: unknown): Promise<string> { return String(id); }
+ *
+ * registry.mock(fetchUser, async (id: unknown) => 'user-mock');
+ * const mocked: MockedActivity | undefined = registry.get(fetchUser);
+ * console.log(typeof mocked?.implementation); // 'function'
+ * ```
+ */
+export interface MockedActivity {
+    implementation: (input?: unknown) => unknown;
+    handle: MockHandle<unknown, unknown>;
+}
+/**
+ * Registry for mocking activity functions in tests.
+ *
+ * Call `mock(activityFn, implementation)` to replace an activity with a test
+ * double and receive a {@link MockHandle} for inspection and configuration.
+ * Use `restoreAll()` in `afterEach` to clear all mocks between test cases.
+ *
+ * @example
+ * ```ts
+ * import { ActivityMockRegistry } from '@lostgradient/weft/testing';
+ *
+ * async function sendEmail(input: unknown): Promise<string> { return 'sent'; }
+ *
+ * const registry = new ActivityMockRegistry();
+ * const handle = registry.mock(sendEmail, async (input: unknown) => 'mock-sent');
+ *
+ * console.log(registry.has(sendEmail)); // true
+ * await (registry.get(sendEmail)!.implementation)({ to: 'a@b.com' });
+ * console.log(handle.callCount); // 1
+ * registry.restoreAll();
+ * ```
+ */
+export declare class ActivityMockRegistry {
+    #private;
+    constructor();
+    /**
+     * Register a cleanup callback to run when `restore(activity)` or
+     * `restoreAll()` removes the mock for `activity`. Used by {@link TestEngine}
+     * to undo the surrogate activity registration it installs on the engine, so
+     * `restoreAll()` does not leave stale registrations behind. The callback runs
+     * at most once per registration and is then discarded.
+     *
+     * If a cleanup hook is already registered for `activity` (for example, when
+     * the same activity is mocked twice without an intervening `restore()`), the
+     * existing hook is kept and the new one is ignored. This preserves the
+     * original-registration snapshot captured by the first mock, so re-mocking
+     * never overwrites the restorer with one that points at a surrogate.
+     */
+    onRestore(activity: Function, cleanup: () => void): void;
+    /** Whether a cleanup hook is currently registered for `activity`. */
+    hasRestoreHook(activity: Function): boolean;
+    mock<TResult>(activity: () => Promise<TResult> | TResult, implementation: () => TResult | Promise<TResult>): MockHandle<void, TResult>;
+    mock<TInput, TResult>(activity: (input: TInput) => Promise<TResult> | TResult, implementation: (input: TInput) => TResult | Promise<TResult>): MockHandle<TInput, TResult>;
+    has(activity: Function): boolean;
+    get(activity: Function): MockedActivity | undefined;
+    restore(activity: Function): void;
+    restoreAll(): void;
+    /**
+     * Iterate all registered mock entries as `[activityFn, MockedActivity]` pairs.
+     * Used internally by `TestEngine.runN` to propagate mocks to per-run engines.
+     */
+    entries(): IterableIterator<[Function, MockedActivity]>;
+}

package/dist/testing/mocks.js

@@ -0,0 +1,136 @@
+class MockHandleImplementation {
+  #calls = [];
+  #baseImplementation;
+  #oneTimeOverrides = [];
+  #onRestore;
+  constructor(baseImplementation, onRestore) {
+    this.#baseImplementation = baseImplementation;
+    this.#onRestore = onRestore;
+  }
+  get calls() {
+    return this.#calls;
+  }
+  get callCount() {
+    return this.#calls.length;
+  }
+  get lastCall() {
+    return this.#calls[this.#calls.length - 1];
+  }
+  get currentImplementation() {
+    return this.#baseImplementation;
+  }
+  mockImplementation(implementation) {
+    this.#baseImplementation = implementation;
+  }
+  mockReturnValueOnce(value) {
+    this.#oneTimeOverrides.push({ type: "return", value });
+    return this;
+  }
+  mockRejectionOnce(error) {
+    this.#oneTimeOverrides.push({ type: "reject", error });
+    return this;
+  }
+  resetCalls() {
+    this.#calls = [];
+  }
+  restore() {
+    this.#onRestore();
+  }
+  async execute(input) {
+    const override = this.#oneTimeOverrides.shift(), recordedInput = input;
+    if (override?.type === "reject") {
+      const call = {
+        input: recordedInput,
+        result: void 0,
+        error: override.error,
+        timestamp: Date.now()
+      };
+      this.#calls.push(call);
+      throw override.error;
+    }
+    if (override?.type === "return") {
+      const call = {
+        input: recordedInput,
+        result: override.value,
+        error: void 0,
+        timestamp: Date.now()
+      };
+      this.#calls.push(call);
+      return override.value;
+    }
+    try {
+      const result = await this.#baseImplementation(recordedInput), call = {
+        input: recordedInput,
+        result,
+        error: void 0,
+        timestamp: Date.now()
+      };
+      this.#calls.push(call);
+      return result;
+    } catch (thrown) {
+      const error = thrown instanceof Error ? thrown : Error(String(thrown)), call = {
+        input: recordedInput,
+        result: void 0,
+        error,
+        timestamp: Date.now()
+      };
+      this.#calls.push(call);
+      throw error;
+    }
+  }
+}
+
+export class ActivityMockRegistry {
+  #mocks;
+  #cleanupHooks;
+  constructor() {
+    this.#mocks = new Map;
+    this.#cleanupHooks = new Map;
+  }
+  onRestore(activity, cleanup) {
+    if (this.#cleanupHooks.has(activity))
+      return;
+    this.#cleanupHooks.set(activity, cleanup);
+  }
+  hasRestoreHook(activity) {
+    return this.#cleanupHooks.has(activity);
+  }
+  #runCleanupHook(activity) {
+    const cleanup = this.#cleanupHooks.get(activity);
+    if (!cleanup)
+      return;
+    this.#cleanupHooks.delete(activity);
+    cleanup();
+  }
+  #runAllCleanupHooks() {
+    const cleanups = Array.from(this.#cleanupHooks.values());
+    this.#cleanupHooks.clear();
+    for (const cleanup of cleanups)
+      cleanup();
+  }
+  mock(activity, implementation) {
+    const handle = new MockHandleImplementation(implementation, this.restore.bind(this, activity)), mocked = {
+      implementation: handle.execute.bind(handle),
+      handle
+    };
+    this.#mocks.set(activity, mocked);
+    return handle;
+  }
+  has(activity) {
+    return this.#mocks.has(activity);
+  }
+  get(activity) {
+    return this.#mocks.get(activity);
+  }
+  restore(activity) {
+    this.#mocks.delete(activity);
+    this.#runCleanupHook(activity);
+  }
+  restoreAll() {
+    this.#mocks.clear();
+    this.#runAllCleanupHooks();
+  }
+  entries() {
+    return this.#mocks.entries();
+  }
+}

package/dist/testing/subprocess-engine.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Signals supported by the subprocess durability harness.
+ *
+ * @example
+ * ```ts
+ * import type { SubprocessSignal } from '@lostgradient/weft/testing';
+ * const signal: SubprocessSignal = 'SIGKILL';
+ * ```
+ */
+export type SubprocessSignal = 'SIGINT' | 'SIGKILL' | 'SIGTERM';
+/**
+ * Configuration for starting a Weft server in a child Bun process.
+ *
+ * @example
+ * ```ts
+ * import type { SubprocessServerOptions } from '@lostgradient/weft/testing';
+ * const options: SubprocessServerOptions = { entrypoint: './tmp/entrypoint.ts', databasePath: './tmp/weft.db' };
+ * ```
+ */
+export interface SubprocessServerOptions {
+    entrypoint: string;
+    databasePath: string;
+    port?: number;
+    hostname?: string;
+    cwd?: string;
+    env?: Record<string, string | undefined>;
+    args?: readonly string[];
+    readyPattern?: RegExp;
+    startupTimeoutMs?: number;
+    exitTimeoutMs?: number;
+}
+declare const subprocessServerHandleBrand: unique symbol;
+/** Minimal public view of the child process managed by a {@link SubprocessServerHandle}.
+ * @example
+ * ```ts
+ * import type { SubprocessServerProcess } from '@lostgradient/weft/testing';
+ * declare const server: { process: SubprocessServerProcess };
+ * const process: SubprocessServerProcess = server.process;
+ * ```
+ */
+export interface SubprocessServerProcess {
+    readonly exited: Promise<number>;
+    readonly exitCode: number | null;
+    readonly signalCode: SubprocessSignal | null;
+    kill(signal?: SubprocessSignal): void;
+}
+/**
+ * Handle for a running Weft server subprocess started by
+ * {@link spawnServerSubprocess}.
+ *
+ * @example
+ * ```ts
+ * import { spawnServerSubprocess, type SubprocessServerHandle } from '@lostgradient/weft/testing';
+ * const server: SubprocessServerHandle = await spawnServerSubprocess({ entrypoint: './tmp/entrypoint.ts', databasePath: './tmp/weft.db' });
+ * await server.stop();
+ * ```
+ */
+export interface SubprocessServerHandle extends AsyncDisposable {
+    readonly [subprocessServerHandleBrand]: true;
+    readonly process: SubprocessServerProcess;
+    readonly url: string;
+    readonly port: number;
+    readonly databasePath: string;
+    readonly command: readonly string[];
+    readonly stdout: string;
+    readonly stderr: string;
+    stop(signal?: SubprocessSignal): Promise<void>;
+}
+/**
+ * Starts a Weft server entrypoint in a real Bun subprocess and waits for the
+ * server to print a readiness URL.
+ *
+ * @example
+ * ```ts
+ * import { spawnServerSubprocess } from '@lostgradient/weft/testing';
+ * const server = await spawnServerSubprocess({ entrypoint: './tmp/entrypoint.ts', databasePath: './tmp/weft.db' });
+ * await server.stop();
+ * ```
+ */
+export declare function spawnServerSubprocess(options: SubprocessServerOptions): Promise<SubprocessServerHandle>;
+/** Kills a running server subprocess and starts a replacement.
+ * @example
+ * ```ts
+ * import { killAndReboot, spawnServerSubprocess } from '@lostgradient/weft/testing';
+ * const server = await spawnServerSubprocess({ entrypoint: './tmp/entrypoint.ts', databasePath: './tmp/weft.db' });
+ * const rebooted = await killAndReboot(server);
+ * await rebooted.stop();
+ * ```
+ */
+export declare function killAndReboot(handle: SubprocessServerHandle, signal?: SubprocessSignal): Promise<SubprocessServerHandle>;
+/** Runs a callback with a server subprocess and tears it down afterward.
+ * @example
+ * ```ts
+ * import { withSubprocessServer } from '@lostgradient/weft/testing';
+ * declare const options: Parameters<typeof withSubprocessServer>[0];
+ * await withSubprocessServer(options, async (server) => fetch(`${server.url}/v1/health`));
+ * ```
+ */
+export declare function withSubprocessServer<T>(options: SubprocessServerOptions, callback: (handle: SubprocessServerHandle) => Promise<T>): Promise<T>;
+export {};

package/dist/testing/subprocess-engine.js

@@ -0,0 +1,291 @@
+const DEFAULT_READY_PATTERN = /(?:WEFT_SUBPROCESS_READY|Weft running on)\s+(\S+)/, DEFAULT_STARTUP_TIMEOUT_MS = 5000, DEFAULT_EXIT_TIMEOUT_MS = 2000, MAX_CAPTURED_OUTPUT_LENGTH = 32768, subprocessServerHandleBrand = Symbol("SubprocessServerHandle");
+
+class SubprocessServerHandleImpl {
+  [subprocessServerHandleBrand] = !0;
+  #process;
+  url;
+  port;
+  databasePath;
+  command;
+  #options;
+  #output;
+  constructor(process, url, command, options, output) {
+    this.#process = process;
+    this.url = url;
+    const parsedUrl = new URL(url);
+    if (parsedUrl.port === "")
+      throw Error(`Subprocess readiness URL must include an explicit port: ${url}`);
+    this.port = Number(parsedUrl.port);
+    this.databasePath = options.databasePath;
+    this.command = command;
+    this.#options = { ...options, port: this.port };
+    this.#output = output;
+  }
+  get process() {
+    const process = this.#process;
+    return {
+      exited: process.exited,
+      get exitCode() {
+        return process.exitCode;
+      },
+      get signalCode() {
+        return normalizeSignalCode(process.signalCode);
+      },
+      kill: (signal) => {
+        process.kill(signal);
+      }
+    };
+  }
+  get stdout() {
+    return this.#output.stdout;
+  }
+  get stderr() {
+    return this.#output.stderr;
+  }
+  async stop(signal = "SIGTERM") {
+    await stopProcess(this.#process, signal, this.#options.exitTimeoutMs);
+  }
+  async[Symbol.asyncDispose]() {
+    await this.stop();
+  }
+  get internalProcess() {
+    return this.#process;
+  }
+  get internalRestartOptions() {
+    return this.#options;
+  }
+}
+function normalizeSignalCode(value) {
+  if (value === "SIGINT" || value === "SIGKILL" || value === "SIGTERM")
+    return value;
+  return null;
+}
+function appendCapturedOutput(current, chunk) {
+  const next = current + chunk;
+  if (next.length <= MAX_CAPTURED_OUTPUT_LENGTH)
+    return next;
+  return next.slice(next.length - MAX_CAPTURED_OUTPUT_LENGTH);
+}
+function normalizeOptions(options) {
+  return {
+    entrypoint: options.entrypoint,
+    databasePath: options.databasePath,
+    port: options.port ?? 0,
+    ...options.hostname !== void 0 ? { hostname: options.hostname } : {},
+    ...options.cwd !== void 0 ? { cwd: options.cwd } : {},
+    ...options.env !== void 0 ? { env: options.env } : {},
+    args: options.args ?? [],
+    readyPattern: options.readyPattern ?? DEFAULT_READY_PATTERN,
+    startupTimeoutMs: options.startupTimeoutMs ?? DEFAULT_STARTUP_TIMEOUT_MS,
+    exitTimeoutMs: options.exitTimeoutMs ?? DEFAULT_EXIT_TIMEOUT_MS
+  };
+}
+function buildCommand(options) {
+  const command = [
+    process.execPath,
+    options.entrypoint,
+    "--port",
+    String(options.port),
+    "--database",
+    options.databasePath
+  ];
+  if (options.hostname !== void 0)
+    command.push("--hostname", options.hostname);
+  command.push(...options.args);
+  return command;
+}
+function setEnvironmentIfDefined(environment, key, value) {
+  if (value !== void 0)
+    environment[key] = value;
+}
+function createSubprocessEnvironment(explicitEnvironment) {
+  const environment = {};
+  setEnvironmentIfDefined(environment, "PATH", Bun.env.PATH);
+  setEnvironmentIfDefined(environment, "HOME", Bun.env.HOME);
+  setEnvironmentIfDefined(environment, "TMPDIR", Bun.env.TMPDIR);
+  setEnvironmentIfDefined(environment, "TEMP", Bun.env.TEMP);
+  setEnvironmentIfDefined(environment, "TMP", Bun.env.TMP);
+  setEnvironmentIfDefined(environment, "TZ", Bun.env.TZ);
+  setEnvironmentIfDefined(environment, "NODE_ENV", Bun.env.NODE_ENV);
+  for (const [key, value] of Object.entries(explicitEnvironment ?? {}))
+    if (value !== void 0)
+      environment[key] = value;
+  return environment;
+}
+function normalizeReadyPattern(pattern) {
+  const flags = pattern.flags.replaceAll("g", "").replaceAll("y", "");
+  return new RegExp(pattern.source, flags);
+}
+function findReadyUrl(output, pattern) {
+  pattern.lastIndex = 0;
+  return pattern.exec(output)?.[1];
+}
+function createReadyWatcher(process, output, readyPattern, timeoutMs) {
+  const normalizedReadyPattern = normalizeReadyPattern(readyPattern);
+  return new Promise((resolve, reject) => {
+    let settled = !1;
+    const timeout = setTimeout(() => {
+      if (settled)
+        return;
+      settled = !0;
+      reject(Error(`Timed out after ${timeoutMs}ms waiting for subprocess readiness.
+${formatOutput(output)}`));
+    }, timeoutMs);
+    function settleWithUrl(url) {
+      if (settled)
+        return;
+      settled = !0;
+      clearTimeout(timeout);
+      resolve(url);
+    }
+    function fail(error) {
+      if (settled)
+        return;
+      settled = !0;
+      clearTimeout(timeout);
+      reject(error);
+    }
+    process.exited.then(async (exitCode) => {
+      await Bun.sleep(0);
+      const url = findReadyUrl(output.stdout, normalizedReadyPattern);
+      if (url !== void 0) {
+        settleWithUrl(url);
+        return;
+      }
+      fail(Error(`Subprocess exited with code ${exitCode} before readiness.
+${formatOutput(output)}`));
+      return;
+    });
+    drainStream(process.stdout, (chunk) => {
+      output.stdout = appendCapturedOutput(output.stdout, chunk);
+      const url = findReadyUrl(output.stdout, normalizedReadyPattern);
+      if (url !== void 0)
+        settleWithUrl(url);
+    }).catch((error) => {
+      fail(error instanceof Error ? error : Error(String(error)));
+    });
+    drainStream(process.stderr, (chunk) => {
+      output.stderr = appendCapturedOutput(output.stderr, chunk);
+    }).catch((error) => {
+      fail(error instanceof Error ? error : Error(String(error)));
+    });
+  });
+}
+async function verifyProcessSurvivedReadiness(process, output, timeoutMs) {
+  const stabilizationMs = Math.min(50, Math.max(1, timeoutMs)), exitCode = await Promise.race([
+    process.exited,
+    Bun.sleep(stabilizationMs).then(() => {
+      return;
+    })
+  ]);
+  if (exitCode !== void 0)
+    throw Error(`Subprocess exited with code ${exitCode} after readiness.
+${formatOutput(output)}`);
+}
+async function drainStream(stream, onChunk) {
+  if (stream === null)
+    return;
+  const reader = stream.getReader(), decoder = new TextDecoder;
+  try {
+    while (!0) {
+      const { done, value } = await reader.read();
+      if (done)
+        return;
+      onChunk(decoder.decode(value, { stream: !0 }));
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+function formatOutput(output) {
+  return [`stdout:
+${output.stdout || "<empty>"}`, `stderr:
+${output.stderr || "<empty>"}`].join(`
+`);
+}
+async function waitForExit(process, timeoutMs, label) {
+  let timeout;
+  try {
+    return await Promise.race([
+      process.exited,
+      new Promise((_resolve, reject) => {
+        timeout = setTimeout(() => reject(Error(`Timed out waiting for ${label}`)), timeoutMs);
+      })
+    ]);
+  } finally {
+    if (timeout !== void 0)
+      clearTimeout(timeout);
+  }
+}
+function hasProcessTerminated(process) {
+  return process.exitCode !== null || process.signalCode !== null;
+}
+async function stopProcess(process, signal, timeoutMs) {
+  if (hasProcessTerminated(process))
+    return;
+  process.kill(signal);
+  try {
+    await waitForExit(process, timeoutMs, "subprocess exit");
+  } catch {
+    if (!hasProcessTerminated(process)) {
+      process.kill("SIGKILL");
+      await process.exited.catch(() => {
+        return;
+      });
+    }
+  }
+}
+function expectedExitCodeForSignal(signal) {
+  if (signal === "SIGKILL")
+    return 137;
+  if (signal === "SIGTERM")
+    return 143;
+  return 130;
+}
+function isExpectedSignalExit(process, signal, exitCode) {
+  const signalCode = normalizeSignalCode(process.signalCode);
+  if (signalCode !== null)
+    return signalCode === signal;
+  return exitCode === expectedExitCodeForSignal(signal);
+}
+export async function spawnServerSubprocess(options) {
+  const normalizedOptions = normalizeOptions(options), command = buildCommand(normalizedOptions), output = { stdout: "", stderr: "" }, spawnOptions = {
+    cmd: command,
+    env: createSubprocessEnvironment(normalizedOptions.env),
+    stdout: "pipe",
+    stderr: "pipe"
+  };
+  if (normalizedOptions.cwd !== void 0)
+    spawnOptions.cwd = normalizedOptions.cwd;
+  const process = Bun.spawn(spawnOptions);
+  try {
+    const url = await createReadyWatcher(process, output, normalizedOptions.readyPattern, normalizedOptions.startupTimeoutMs);
+    await verifyProcessSurvivedReadiness(process, output, normalizedOptions.startupTimeoutMs);
+    return new SubprocessServerHandleImpl(process, url, command, normalizedOptions, output);
+  } catch (error) {
+    await stopProcess(process, "SIGKILL", normalizedOptions.exitTimeoutMs);
+    throw error;
+  }
+}
+export async function killAndReboot(handle, signal = "SIGKILL") {
+  if (!(handle instanceof SubprocessServerHandleImpl))
+    throw Error("killAndReboot requires a handle returned by spawnServerSubprocess");
+  const { internalProcess: process, internalRestartOptions: restartOptions } = handle;
+  if (hasProcessTerminated(process))
+    throw Error(`Cannot reboot: subprocess already exited.
+${formatOutput(handle)}`);
+  process.kill(signal);
+  const exitCode = await waitForExit(process, restartOptions.exitTimeoutMs, "kill");
+  if (!isExpectedSignalExit(process, signal, exitCode))
+    throw Error(`Expected subprocess to exit from ${signal}, got code ${exitCode} and signal ${process.signalCode ?? "<none>"}.
+${formatOutput(handle)}`);
+  return spawnServerSubprocess({ ...restartOptions, port: 0 });
+}
+export async function withSubprocessServer(options, callback) {
+  const handle = await spawnServerSubprocess(options);
+  try {
+    return await callback(handle);
+  } finally {
+    await handle.stop();
+  }
+}