@ultimat3/cli 22.15.0 → 24.0.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();
-}

package/src/scaffold-fixture.ts

@@ -1,160 +0,0 @@
-// What the scaffold drift gate compiles: every documented `x new` invocation, with every `x g`
-// generator run on top of the one that carries an app. Separate from the compiler harness next to
-// it, because "which scaffolds exist" is a fact about the CLI's surface, not about running `tsc`.
-
-import type { GenerateOptions } from './cmd-generate';
-import { dedupe, generate } from './cmd-generate';
-import { planNewApp } from './cmd-new';
-import type { GeneratedFile } from './templates';
-
-/** The app the fixture scaffolds. Kebab, multi-word: single-word names hide casing bugs. */
-export const FIXTURE_APP = 'ledger-demo';
-
-/**
- * An `errors.ts` an author wrote: it declares what the slice throws, and not the generated name.
- * The generator's INPUT only — the sandbox's own `errors.ts` is the one the resource wrote — so it
- * carries no `X_*` code: a literal here would be one shipped source hands a reader, and the
- * registry rule would ask where it was registered.
- */
-export const HANDWRITTEN_ERRORS = `import { UltimateError } from '@ultimat3/core';
-
-export class LedgerClosedError extends UltimateError {}
-`;
-
-/**
- * A feature slice whose entity is NOT tenant-scoped — the shape `x g entity`'s own comment
- * describes for a single-tenant app, and never a shape the generator writes itself. The
- * generator's INPUT only, the same way `HANDWRITTEN_ERRORS` above is: `x g job`/`x g task` read
- * this from a real `entity.ts`, and a fixture that never exercised it compiled only the shape
- * that never failed.
- */
-export const HANDWRITTEN_ENTITY_NO_TENANT = `import { entity, text, uuid } from '@ultimat3/entity';
-
-export const shortLink = entity('short_links', {
-  columns: { id: uuid().primaryKey(), url: text({ max: 2000 }) },
-});
-
-export type ShortLink = typeof shortLink.$row;
-`;
-
-/** The paired `repo.ts`: no `byId`, no `listByOrg` — nothing this slice's job may call. */
-export const HANDWRITTEN_REPO_NO_TENANT = `import { db, sql } from '@ultimat3/db';
-import type { ShortLink } from './entity';
-
-export async function list(limit = 50): Promise<readonly ShortLink[]> {
-  return db().query<ShortLink>(sql\`select * from short_links order by url limit \${limit}\`);
-}
-`;
-
-/**
- * The `invoice` resource's own `entity.ts`, as `x g` would read it off disk after the resource
- * below ran — the generators writing INTO that slice are handed it, because a slice with no entity
- * now gets the neutral body and no invented table.
- */
-export const INVOICE_ENTITY = String(
-  generate({ kind: 'entity', name: 'invoice' }).find((file) => file.path.endsWith('/entity.ts'))
-    ?.contents,
-);
-
-/**
- * One realistic invocation of every generator, on top of `x new --example`. Names differ from
- * their feature on purpose: `x g query invoice --feature invoice` would collide with the entity
- * import, and a fixture that trips over its own naming stops testing the templates.
- *
- * `admin: true` on the resource is not decoration: `apps/web/app/<name>/admin/resource.ts` and its
- * test are templates no other invocation emits, and they cost nothing extra here because they land
- * in a sandbox that is compiled anyway.
- */
-export const FIXTURE_GENERATORS: readonly GenerateOptions[] = [
-  { kind: 'resource', name: 'invoice', admin: true },
-  { kind: 'entity', name: 'credit-note', feature: 'credit-note' },
-  { kind: 'policy', name: 'credit-note', feature: 'credit-note' },
-  { kind: 'action', name: 'send-invoice', feature: 'invoice', sliceEntity: INVOICE_ENTITY },
-  { kind: 'mutator', name: 'rename-invoice', feature: 'invoice', sliceEntity: INVOICE_ENTITY },
-  // The other shape both templates have: a slice whose `errors.ts` is the author's and declares
-  // no `InvoiceNotFoundError`. The resource's own `errors.ts` still lands in the sandbox (it does
-  // declare one), which is the point — this compiles the file `x g action` writes when it must
-  // not import that class, beside the one it writes when it may.
-  {
-    kind: 'action',
-    name: 'ping-invoice',
-    feature: 'invoice',
-    sliceErrors: HANDWRITTEN_ERRORS,
-    sliceEntity: INVOICE_ENTITY,
-  },
-  {
-    kind: 'mutator',
-    name: 'touch-invoice',
-    feature: 'invoice',
-    sliceErrors: HANDWRITTEN_ERRORS,
-    sliceEntity: INVOICE_ENTITY,
-  },
-  { kind: 'query', name: 'invoice-search', feature: 'invoice' },
-  { kind: 'query', name: 'invoice-feed', feature: 'invoice', live: true },
-  { kind: 'job', name: 'sweep-invoices', feature: 'invoice', sliceEntity: INVOICE_ENTITY },
-  { kind: 'backfill', name: 'reindex-invoices', feature: 'invoice' },
-  { kind: 'task', name: 'nightly-sweep', feature: 'invoice', sliceEntity: INVOICE_ENTITY },
-  // The other shape both templates have: a feature whose entity names no tenant column, so the
-  // job/task must not assume one — compiled here beside the tenant-scoped pair above, exactly as
-  // `ping-invoice`/`touch-invoice` compile the action's other shape beside `send-invoice`.
-  {
-    kind: 'job',
-    name: 'purge-orphans',
-    feature: 'short-link',
-    sliceEntity: HANDWRITTEN_ENTITY_NO_TENANT,
-    sliceRepo: HANDWRITTEN_REPO_NO_TENANT,
-  },
-  {
-    kind: 'task',
-    name: 'nightly-purge',
-    feature: 'short-link',
-    sliceEntity: HANDWRITTEN_ENTITY_NO_TENANT,
-    sliceRepo: HANDWRITTEN_REPO_NO_TENANT,
-  },
-  { kind: 'route', name: 'pricing', surface: 'site' },
-  { kind: 'route', name: 'billing', surface: 'app' },
-  // `--at`, pointed at the `site/` route above: an island's whole reason to exist is a 0kb page
-  // that needs one interactive control, so the fixture places it where that is true.
-  { kind: 'island', name: 'currency-picker', at: 'apps/web/site/pricing' },
-  // The one screen the admin derives from nothing — and the one generator that must NOT emit a
-  // `defineRoute`, so compiling it is how that stays true.
-  { kind: 'admin:page', name: 'reconcile', permission: 'ledger:reconcile' },
-  // The app's own convention. It is the only generated file that imports `@ultimat3/cli` for its
-  // types, so compiling it is what proves a scaffolded app can actually write one.
-  { kind: 'guard', name: 'migration-safety' },
-];
-
-/** The whole scaffolded surface: a new app, then every generator run inside it. */
-export function scaffoldFixture(): readonly GeneratedFile[] {
-  return dedupe([
-    ...planNewApp({ name: FIXTURE_APP, example: true }),
-    ...FIXTURE_GENERATORS.flatMap((options) => generate(options)),
-  ]);
-}
-
-export interface ScaffoldVariant {
-  /** Names the invocation in a failure, so a red gate says which `x new` broke. */
-  readonly name: string;
-  /** What this variant emits that no other one does — why it earns its own compile. */
-  readonly why: string;
-  readonly files: readonly GeneratedFile[];
-}
-
-/**
- * Every scaffold a user can ask for, each compiled on its own. One variant per *file set*, not per
- * flag: `--no-example` writes a different `packages/db` than `--example` does, and compiling only
- * the example app is what let `x new --no-example` ship a `schema.ts` importing a slice that
- * invocation never writes.
- */
-export const scaffoldVariants = (): readonly ScaffoldVariant[] => [
-  {
-    name: 'x new',
-    why: 'the example slice, plus one run of every generator on top of it',
-    files: scaffoldFixture(),
-  },
-  {
-    name: 'x new --no-example',
-    why: 'an empty app/: no entity, so schema, seed and the initial migration have nothing to name',
-    files: planNewApp({ name: FIXTURE_APP, example: false }),
-  },
-];

