@ultimat3/cli 22.14.0 → 23.0.0

package/src/workspace-dep-edit.ts

@@ -0,0 +1,127 @@
+// One workspace declaring another in its `package.json`, as a TEXT edit. A generator that makes
+// `packages/db` import the web app owes the manifest line `package-shape` would otherwise demand
+// (`X_WORKSPACE_DEP_UNDECLARED`), and re-serialising the whole file would reformat arrays and
+// spacing the author — or their formatter — chose.
+
+import { containedPath } from './generate-write';
+
+const MANIFEST = 'package.json';
+
+/** The fields a manifest edit reads. Anything else in the file is carried through untouched. */
+interface Manifest {
+  readonly name?: unknown;
+  readonly version?: unknown;
+  readonly dependencies?: unknown;
+  readonly devDependencies?: unknown;
+  readonly peerDependencies?: unknown;
+}
+
+function parseManifest(text: string): Manifest | undefined {
+  try {
+    const parsed: unknown = JSON.parse(text);
+    return typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed)
+      ? (parsed as Manifest)
+      : undefined;
+  } catch {
+    // A manifest that does not parse is `bun install`'s finding, and `package-shape`'s.
+    return undefined;
+  }
+}
+
+const stringRecord = (value: unknown): Readonly<Record<string, string>> =>
+  typeof value === 'object' && value !== null
+    ? Object.fromEntries(
+        Object.entries(value).filter(
+          (entry): entry is [string, string] => typeof entry[1] === 'string',
+        ),
+      )
+    : {};
+
+const declares = (manifest: Manifest, name: string): boolean =>
+  [manifest.dependencies, manifest.devDependencies, manifest.peerDependencies].some((block) =>
+    Object.hasOwn(stringRecord(block), name),
+  );
+
+/**
+ * `manifest` with `name` declared under `dependencies`, or `undefined` when it already is — or
+ * when the text is not a manifest this can edit safely. The block is rewritten from its parsed
+ * entries, sorted the way `bun add` sorts them; every byte outside it is the author's.
+ */
+export function withDependency(
+  manifest: string,
+  name: string,
+  version: string,
+): string | undefined {
+  const parsed = parseManifest(manifest);
+  if (parsed === undefined || declares(parsed, name)) return undefined;
+  const block = /^([ \t]*)"dependencies":\s*\{/m.exec(manifest);
+  if (block === null) {
+    const close = manifest.lastIndexOf('}');
+    const body = manifest.slice(0, close).trimEnd();
+    // `{}` has no property to put a comma after; nothing a scaffold writes is that.
+    if (close === -1 || body.endsWith('{')) return undefined;
+    return `${body},\n  "dependencies": {\n    "${name}": "${version}"\n  }\n}\n`;
+  }
+  const indent = block[1] ?? '';
+  const open = block.index + block[0].length;
+  const close = manifest.indexOf('}', open);
+  if (close === -1) return undefined;
+  const entries = Object.entries({ ...stringRecord(parsed.dependencies), [name]: version })
+    .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))
+    .map(([key, value]) => `${indent}  ${JSON.stringify(key)}: ${JSON.stringify(value)}`);
+  return `${manifest.slice(0, open)}\n${entries.join(',\n')}\n${indent}${manifest.slice(close)}`;
+}
+
+/** A workspace's `name` and `version`, or `undefined` when its manifest supplies no name. */
+export async function readWorkspace(
+  root: string,
+  dir: string,
+): Promise<{ readonly name: string; readonly version: string } | undefined> {
+  const file = Bun.file(containedPath(root, `${dir}/${MANIFEST}`));
+  if (!(await file.exists())) return undefined;
+  const parsed = parseManifest(await file.text());
+  if (parsed === undefined || typeof parsed.name !== 'string' || parsed.name === '') {
+    return undefined;
+  }
+  return {
+    name: parsed.name,
+    version: typeof parsed.version === 'string' ? parsed.version : '0.0.0',
+  };
+}
+
+/** One file a caller is about to write: its app-root-relative path and its whole new text. */
+export interface PlannedEdit {
+  readonly path: string;
+  readonly contents: string;
+}
+
+/**
+ * The edit that declares the workspace at `toDir` in `fromDir`'s manifest, NOT yet written — a
+ * registrar plans every file it touches and writes all of them or none. `undefined` when the edge
+ * is already declared or either manifest is unreadable; the `package-shape` step then names the
+ * line, which is the same edit by hand.
+ */
+export async function planWorkspaceDependency(
+  root: string,
+  fromDir: string,
+  toDir: string,
+): Promise<PlannedEdit | undefined> {
+  const target = await readWorkspace(root, toDir);
+  const path = `${fromDir}/${MANIFEST}`;
+  const file = Bun.file(containedPath(root, path));
+  if (target === undefined || !(await file.exists())) return undefined;
+  const contents = withDependency(await file.text(), target.name, target.version);
+  return contents === undefined ? undefined : { path, contents };
+}
+
+/** Declares it now. Answers the path it rewrote, or `undefined` when there was nothing to write. */
+export async function declareWorkspaceDependency(
+  root: string,
+  fromDir: string,
+  toDir: string,
+): Promise<string | undefined> {
+  const edit = await planWorkspaceDependency(root, fromDir, toDir);
+  if (edit === undefined) return undefined;
+  await Bun.write(containedPath(root, edit.path), edit.contents);
+  return edit.path;
+}

