@ultimat3/testing 23.0.0 → 25.0.0

package/src/fixture-island.ts

@@ -3,13 +3,14 @@
 // packages are tier 5, so importing it here would be the reverse of the one declared `cli → testing`
 // edge. A structural seam keeps the direction honest and survives the bundler changing underneath.
 
-import { mkdtempSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
 import { basename, join } from 'node:path';
 import { islandMountMissing, islandNotBuilt } from './errors';
+import { onFileBoundary } from './file-boundary';
 import { createIslandDocument, FakeElement, handlerFor, parseHtml } from './island-dom';
+import { installGlobals } from './island-globals';
 import type { ResizeInput } from './island-observers';
 import { deliverResize } from './island-observers';
+import { createScratchDir, removeScratchDir } from './island-scratch';
 
 /** The two fields a mounted island needs from a chunk. Anything else a bundler grows — a CSS
  *  artifact, a source map, a dev/production flag — is invisible here on purpose. */
@@ -139,83 +140,13 @@ function entryOf(module: unknown, file: string): IslandEntry {
   return { mount: mount as IslandEntry['mount'] };
 }
 
-let moduleDir: string | undefined;
-
-/**
- * One directory per process, outside the app under test — so no test leaves a `.mjs` behind. Two
- * properties the module-scope `mkdtempSync` it replaces had neither of:
- *
- * LAZY. This module is on the `.` barrel, so importing `@ultimat3/testing` for `expect` alone
- * created a directory — in every test process in the repo, whether or not it ever mounts anything.
- *
- * REMOVED. `exit` and `rmSync`, because an exit handler runs synchronously and nothing else covers
- * every path: `mountIsland` restores and rethrows on a failed mount, so that run never reaches the
- * `Disposable`, and the directory is per PROCESS while the disposable is per mount.
- */
-function moduleDirPath(): string {
-  const existing = moduleDir;
-  if (existing !== undefined) return existing;
-  const created = mkdtempSync(join(tmpdir(), 'ultimate-island-'));
-  process.on('exit', () => {
-    rmSync(created, { recursive: true, force: true });
-  });
-  moduleDir = created;
-  return created;
-}
-
-/**
- * The scratch root, or `undefined` when nothing has been mounted. Read by the leak test, which
- * asserts both halves of the above from a CHILD process — the only place where "this process
- * created no directory" and "the directory is gone afterwards" are both observable.
- */
-export const islandModuleDir = (): string | undefined => moduleDir;
-
-/**
- * A temp file named by the chunk's own hash, NOT a `data:` URL. The URL form read better and
- * crashed the coverage reporter: `bun test --coverage` panics with `range end index N out of range
- * for slice of length 4096` on `import()` of any `data:` module whose URL exceeds ~4 kB, and an
- * island chunk is 12-55 kB. Measured on Bun 1.4.0, threshold at a URL length of 4032; without
- * `--coverage` the same import is fine, which is why only the per-package CI job ever saw it.
- *
- * The property the URL form was chosen for survives: the name is derived from the bytes, so an
- * edited island is a different module rather than a cache hit on the same path.
- */
-const modulePathFor = (code: string): string =>
-  join(moduleDirPath(), `${Bun.SHA256.hash(code, 'hex').slice(0, 16)}.mjs`);
-
 /**
- * DESCRIPTORS, not values, and all-or-nothing.
- *
- * A saved value cannot tell "no such global" from "a global holding `undefined`", so a teardown
- * reading one deletes both — and `key in globalThis` flips behind whoever owned it. It also cannot
- * put an accessor back as an accessor.
- *
- * The rollback is the half with teeth. This runs BEFORE `mountIsland`'s own `try`, so an
- * assignment that throws — a getter-only own global among the caller's `globals` — would leave the
- * fake `document` already installed ahead of it for the whole rest of the process, which is the
- * exact leak the `catch` below exists to prevent.
+ * A temp FILE named by the chunk's own hash, NOT a `data:` URL: `bun test --coverage` panics on
+ * `import()` of a `data:` module past ~4 kB (Bun 1.4.0) and an island chunk is 12-55 kB. The file
+ * sits in the mount's OWN directory (`island-scratch.ts`), so a mount is a fresh module instance.
  */
-function installGlobals(values: Readonly<Record<string, unknown>>): () => void {
-  const host = globalThis as unknown as Record<string, unknown>;
-  const saved = Object.keys(values).map(
-    (key) => [key, Object.getOwnPropertyDescriptor(host, key)] as const,
-  );
-  const restore = (): void => {
-    for (const [key, descriptor] of saved) {
-      if (descriptor === undefined) delete host[key];
-      else Object.defineProperty(host, key, descriptor);
-    }
-  };
-  try {
-    // Assignment, not `defineProperty`: a global with a setter is meant to see the write, and
-    // `Object.assign` over the lot would report the same failure with nothing rolled back.
-    for (const [key, value] of Object.entries(values)) host[key] = value;
-  } catch (error) {
-    restore();
-    throw error;
-  }
-  return restore;
-}
+const modulePathFor = (dir: string, code: string): string =>
+  join(dir, `${Bun.SHA256.hash(code, 'hex').slice(0, 16)}.mjs`);
 
 /**
  * The island fixture. Everything it installs is process-global, so the result is `Disposable` and
@@ -230,9 +161,12 @@ function installGlobals(values: Readonly<Record<string, unknown>>): () => void {
  * clears (a listener on `document`, an interval whose callback reads it) was made against that one.
  */
 /**
- * Every mount not yet disposed. A worker runs many files in one global (22.7), so a mount a file
- * forgot to `using` is disposed at the file boundary (`file-boundary.ts`) instead of handing its
- * fake `window`/`document` to every later file.
+ * Every mount not yet disposed — from the moment it installs its globals, not from when `mount`
+ * answers. A worker runs many files in one global (22.7), so a mount a file forgot to `using` is
+ * disposed at the file boundary (`file-boundary.ts`) instead of handing its fake
+ * `window`/`document` to every later file. Registered BEFORE the awaits, because a mount that
+ * never settles — a test that timed out inside an island's `mount` — was otherwise nobody's: its
+ * globals stayed installed and its scratch directory stayed in the temp dir, one per timeout.
  */
 const liveMounts = new Set<() => void>();
 
@@ -249,6 +183,10 @@ export function disposeLiveIslands(): number {
   return pending.length;
 }
 
+// Registered here, not by each preload: the repo's own preload and an app's both install the leak
+// guard that runs the boundary, and a mount a file forgot is one only this module can see.
+onFileBoundary(disposeLiveIslands);
+
 export async function mountIsland(options: MountIslandOptions): Promise<MountedIsland> {
   // `only`, because this fixture has always KNOWN which island it wants and asked for all of them
   // anyway — `island-bundle.ts` added the option for exactly this caller ("a test that mounts a
@@ -275,14 +213,35 @@ export async function mountIsland(options: MountIslandOptions): Promise<MountedI
 
   const { documentElement, globals, resizeObservers } = createIslandDocument();
   const restore = installGlobals({ ...globals, ...options.globals });
+  let dir: string | undefined;
+  let unmount: (() => void) | undefined;
+  let disposed = false;
+  const dispose = (): void => {
+    // Once: `using` and an `afterAll` that also disposes by hand are both real, and Solid's own
+    // disposer is idempotent while an island's `clearInterval` wrapper need not be.
+    if (disposed) return;
+    disposed = true;
+    liveMounts.delete(dispose);
+    try {
+      unmount?.();
+    } finally {
+      // Whatever the disposer did — including throw, which is the test's to see — the process
+      // gets its globals back, or the fake `document` reaches every later file in the run.
+      restore();
+      if (dir !== undefined) removeScratchDir(dir);
+    }
+  };
+  liveMounts.add(dispose);
   try {
+    dir = createScratchDir();
+    const scratch = dir;
     // Beside the entry, under the name its bytes import them by: the same relative resolution a
     // browser does under `/islands/`. Named by their content-addressed URL, so a rewrite is the same
     // bytes at the same name.
     for (const shared of bundle.shared ?? []) {
-      await Bun.write(join(moduleDirPath(), basename(shared.url)), shared.code);
+      await Bun.write(join(scratch, basename(shared.url)), shared.code);
     }
-    const path = modulePathFor(chunk.code);
+    const path = modulePathFor(scratch, chunk.code);
     await Bun.write(path, chunk.code);
     const entry = entryOf(await import(path), chunk.file);
     const el = new FakeElement('div');
@@ -296,23 +255,16 @@ export async function mountIsland(options: MountIslandOptions): Promise<MountedI
     // island's `mount` resumed AFTER the `restore()` below had taken the fake `document` back out
     // — so it failed with `document is not defined` inside whichever later test happened to be
     // running, with no thread back here.
-    const unmount = disposerOf(await entry.mount(el, options.props));
-    let disposed = false;
-    const dispose = (): void => {
-      // Once: `using` and an `afterAll` that also disposes by hand are both real, and Solid's own
-      // disposer is idempotent while an island's `clearInterval` wrapper need not be.
-      if (disposed) return;
-      disposed = true;
-      liveMounts.delete(dispose);
+    const stop = disposerOf(await entry.mount(el, options.props));
+    if (disposed) {
+      // The boundary took this mount back while `mount` was still running — its test is long
+      // over. What it started is stopped now, and nobody is left to see a throw from it.
       try {
-        unmount?.();
-      } finally {
-        // Whatever the disposer did — including throw, which is the test's to see — the process
-        // gets its globals back, or the fake `document` reaches every later file in the run.
-        restore();
+        stop?.();
+      } catch {
+        // Its `document` is already gone; the stop was best-effort for that reason.
       }
-    };
-    liveMounts.add(dispose);
+    } else unmount = stop;
     const resolve = (target: string | FakeElement | null | undefined): FakeElement | null =>
       typeof target === 'string' ? el.querySelector(target) : (target ?? null);
     return {
@@ -348,7 +300,7 @@ export async function mountIsland(options: MountIslandOptions): Promise<MountedI
   } catch (error) {
     // A mount that throws restores the process before it rethrows: the alternative leaves every
     // later file in the run holding a fake `document`, which fails somewhere with no thread back.
-    restore();
+    dispose();
     throw error;
   }
 }

package/src/fixture-jobs.ts

@@ -6,7 +6,7 @@
 // Nothing here polls or sleeps: a job becomes due only because `clock.advance()` said so.
 
 import type { Actor, Ctx } from '@ultimat3/core';
-import { assert, createContext } from '@ultimat3/core';
+import { assert, ctxOf } from '@ultimat3/core';
 import type {
   AnyJobHandle,
   EnqueueResult,
@@ -108,9 +108,9 @@ const tallyOf = (executions: readonly JobExecution[]): Record<string, StepTally>
   return steps;
 };
 
-export async function createRunJobs(): Promise<RunJobs> {
+export async function testJobs(): Promise<RunJobs> {
   const jobs = await import('@ultimat3/jobs');
-  const driver: JobDriver = jobs.createMemoryDriver();
+  const driver: JobDriver = jobs.memoryJobDriver();
   // Captured before the overwrite: the ambient driver is process-global, so without this the
   // next file to call `send()` enqueues into this test's dead queue instead of sending inline.
   const previous = jobs.jobDriver();
@@ -119,8 +119,8 @@ export async function createRunJobs(): Promise<RunJobs> {
   // answer one test published resumed the next test's waiting run. A fresh bus per fixture, and
   // the process's own handed back with the driver.
   const previousBus = jobs.eventBus();
-  jobs.setEventBus(jobs.createMemoryEventBus());
-  const anonymousWorker = createContext({ role: 'worker' });
+  jobs.setEventBus(jobs.memoryEventBus());
+  const anonymousWorker = ctxOf({ role: 'worker' });
   const renewals = frozenScheduler();
 
   const introspect = (): NonNullable<JobDriver['introspect']> => {
@@ -164,7 +164,7 @@ export async function createRunJobs(): Promise<RunJobs> {
    * row, no shutdown hook — the frozen clock and the test decide when a pass happens.
    */
   const round = async (ctx: Ctx): Promise<readonly JobExecution[]> => {
-    const worker = jobs.createWorker({
+    const worker = jobs.jobWorker({
       driver,
       workerId: WORKER_ID,
       queues: queues(),
@@ -198,7 +198,7 @@ export async function createRunJobs(): Promise<RunJobs> {
     const ctx =
       options.actor === undefined
         ? anonymousWorker
-        : createContext({ role: 'worker', actor: options.actor });
+        : ctxOf({ role: 'worker', actor: options.actor });
     for (let rounds = 0; rounds < MAX_ROUNDS; rounds += 1) {
       const batch = await round(ctx);
       if (batch.length === 0) return { executions: [...history], steps: tallyOf(history) };
@@ -244,11 +244,15 @@ export async function createRunJobs(): Promise<RunJobs> {
       ).length,
     inFlight: async () => (await live()).filter((record) => record.state === 'running').length,
     [Symbol.asyncDispose]: async (): Promise<void> => {
-      await driver.close?.();
-      renewals[Symbol.dispose]();
-      jobs.setEventBus(previousBus);
-      if (previous === undefined) jobs.resetJobDriver();
-      else jobs.setJobDriver(previous);
+      // A `finally`: a close that throws must still hand every later file its bus and its driver.
+      try {
+        await driver.close?.();
+      } finally {
+        renewals[Symbol.dispose]();
+        jobs.setEventBus(previousBus);
+        if (previous === undefined) jobs.resetJobDriver();
+        else jobs.setJobDriver(previous);
+      }
     },
   });
 }

package/src/fixture-mail.ts

@@ -21,10 +21,10 @@ export interface TestMail extends Disposable {
 
 const idOf = (mail: MailRef): string => (typeof mail === 'string' ? mail : mail.id);
 
-export async function createTestMail(): Promise<TestMail> {
-  const { createMemoryDriver, driverUnavailable, resetMailDriver, setMailDriver, tryMailDriver } =
+export async function testMail(): Promise<TestMail> {
+  const { memoryMailDriver, driverUnavailable, resetMailDriver, setMailDriver, tryMailDriver } =
     await import('@ultimat3/mail');
-  const memory = createMemoryDriver();
+  const memory = memoryMailDriver();
   const failuresLeft = new Map<string, number>();
   // The ambient driver is process-global; the fixture borrows it for one test and hands it back.
   const previous = tryMailDriver();

package/src/fixture-network.ts

@@ -30,7 +30,7 @@ export interface TestNetwork extends Disposable {
  * no subsystem to import on demand. The test bodies rely on it — `network.offline()` is followed
  * on the next line by the mutation that has to observe it.
  */
-export function createTestNetwork(): TestNetwork {
+export function testNetwork(): TestNetwork {
   // A process that unsealed on purpose (ULTIMATE_TEST_ALLOW_NET=1) still gets a working
   // `offline()`, and gets its unsealed fetch back on disposal rather than keeping ours.
   const sealedBefore = isNetworkSealed();

package/src/fixture-statements.ts

@@ -81,7 +81,7 @@ interface ShapeTally {
  * The threshold is `@ultimat3/entity`'s `N_PLUS_ONE_THRESHOLD` and there is no knob: a loop that
  * fails a test and a loop that warns in `x dev` have to be the same loop.
  */
-export async function createTestStatements(): Promise<TestStatements> {
+export async function testStatements(): Promise<TestStatements> {
   // Imported on demand, like every other fixture factory here: a `packages/core` test that never
   // names `statements` must not load the database layer or the entity registry to run.
   const db = await import('@ultimat3/db');

package/src/fixture-subscribe.ts

@@ -13,7 +13,7 @@ import type { LiveReplicator } from '@ultimat3/realtime/server';
 import { startLiveReplicator } from '@ultimat3/realtime/server';
 import type { LiveFeed, LiveFeedPatch, LiveTarget } from './fixture-drivers';
 import type { LiveConnection, LiveNodeHandle } from './live-node';
-import { createLiveNode } from './live-node';
+import { liveNode } from './live-node';
 
 interface Row {
   readonly id: string;
@@ -58,9 +58,9 @@ export interface SubscribeDriver {
  * once would each see the other's writes. `bun test` builds a fixture on first use and disposes it
  * with the test, which is exactly the lifetime this needs.
  */
-export async function createSubscribeDriver(): Promise<SubscribeDriver> {
+export async function subscribeDriver(): Promise<SubscribeDriver> {
   const realtime = await import('@ultimat3/realtime');
-  const node = await createLiveNode();
+  const node = await liveNode();
   const replicator = await startLiveReplicator({ registry: node.registry });
   const connections: LiveConnection[] = [];
   let sid = 0;

package/src/framework-fixtures.ts

@@ -2,13 +2,13 @@
 // `actorFor`, …). Called by the preload, which is why an app never writes
 // `defineFixtures({ clock })` and why two apps cannot disagree about what `clock` means.
 
-import { createTestClock } from './fixture-clock';
+import { testClock } from './fixture-clock';
 import { DRIVER_FIXTURE_NAMES, driverFixtures } from './fixture-drivers';
-import { createRunJobs } from './fixture-jobs';
-import { createTestMail } from './fixture-mail';
-import { createTestNetwork } from './fixture-network';
-import { createTestStatements } from './fixture-statements';
-import { createSubscribeDriver } from './fixture-subscribe';
+import { testJobs } from './fixture-jobs';
+import { testMail } from './fixture-mail';
+import { testNetwork } from './fixture-network';
+import { testStatements } from './fixture-statements';
+import { subscribeDriver } from './fixture-subscribe';
 import { defineFixtures } from './fixtures';
 
 /**
@@ -24,7 +24,7 @@ export const FRAMEWORK_FIXTURE_NAMES = [
   'runJobs',
   'statements',
   // Moved here from `DRIVER_FIXTURE_NAMES` on 2026-08-20: the driver it was waiting for is
-  // `createSubscribeDriver()`, and the framework can build one — a whole `sync` node in this
+  // `subscribeDriver()`, and the framework can build one — a whole `sync` node in this
   // process, over the change source `@ultimat3/entity`'s `setRowObserver` gives it. The four left
   // in that list all need something the framework genuinely cannot bundle: a browser, or a
   // second build.
@@ -48,14 +48,14 @@ export const ALL_FIXTURE_NAMES: readonly string[] = [
 export function registerFrameworkFixtures(): void {
   defineFixtures({
     ...driverFixtures(),
-    clock: createTestClock,
-    mail: createTestMail,
-    network: createTestNetwork,
-    runJobs: createRunJobs,
-    statements: createTestStatements,
+    clock: testClock,
+    mail: testMail,
+    network: testNetwork,
+    runJobs: testJobs,
+    statements: testStatements,
     // After the spread, so it REPLACES the `unavailableFixture('subscribe')` declaration above it —
     // `defineFixtures` merges and the last registration wins, which is the same seam an app's own
     // driver uses.
-    subscribe: async () => (await createSubscribeDriver()).subscribe,
+    subscribe: async () => (await subscribeDriver()).subscribe,
   });
 }

package/src/free-port.ts

@@ -0,0 +1,46 @@
+// One responsibility: a port the e2e app can listen on AND a browser will open. The OS hands out
+// whatever is free in its ephemeral range, and a box whose range starts at 1024 hands out ports
+// Chrome refuses outright — every navigation of the run then fails `net::ERR_UNSAFE_PORT`.
+
+/** What `freePort` needs of a listener: the port the OS gave it, and a way to give it back. */
+export interface PortProbe {
+  readonly port: number;
+  stop(): void;
+}
+
+/**
+ * Chromium's restricted ports (`net/base/port_util.cc`, `kRestrictedPorts`) from 1024 up — the
+ * ones an unprivileged listener can be handed. Below 1024 the OS never answers a `port: 0` ask.
+ */
+export const BROWSER_REFUSED_PORTS: ReadonlySet<number> = new Set([
+  1719, 1720, 1723, 2049, 3659, 4045, 4190, 5060, 5061, 6000, 6566, 6665, 6666, 6667, 6668, 6669,
+  6679, 6697, 10_080,
+]);
+
+/** Listen on a port of the OS's choosing. */
+const listenOnAnyPort = (): PortProbe => {
+  const probe = Bun.serve({ port: 0, fetch: () => new Response() });
+  return { port: probe.port ?? 0, stop: () => void probe.stop(true) };
+};
+
+/**
+ * A port nothing holds right now, asked of the OS and handed to the child — and one a browser will
+ * open. A refused port is KEPT listening while the next is asked for, so the OS cannot answer with
+ * it again: the walk ends after at most one ask per refused port, with no counter and no retry.
+ */
+export const freePort = (listen: () => PortProbe = listenOnAnyPort): number => {
+  const refused: PortProbe[] = [];
+  try {
+    for (;;) {
+      const probe = listen();
+      if (BROWSER_REFUSED_PORTS.has(probe.port)) {
+        refused.push(probe);
+        continue;
+      }
+      probe.stop();
+      return probe.port;
+    }
+  } finally {
+    for (const probe of refused) probe.stop();
+  }
+};

package/src/harness.ts

@@ -4,6 +4,7 @@
 
 import { afterAll, beforeAll, describe, test } from 'bun:test';
 import { captureDeterminism, installDeterminism, restoreCapturedDeterminism } from './determinism';
+import { AppNotBootedError } from './errors';
 import {
   allowHost,
   captureNetwork,
@@ -171,7 +172,7 @@ export function describeApp(
       booted = undefined;
     });
     body(() => {
-      if (booted === undefined) throw new ReferenceError('app is not booted yet');
+      if (booted === undefined) throw new AppNotBootedError({ suite: name });
       return booted.handle;
     });
   });

package/src/index.ts

@@ -27,6 +27,8 @@ export { afterAll, afterEach, beforeAll, beforeEach, describe, expect } from 'bu
 // `@ultimat3/http` is imported inside the function.
 export type { AuthRequestInit } from './auth-request';
 export { authRequest } from './auth-request';
+export type { BudgetStoreLike } from './budget-store-conformance';
+export { budgetStoreConformance } from './budget-store-conformance';
 // The browser-backed e2e driver and the raw-CDP browser under it — moved here from
 // `@ultimat3/cli` in 22.0.0. `installE2eDriver` is the ONE entry point an app's test preload calls;
 // `openE2eBrowserIfAvailable()` answers `undefined` on a machine with no Chrome, so a
@@ -35,9 +37,15 @@ export { authRequest } from './auth-request';
 export type { E2eBrowser, OpenE2eBrowserOptions } from './cdp-browser';
 export {
   DEFAULT_CDP_TIMEOUT_MS,
+  E2E_BROWSER_CLOSE_MS,
+  E2E_BROWSER_OPEN_MS,
+  E2E_GOTO_MS,
+  E2E_TAB_OPEN_MS,
   openE2eBrowser,
   openE2eBrowserIfAvailable,
 } from './cdp-browser';
+export type { E2eBrowserLease, RunEndHook } from './cdp-browser-lease';
+export { closeE2eBrowsersAtRunEnd, leaseE2eBrowser } from './cdp-browser-lease';
 export type {
   CdpConnection,
   CdpConnectionOptions,
@@ -50,6 +58,12 @@ export type { CdpE2eTabOptions, E2eTab } from './cdp-e2e-page';
 export { cdpE2eTab } from './cdp-e2e-page';
 export type { CdpE2eSessionOptions, E2eSession } from './cdp-e2e-session';
 export { cdpE2eSession } from './cdp-e2e-session';
+export type {
+  CdpLaunchAttempt,
+  CdpTargetGone,
+  CdpTimeoutObservation,
+  CdpTimeoutReading,
+} from './cdp-errors';
 export {
   CdpBrowserMissingError,
   CdpCallFailedError,
@@ -62,6 +76,9 @@ export {
   CHROME_PATH_ENV,
   CONTAINER_CHROME_ARGS,
   findChrome,
+  LAUNCH_ATTEMPTS,
+  LAUNCH_BUDGET_MS,
+  LAUNCH_TIMEOUT_MS,
   launchChrome,
   launchFoundChrome,
 } from './cdp-launch';
@@ -79,7 +96,6 @@ export {
   captureDeterminism,
   DEFAULT_NOW,
   DEFAULT_SEED,
-  frozenClock,
   frozenNow,
   installDeterminism,
   isDeterminismInstalled,
@@ -88,9 +104,10 @@ export {
   seededRandom,
   seededUuid,
   setFrozenClock,
+  withFrozenClock,
 } from './determinism';
 export type { E2eApp, E2eAppMode, StartE2eAppOptions } from './e2e-app';
-export { startE2eApp } from './e2e-app';
+export { E2E_APP_START_MS, E2E_APP_STOP_MS, startE2eApp } from './e2e-app';
 export { E2E_ROOT_ENV, e2eApp, e2eBaseUrl, e2eBrowser } from './e2e-browser-handle';
 export type { E2eDriverOptions } from './e2e-driver';
 export { e2eFixtures, installE2eDriver } from './e2e-driver';
@@ -121,6 +138,7 @@ export {
 } from './e2e-selection';
 export type { TestingErrorCode } from './errors';
 export {
+  AppNotBootedError,
   FixtureUnavailableError,
   NetworkOfflineError,
   NetworkSealedError,
@@ -146,7 +164,7 @@ export { clearPersister, persisterInstalled, usePersister } from './factory-pers
 export type { EntityRegistry, FactoryRegistry } from './factory-registry';
 export { factoriesFor } from './factory-registry';
 export type { TestClock, TestDuration } from './fixture-clock';
-export { createTestClock } from './fixture-clock';
+export { testClock } from './fixture-clock';
 export type {
   DriverFixtureName,
   DriverFixtures,
@@ -179,15 +197,15 @@ export type {
   RunJobsOptions,
   StepTally,
 } from './fixture-jobs';
-export { createRunJobs } from './fixture-jobs';
+export { testJobs } from './fixture-jobs';
 export type { MailRef, TestMail } from './fixture-mail';
-export { createTestMail } from './fixture-mail';
+export { testMail } from './fixture-mail';
 export type { TestNetwork } from './fixture-network';
-export { createTestNetwork } from './fixture-network';
+export { testNetwork } from './fixture-network';
 export type { ObservedStatement, StatementShape, TestStatements } from './fixture-statements';
-export { createTestStatements } from './fixture-statements';
+export { testStatements } from './fixture-statements';
 export type { SubscribeDriver } from './fixture-subscribe';
-export { createSubscribeDriver } from './fixture-subscribe';
+export { subscribeDriver } from './fixture-subscribe';
 export { fixtureTest as test } from './fixtures';
 export {
   ALL_FIXTURE_NAMES,
@@ -271,8 +289,9 @@ export {
   normalizeIslandName,
 } from './island-states-resolve';
 export { ISOLATED_ENV, releasePluginsAfterIsolatedFile } from './isolated-plugins';
+export { jobDriverConformance } from './job-driver-conformance';
 export type { LiveConnection, LiveNodeHandle, LiveNodeOptions } from './live-node';
-export { createLiveNode } from './live-node';
+export { liveNode } from './live-node';
 // The store a mutator's `local()` half writes into under test — the Map every app hand-rolled.
 export type { LocalRows, MemoryLocalTx } from './local-tx';
 export { memoryLocalTx } from './local-tx';
@@ -323,11 +342,11 @@ export type { SqlRunner, TemplateDbConfig, WorkerDatabase } from './template-db'
 export {
   acquireWorkerDatabase,
   cloneSql,
-  createTemplateSql,
   DEFAULT_TEMPLATE,
   databaseNameFor,
   dropSql,
   lockSql,
+  templateSql,
   unlockSql,
   urlFor,
   workerId,