package/src/templates/island-fixture.ts

@@ -1,76 +0,0 @@
-// TEST-ONLY. An app root on disk holding emitted files, with the packages an island imports
-// resolvable BY SPECIFIER the way a real app resolves them — so a template that emits
-// `import { Button } from '@ultimat3/ui'` is proven by a build that actually resolves it, and not
-// by a string assertion that the import is present.
-
-// `node:` by necessity, and SYNC by necessity: `[Symbol.dispose]` cannot await, so the teardown
-// half has to be synchronous — and Bun ships neither a path API nor a `symlink`.
-import { mkdirSync, rmSync, symlinkSync } from 'node:fs';
-import { dirname, join } from 'node:path';
-import type { GeneratedFile } from './naming';
-
-/** `packages/cli/src/templates` → the repo root, four hops up. */
-const REPO_ROOT = join(import.meta.dir, '..', '..', '..', '..');
-
-/**
- * INSIDE the checkout, and measured rather than chosen: the identical fixture under `os.tmpdir()`
- * fails every `@ultimat3/*` and every relative import inside it with `Could not resolve`, because
- * `Bun.build`'s resolver is scoped to the project `bun test` was started in and an app root outside
- * it cannot reach its own `node_modules`. `.prerender-fixture` is the same shape for the same
- * reason. The leading dot keeps it out of every `tsc` wildcard include.
- */
-const FIXTURE_ROOT = join(REPO_ROOT, 'packages', 'cli', '.island-fixture');
-
-/** The package the fixture lives inside. Linking it would aim a symlink at its own ancestor. */
-const SELF = 'cli';
-
-export interface FixtureApp extends Disposable {
-  /** Absolute path of the app root — what `buildIslands` globs from. */
-  readonly path: string;
-}
-
-/**
- * Symlinks rather than a `bun install`: the emitted island must resolve THIS working copy of
- * `@ultimat3/ui`, and an install in a fixture directory would fetch the registry's last release
- * and quietly prove nothing about the change under test. Every workspace is linked, not a chosen
- * few — a template that grows an import should build, not fail on a list nobody updated.
- */
-function linkDependencies(root: string): void {
-  const scope = join(root, 'node_modules', '@ultimat3');
-  mkdirSync(scope, { recursive: true });
-  const packages = join(REPO_ROOT, 'packages');
-  for (const entry of new Bun.Glob('*/package.json').scanSync({ cwd: packages })) {
-    const name = entry.slice(0, entry.indexOf('/'));
-    if (name === SELF) continue;
-    symlinkSync(join(packages, name), join(scope, name), 'dir');
-  }
-  // Resolved, never spelled as a path: the installer's layout is its own business and a hardcoded
-  // `node_modules/solid-js` is a fixture that breaks on a linker change rather than on a real one.
-  symlinkSync(
-    dirname(Bun.resolveSync('solid-js/package.json', REPO_ROOT)),
-    join(root, 'node_modules', 'solid-js'),
-    'dir',
-  );
-}
-
-/**
- * `Disposable`, so the idiom is `using root = await fixtureAppRoot(label, files)`. `label` is the
- * caller's, and is what keeps two test FILES off one directory: the path is fixed rather than
- * random, because a random one cannot be named in `.gitignore` and a crashed run leaves it behind.
- */
-export async function fixtureAppRoot(
-  label: string,
-  files: readonly GeneratedFile[],
-): Promise<FixtureApp> {
-  const path = join(FIXTURE_ROOT, label);
-  rmSync(path, { recursive: true, force: true });
-  mkdirSync(path, { recursive: true });
-  linkDependencies(path);
-  for (const file of files) await Bun.write(join(path, file.path), String(file.contents));
-  return {
-    path,
-    [Symbol.dispose]: (): void => {
-      rmSync(path, { recursive: true, force: true });
-    },
-  };
-}