package/src/cmd-dev-fixture.ts

@@ -1,204 +0,0 @@
-// The app `x dev` boots in its tests, and the one place it is declared: every assertion that
-// needs a booted app lives in `cmd-dev.test.ts`, because a process has ONE lifecycle — the second
-// in-process boot is refused (X_LIFECYCLE_DRAINED) — and the coverage gate runs a package in one
-// process. So the fixture is a module of its own, and that file keeps its line budget for tests.
-//
-// What the app declares, and what each declaration is here to prove:
-//   app.config.ts               the root marker a real `x dev` cannot start without; `ai.mcp` by default
-//   apps/web/mcp.ts             the app's own MCP endpoint, mounted by the web role
-//   apps/web/runtime.ts         the app's middleware and disks, reaching a development process
-//   .git/HEAD                   the fixture is its own repository — see the entry below
-//   apps/web/app/hello/*        an SSR page with a component, edited on disk while `x dev` runs
-//   apps/web/app/notes/*        a memory-backed entity and a live query, fed by the in-process bridge
-//   apps/web/app/posts/*        an action, a policy and a query, mounted as HTTP routes
-//   apps/web/site/pricing/*     a static page with its own stylesheet, under the CSP `x dev` sends
-import { resetRegistry as resetActions } from '@ultimat3/action';
-import { clearRegistry as clearEntities } from '@ultimat3/entity';
-import { resetJobs, resetTasks } from '@ultimat3/jobs';
-import { clearPermissions, clearRoles } from '@ultimat3/policy';
-import { resetRegistry as resetQueries } from '@ultimat3/query';
-import type { Frame } from '@ultimat3/realtime';
-import { decode } from '@ultimat3/realtime';
-import type { WsLike } from '@ultimat3/realtime/server';
-import { clearRoutes } from '@ultimat3/render';
-import { resetAppLoad } from './app-load';
-
-export const DEV_FIXTURE_FILES: Readonly<Record<string, string>> = {
-  'package.json': JSON.stringify({ name: 'dev-fixture', version: '1.4.0' }),
-
-  // Its own repository, so the ignore walk stops HERE. The framework's root `.gitignore` lists
-  // `packages/cli/.dev-fixture/`, and `devIgnore` honours every ancestor up to a `.git` — without
-  // this marker the watcher admitted the fixture root and nothing under it, so no save in this
-  // tree ever reached `rebuild`, and the reload path was booted by every run and exercised by none.
-  '.git/HEAD': 'ref: refs/heads/main\n',
-
-  // The root marker a real `x dev` cannot start without, and where `ai.mcp` is declared — by
-  // default `{ expose: true, path: '/mcp' }`, which is what the MCP mount reads.
-  'app.config.ts': `import { defineConfig } from '@ultimat3/core';
-export const config = defineConfig({ name: 'dev-fixture' });
-`,
-
-  // The app's own MCP endpoint, in the contract `app-mcp.ts` reads. `resolveToken` answering
-  // `null` rejects every bearer, which is enough to prove the ROUTE is mounted (401, not 404).
-  'apps/web/mcp.ts': `import { defineAppMcp } from '@ultimat3/mcp';
-export const mcp = defineAppMcp({ include: 'exposed', resolveToken: () => null });
-`,
-
-  // The app's own middleware, in the contract `app-runtime.ts` reads: a header on every response
-  // is the cheapest proof that the chain `x dev` composed is the app's and not only the replica's.
-  // Its disks too: `x dev` built its own embedded disk and ignored this one until 22.4.
-  'apps/web/runtime.ts': `import { defineStorage, localDriver } from '@ultimat3/storage';
-const stamp = async (request, ctx, next) => {
-  const response = await next(request, ctx);
-  const headers = new Headers(response.headers);
-  headers.set('x-dev-runtime', 'app');
-  return new Response(response.body, { status: response.status, headers });
-};
-const storage = defineStorage({
-  disks: { appdisk: localDriver({ root: new URL('../../.app-disk', import.meta.url).pathname }) },
-  default: 'appdisk',
-});
-export const runtime = { middleware: [stamp], storage };
-`,
-
-  // A memory-backed entity, so the fixture needs no migration: the row observer sits on
-  // `database()`'s repo wrapper, the same seam a Postgres-backed repo writes through.
-  'apps/web/app/notes/entity.ts': `import { database, entity, memoryDriver, text, uuid } from '@ultimat3/entity';
-export const notes = entity('notes', { columns: { id: uuid().primaryKey(), title: text() } });
-export const db = database({ notes }, { driver: memoryDriver() });
-`,
-  'apps/web/app/notes/live.ts': `import { allow } from '@ultimat3/policy';
-import { from, query, t } from '@ultimat3/query';
-import { db } from './entity';
-export const liveNotes = query({
-  input: t.object({}),
-  policy: allow('public'),
-  live: true,
-  subscribes: ['notes'],
-  sql: () =>
-    from<{ id: string; title: string }>('notes', () => db.notes.where({}).all())
-      .orderBy('id')
-      .limit(50),
-});
-`,
-
-  'apps/web/app/posts/policy.ts': `import { allow, can, definePermissions, defineRoles } from '@ultimat3/policy';
-export const permissions = definePermissions(['post:publish'] as const);
-export const roles = defineRoles({
-  author: { grants: ['post:publish'] },
-  reader: { grants: [] },
-});
-export const canPostWrite = can('post:publish');
-export const anyone = allow();
-`,
-
-  'apps/web/app/posts/actions.ts': `import { action, t } from '@ultimat3/action';
-import { anyone, canPostWrite } from './policy';
-
-export const publishPost = action({
-  input: t.object({ id: t.uuid }),
-  output: t.object({ id: t.uuid }),
-  policy: canPostWrite,
-  async handle({ input }) {
-    return { id: input.id };
-  },
-});
-
-export const echoPost = action({
-  input: t.object({ word: t.string }),
-  output: t.object({ word: t.string }),
-  policy: anyone,
-  async handle({ input }) {
-    return { word: input.word };
-  },
-});
-`,
-
-  // A page with a body, on the surface an author edits all day. What the reload test rewrites: the
-  // module must be imported again for the new body to be served, which `import()` alone never does.
-  'apps/web/app/hello/page.tsx': `import { defineRoute } from '@ultimat3/render';
-
-export const config = defineRoute({
-  render: 'ssr',
-  hydrate: 'visible',
-  offline: 'runtime',
-  budget: { js: '60kb' },
-  meta: () => ({ title: 'Hello', description: 'A page that is edited while x dev runs' }),
-});
-
-export function Page() {
-  return <p>generation one</p>;
-}
-`,
-
-  // An ISR page whose body is a COMPONENT in another file — the shape every real page has. What the
-  // component-reload test rewrites: the page module's own bytes never change, so only evicting what
-  // imports the component re-evaluates it, and only clearing the ISR store stops the first render
-  // from answering for the rest of the process (notificado.co, 2026-09-27).
-  'apps/web/site/news/headline.tsx': `export function Headline() {
-  return <h1>headline one</h1>;
-}
-`,
-
-  'apps/web/site/news/page.tsx': `import { defineRoute } from '@ultimat3/render';
-import { Headline } from './headline';
-
-export const config = defineRoute({
-  render: 'isr',
-  revalidate: { ttl: '1h' },
-  offline: 'runtime',
-  hydrate: 'never',
-  budget: { js: '0kb' },
-  meta: () => ({ title: 'News', description: 'A page whose component is edited while x dev runs' }),
-});
-
-export function Page() {
-  return <main><Headline /></main>;
-}
-`,
-
-  // A stylesheet the page imports, because that import is what registers it — and the document's
-  // inline `<style>` is what the CSP has to name. Without one this file served no styled page and
-  // could not have caught the policy that blanked every deployed app.
-  'apps/web/site/pricing/page.module.scss': `.price { color: #123456; }
-`,
-
-  'apps/web/site/pricing/page.tsx': `import { defineRoute } from '@ultimat3/render';
-import './page.module.scss';
-
-export const config = defineRoute({
-  render: 'static',
-  offline: 'precache',
-  hydrate: 'never',
-  budget: { js: '0kb' },
-  meta: () => ({ title: 'Pricing', description: 'What it costs' }),
-});
-`,
-};
-
-export const resetRegistries = (): void => {
-  resetActions();
-  resetQueries();
-  clearEntities();
-  clearRoutes();
-  resetJobs();
-  resetTasks();
-  clearPermissions();
-  clearRoles();
-  resetAppLoad();
-};
-
-/** A `WsLike` that keeps every frame the node sends, decoded — what a live assertion reads. */
-export class FakeWs implements WsLike {
-  readonly frames: Frame[] = [];
-  send(data: string): number {
-    this.frames.push(decode(data));
-    return data.length;
-  }
-  close(): void {}
-  subscribe(): void {}
-  unsubscribe(): void {}
-  getBufferedAmount(): number {
-    return 0;
-  }
-}