package/src/verify-errors.ts

@@ -1,49 +0,0 @@
-// The gate's sizing and CI-split refusals: a bad budget env var, an unsplittable `--shard`, and a
-// `x verify merge` part that is not a verify document. Split from errors.ts at its size ceiling.
-
-import { UltimateError } from '@ultimat3/core';
-
-/**
- * `ULTIMATE_TEST_MEMORY_BUDGET` or `ULTIMATE_TEST_MAX_WORKERS` set to something that does not
- * parse. Refused rather than ignored: a typo read as "the default" is a run sized for a machine
- * the caller said this is not.
- */
-export class TestBudgetInvalidError extends UltimateError {
-  constructor(name: string, value: string) {
-    super({
-      code: 'X_TEST_BUDGET_INVALID',
-      cause: `${name}=${JSON.stringify(value)} does not parse — ${
-        name === 'ULTIMATE_TEST_MAX_WORKERS'
-          ? 'expected a positive integer'
-          : 'expected a size such as 3g, 512m or 4GiB'
-      }`,
-      fix:
-        name === 'ULTIMATE_TEST_MAX_WORKERS'
-          ? 'ULTIMATE_TEST_MAX_WORKERS=4 x verify'
-          : 'ULTIMATE_TEST_MEMORY_BUDGET=3g x verify',
-    });
-  }
-}
-
-/** `x verify --shard` asked for a split the gate cannot make. */
-export class VerifyShardInvalidError extends UltimateError {
-  constructor(input: { reason: string; fix?: string }) {
-    super({
-      code: 'X_VERIFY_SHARD_INVALID',
-      cause: `x verify --shard: ${input.reason}`,
-      fix: input.fix ?? 'x verify --only unit --shard 1/4 --json',
-    });
-  }
-}
-
-/** A part handed to `x verify merge` that is not an `x verify --json` document. */
-export class VerifyMergeInputError extends UltimateError {
-  constructor(input: { file: string; reason: string; sourceError?: unknown }) {
-    super({
-      code: 'X_VERIFY_MERGE_INPUT',
-      cause: `x verify merge: ${input.file} ${input.reason}`,
-      fix: 'x verify --only <step> --json > part.json   # one document per part, the last line of stdout',
-      ...(input.sourceError === undefined ? {} : { sourceError: input.sourceError }),
-    });
-  }
-}