package/src/dev-live-fixture.ts

@@ -1,122 +0,0 @@
-// The `x dev` live tests' process discipline, in one place: spawn the supervisor, read its two
-// streams, and — on every path, a failing one included — reap every process it started and prove
-// none is left. Two children of `cmd-dev-restart.live.test.ts` ran for six hours with ppid 1 and a
-// deleted cwd because the test's `finally` SIGKILLed the supervisor, which cannot forward a signal
-// it never gets, and nothing then looked for what it had started (2026-09-29).
-
-import { readdirSync, readlinkSync } from 'node:fs'; // why: /proc is read synchronously; Bun has no readlink.
-
-/** One pump per stream — reading a stream twice closes its reader under the first `for await`. */
-export function pump(stream: ReadableStream<Uint8Array>): { seen: () => string } {
-  const decoder = new TextDecoder();
-  let seen = '';
-  void (async () => {
-    for await (const chunk of stream) seen += decoder.decode(chunk, { stream: true });
-  })();
-  return { seen: () => seen };
-}
-
-/** Poll the buffer until `marker` shows up. The caller's own timeout is the deadline. */
-export async function waitFor(output: { seen: () => string }, marker: string): Promise<string> {
-  for (;;) {
-    const seen = output.seen();
-    if (seen.includes(marker)) return seen;
-    await Bun.sleep(25);
-  }
-}
-
-/** Whether `pid` is still a process — signal 0 delivers nothing and only asks. */
-export function alive(pid: number): boolean {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-/** Every descendant of `pid`, depth first — asked while `pid` lives, or its children are init's. */
-export function descendantsOf(pid: number): readonly number[] {
-  const out = Bun.spawnSync(['pgrep', '-P', String(pid)]).stdout.toString();
-  const children = out
-    .split('\n')
-    .map((line) => Number(line.trim()))
-    .filter((child) => Number.isInteger(child) && child > 0);
-  return children.flatMap((child) => [child, ...descendantsOf(child)]);
-}
-
-/**
- * Every process whose cwd is `dir` — a deleted one included, which Linux spells `<dir> (deleted)`.
- * The one question that finds an orphan after its parent is gone, when no process tree reaches it.
- * Empty where there is no `/proc` (macOS): the descendant walk is then the whole answer.
- */
-export function processesIn(dir: string): readonly number[] {
-  let pids: readonly string[];
-  try {
-    pids = readdirSync('/proc').filter((name) => /^\d+$/.test(name));
-  } catch {
-    return [];
-  }
-  const found: number[] = [];
-  for (const pid of pids) {
-    try {
-      const cwd = readlinkSync(`/proc/${pid}/cwd`);
-      if (cwd === dir || cwd === `${dir} (deleted)`) found.push(Number(pid));
-    } catch {
-      // Gone between the listing and the read, or not ours to read.
-    }
-  }
-  return found;
-}
-
-/** Whether anything still answers on `port` at the loopback address `x dev` binds. */
-export async function listening(port: number): Promise<boolean> {
-  try {
-    const socket = await Bun.connect({
-      hostname: '127.0.0.1',
-      port,
-      socket: { data: () => undefined },
-    });
-    socket.end();
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-/**
- * SIGKILL `pids`, then wait until each is gone. A test's last resort, run in `finally` — by then
- * every graceful stop the test meant to prove has had its chance. `performance.now()`, never
- * `Date.now()`: the test preload freezes the wall clock, and a deadline read off it never arrives.
- */
-export async function reap(pids: readonly number[], timeoutMs = 10_000): Promise<void> {
-  for (const pid of pids) {
-    try {
-      process.kill(pid, 'SIGKILL');
-    } catch {
-      // Already gone.
-    }
-  }
-  const until = performance.now() + timeoutMs;
-  while (pids.some(alive) && performance.now() < until) await Bun.sleep(25);
-}
-
-/** What was left: the pids still in `dir` and whether `port` still answers. Both empty is clean. */
-export async function leftovers(
-  dir: string,
-  port: number | undefined,
-): Promise<{ readonly pids: readonly number[]; readonly port: boolean }> {
-  return {
-    pids: processesIn(dir),
-    port: port === undefined ? false : await listening(port),
-  };
-}
-
-/**
- * The net under a TIMED-OUT test: bun abandons its body without running `finally`, so an
- * `afterEach` reaps whatever still runs in the fixture directory — the only handle left on an
- * orphan whose parent is gone.
- */
-export async function reapIn(dir: string): Promise<void> {
-  await reap(processesIn(dir));
-}

package/src/policy-fixture.ts

@@ -1,78 +0,0 @@
-// The one policy declaration set both `x policy` test files run against. Shared rather than
-// copied, for the reason `thrown-by.ts` gives: every count in both files' assertions is read off
-// THIS set, so a second copy drifts and each file keeps passing while they stop agreeing.
-
-import { action, registerActions, t } from '@ultimat3/action';
-import { and, can, definePermissions, defineRoles } from '@ultimat3/policy';
-import { from, query, registerQuery } from '@ultimat3/query';
-
-/**
- * The row the fixture's two reads return, over an empty source: `x policy` describes a query and
- * evaluates its policy, it never executes one, so the rows are the one fact that may be missing.
- */
-interface PostRow {
-  readonly id: string;
-}
-
-/**
- * Four permissions, three roles, two actions and two queries — each fact earning its place.
- *
- * `archivePost` is guarded by a COMPOSITE, and that is the point of it: its display capability is
- * the label `and(post:publish, post:read)`, which is not any permission, so a report that matched
- * on the label counted this action as enforcing nothing and printed both of its permissions as
- * dead grants. It enforces two, and the facts say so.
- *
- * `post:delete` is the control: declared, granted to `admin`, enforced by nothing at all. It is
- * what a genuinely dead grant looks like, and it is what keeps `unenforced` a claim worth making
- * now that a composite no longer lands in it by accident.
- *
- * `post:publish` is enforced by two actions AND a query, so the aggregation across declarations
- * has something to aggregate.
- *
- * Registers only; the registries are process-global, so the caller clears them first.
- */
-export function registerPolicyFixture(): void {
-  definePermissions(['post:publish', 'post:read', 'post:delete', 'feed:read'] as const);
-  defineRoles({
-    admin: { grants: ['post:publish', 'post:read', 'post:delete', 'feed:read'] },
-    editor: { grants: ['post:publish', 'post:read'] },
-    reader: { grants: ['post:read', 'feed:read'] },
-  });
-  registerActions({
-    publishPost: action({
-      input: t.object({}),
-      output: t.object({}),
-      policy: can('post:publish'),
-      async handle() {
-        return {};
-      },
-    }),
-    archivePost: action({
-      input: t.object({}),
-      output: t.object({}),
-      policy: and(
-        can('post:publish'),
-        can('post:read', ({ actor }) => actor?.id === 'admin'),
-      ),
-      async handle() {
-        return {};
-      },
-    }),
-  });
-  registerQuery(
-    'postFeed',
-    query({
-      input: t.object({}),
-      policy: can('feed:read'),
-      sql: () => from<PostRow>('posts', []).orderBy('id').limit(10),
-    }),
-  );
-  registerQuery(
-    'publishedPosts',
-    query({
-      input: t.object({}),
-      policy: can('post:publish'),
-      sql: () => from<PostRow>('posts', []).orderBy('id').limit(10),
-    }),
-  );
-}

package/src/realtime-browser-probe-fixture.ts

@@ -1,9 +0,0 @@
-// The browser island `wiki/Realtime.md` promises: one live hook and nothing else. It is a real
-// module rather than a string a test writes to a temp path, because module resolution is the thing
-// under test — `@ultimat3/realtime`'s client entry must reach neither the bus nor the WAL decoder.
-// Bundled AND imported by `realtime-browser-barrel.test.ts` — the import is what gives it an lcov
-// record, since `Bun.build()` reads this file without evaluating it.
-
-import { useQuery } from '@ultimat3/realtime';
-
-export const probeUseQuery = useQuery;

package/src/role-start-fixture.ts

@@ -1,78 +0,0 @@
-// The one `RunningServices` every `role-start` test file boots roles against, and the one reset
-// between them. Shared rather than copied, for the reason `policy-fixture.ts` gives: three files
-// start the same roles, and a second copy of the runtime drifts while each file keeps passing.
-//
-// Its own module rather than a `.test.ts` neighbours import, because `tsconfig.json` excludes
-// `*.test.ts` — a fixture written there is one `tsc` never reads.
-
-import { noopPurgeDriver } from '@ultimat3/cache';
-import { type RealtimeConfig, resetLifecycle } from '@ultimat3/core';
-import { resetHttpConfig } from '@ultimat3/http';
-import {
-  createMemoryDriver,
-  createMemoryEventBus,
-  createMemoryOutboxStore,
-  resetJobs,
-  resetJobsFacade,
-  resetTasks,
-} from '@ultimat3/jobs';
-import { createMemoryDriver as createMemoryMailDriver } from '@ultimat3/mail';
-import { DEFAULT_PRESENCE_TTL_MS, InProcessTransport } from '@ultimat3/realtime/server';
-import { defineStorage, localDriver } from '@ultimat3/storage';
-import { resolveServices } from './runtime-bindings';
-import type { RunningServices } from './runtime-services';
-
-/**
- * Every service a role touches, embedded but real — no PGlite boot for a role-wiring test.
- *
- * `root` is a parameter and not a constant: each test file owns its own directory and deletes it,
- * so two files sharing one on-disk storage root cannot leave the other's fixture half-removed.
- */
-/** Enabled, in-process: the section every role test before 22.0.0 was implicitly booting. */
-const REALTIME_ON: RealtimeConfig = { enabled: true, transport: 'memory', urlEnv: undefined };
-
-export function fixtureRuntime(root: string, realtime = REALTIME_ON): RunningServices {
-  const services = resolveServices(root, {});
-  const transport = new InProcessTransport();
-  return {
-    services,
-    db: { async ping() {}, async close() {} } as unknown as RunningServices['db'],
-    jobs: createMemoryDriver(),
-    // A real store, not a stub: the `worker` role starts the outbox relay against it, and a relay
-    // whose `claim()` rejects on the first 200ms tick is an unhandled rejection in whichever test
-    // happens to still be running.
-    outbox: createMemoryOutboxStore(),
-    events: createMemoryEventBus(),
-    transport,
-    realtime,
-    transportDetail: 'in-process fanout',
-    // The sync role reads this to build its `PresenceRegistry`; the default is what a boot with no
-    // `NATS_URL` resolves to, so the fixture is the real number rather than a rounder one.
-    presenceTtlMs: DEFAULT_PRESENCE_TTL_MS,
-    storage: defineStorage({ disks: { local: localDriver({ root: `${root}/storage` }) } }),
-    mail: createMemoryMailDriver(),
-    mailDetail: 'embedded',
-    purge: noopPurgeDriver(),
-    purgeDetail: 'none',
-    stop: async () => transport.close(),
-  };
-}
-
-/**
- * The process-global state one started role leaves behind. `resetLifecycle` is the load-bearing
- * one: core's lifecycle is process-wide and a stopped server leaves it drained, so without it the
- * SECOND web role in a file answers every request `X_DRAINING` — a suite that only passes when its
- * tests are run one at a time. `@ultimat3/http`'s own server suite resets it for the same reason.
- */
-export function resetDevRolesState(): void {
-  resetJobs();
-  resetJobsFacade();
-  resetTasks();
-  resetLifecycle();
-  // `configureHttp()` is a process-global registration made at MODULE scope, so one file that
-  // loads an app leaves that app's CORS origins, body limit and buckets standing for every later
-  // file in the same `bun test` process — and a scaffolded app now ships such a module
-  // (`apps/web/app/http.ts`). Nothing is broken today; this is the same rule the four resets above
-  // already follow, applied to the fifth global before it is the one that costs an afternoon.
-  resetHttpConfig();
-}