@ultimat3/cli 1.1.0 → 2.0.0

package/src/flag-number.ts

@@ -0,0 +1,56 @@
+// One integer-flag reader for every command that takes one. `Number.parseInt` alone accepts a
+// prefix and answers `NaN` for the rest, and three commands took it bare: `x doctor --port abc`
+// probed `NaN`, which `portFree` reports as free — a check that CANNOT FAIL — `x dev --port abc`
+// handed `NaN` to `Bun.serve` and bound an arbitrary port, and `x test --workers 4abc` ran four.
+
+import { BadFlagError } from './errors';
+import type { ParsedArgs } from './parse';
+import { flagString } from './parse';
+
+export interface IntFlag {
+  readonly name: string;
+  /** The command as it appears in the cause line, e.g. `doctor` for `x doctor`. */
+  readonly command: string;
+  readonly min: number;
+  readonly max?: number;
+  /** A runnable invocation carrying a good value — never a `<placeholder>`. */
+  readonly example: string;
+}
+
+const bound = (flag: IntFlag): string =>
+  flag.max === undefined ? `>= ${flag.min}` : `from ${flag.min} to ${flag.max}`;
+
+/** `/^\d+$/` first: it is the only test that refuses `4abc`, `4.9`, `0x10`, `+4` and ` 4`. */
+export function parseIntFlag(raw: string, flag: IntFlag): number {
+  const value = /^\d+$/.test(raw) ? Number.parseInt(raw, 10) : Number.NaN;
+  if (
+    !Number.isInteger(value) ||
+    value < flag.min ||
+    (flag.max !== undefined && value > flag.max)
+  ) {
+    throw new BadFlagError({
+      flag: flag.name,
+      command: flag.command,
+      reason: `expects an integer ${bound(flag)}, got "${raw}"`,
+      fix: flag.example,
+    });
+  }
+  return value;
+}
+
+/** The flag's value, or `undefined` when it was not given. Throws `X_CLI_BAD_FLAG` on a bad one. */
+export function readIntFlag(args: ParsedArgs, flag: IntFlag): number | undefined {
+  const raw = flagString(args, flag.name);
+  return raw === undefined ? undefined : parseIntFlag(raw, flag);
+}
+
+/** The same, with a default — for a flag whose spec already declares one. */
+export const intFlagOr = (args: ParsedArgs, flag: IntFlag, fallback: number): number =>
+  readIntFlag(args, flag) ?? fallback;
+
+/**
+ * Every port flag answers to the same bounds `serve.ts`'s `portValue` already enforces on `PORT`,
+ * 0 included — 0 is "let the kernel pick", which is how `x dev --port 0` boots a test server on a
+ * free port. Two ranges for one concept is the drift this constant exists to prevent.
+ */
+export const PORT_RANGE = { min: 0, max: 65_535 } as const;

package/src/framework-scope.ts

@@ -0,0 +1,49 @@
+// Where the `@ultimat3` packages THIS `x` is pinned against live on disk. One resolver, because
+// two answers to "which framework is installed" is two answers to every question read off it —
+// the docs `x docs` quotes and the `fix:` lines `x errors explain` projects come from the same
+// directory or they describe different builds.
+
+// `node:fs`/`node:path` because Bun ships neither: `dirname` walks a resolved module up to the
+// directory that owns it, and `existsSync` is what says which directory that is.
+import { existsSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+
+/**
+ * Deep enough for `src/index.ts` and for any entry an `exports` map could point at, shallow enough
+ * that a resolver answering something unexpected stops rather than walking to `/`.
+ */
+const MAX_DEPTH = 6;
+
+/**
+ * Resolved from the CLI's own dependency on `@ultimat3/core` rather than from the user's cwd:
+ * these are the packages this `x` would actually run. Resolution follows the symlink, so a
+ * workspace-linked app lands on the same `packages/` this monorepo does — one code path for both,
+ * and a directory listing rather than a hardcoded package list, because an app installs the
+ * subset it uses.
+ *
+ * The **exported entry** is what gets resolved, never `@ultimat3/core/package.json`: every package
+ * here declares `"exports": { ".": "./src/index.ts" }` and nothing else, so a subpath specifier is
+ * asking a resolver for something the package does not publish. Bun 1.3 happens to answer it
+ * anyway; a resolver that enforced `exports` would answer `undefined`, and the failure would be
+ * silent — `x docs` reporting no installed packages and `x errors explain` reporting that no
+ * framework raises the code. Walking up from the entry to the directory that owns its
+ * `package.json` depends on nothing but the entry that is already imported.
+ *
+ * `undefined` means the CLI cannot see its own dependency, which is a broken install and not
+ * merely an undocumented one; every caller reports that rather than answering emptily.
+ */
+export function frameworkScopeDir(): string | undefined {
+  let dir: string;
+  try {
+    dir = dirname(Bun.resolveSync('@ultimat3/core', import.meta.dir));
+  } catch {
+    return undefined;
+  }
+  for (let depth = 0; depth < MAX_DEPTH; depth += 1) {
+    if (existsSync(join(dir, 'package.json'))) return dirname(dir);
+    const parent = dirname(dir);
+    if (parent === dir) return undefined;
+    dir = parent;
+  }
+  return undefined;
+}

package/src/generate-kinds.ts

@@ -0,0 +1,97 @@
+// Which generators exist, and how one is named on a command line. Split from `cmd-generate.ts`
+// because "what a generator emits" and "which spelling reaches it" are two jobs — and the file
+// that held both had reached the 500-line ceiling, one generator short of failing its own gate.
+
+import { BadFlagError, MissingPositionalError, UnknownCommandError } from './errors';
+import type { Surface } from './templates';
+
+export const GENERATORS = [
+  'resource',
+  'action',
+  'mutator',
+  'backfill',
+  'job',
+  'route',
+  'policy',
+  'entity',
+  'query',
+  'task',
+  'island',
+  'admin:page',
+  'guard',
+] as const;
+
+export type Generator = (typeof GENERATORS)[number];
+
+/**
+ * A resource slice is app-surface by construction: it ships a live query, a form with a signal,
+ * two actions and a policy, and `site/` is the 0kb, never-hydrated surface that may not import
+ * `app/`. The documented shape is the slice in `app/` plus a separate public route
+ * (`docs/architecture/15-adding-a-feature.md`), so the flag is refused before anything is written
+ * rather than emitting a slice that fails the app's own budget and boundary gates.
+ */
+export function assertSurfaceSupported(kind: Generator, surface: Surface, name: string): void {
+  if (kind !== 'resource' || surface !== 'site') return;
+  throw new BadFlagError({
+    flag: 'surface',
+    command: 'g resource',
+    reason: 'a resource slice is app-surface — site/ ships 0kb JS and may not import app/',
+    // The caller's own name, not `<name>`: a `fix:` is copied and run verbatim, and `x g resource
+    // <name>` is a shell redirect (`bash: name: No such file or directory`), not a command.
+    fix: `x g resource ${name} && x g route ${name} --surface site`,
+  });
+}
+
+export function readKind(raw: string | undefined): Generator {
+  const kinds: readonly string[] = GENERATORS;
+  if (raw !== undefined && kinds.includes(raw)) return raw as Generator;
+  throw new UnknownCommandError({
+    path: `g ${raw ?? ''}`.trim(),
+    known: GENERATORS,
+    suggestion: 'g resource',
+  });
+}
+
+/** Two surfaces, spelled exactly. A typo that fell through to `app` would scaffold the wrong one. */
+export function readSurface(raw: string | undefined, kind: Generator, name: string): Surface {
+  if (raw === undefined || raw === 'app') return 'app';
+  if (raw === 'site') return 'site';
+  throw new BadFlagError({
+    flag: 'surface',
+    command: 'g',
+    reason: `"${raw}" is not a surface (site, app)`,
+    fix: `x g ${kind} ${name} --surface app`,
+  });
+}
+
+/**
+ * The missing `<name>` positional. It used to throw `X_CLI_UNKNOWN_COMMAND` — for a command form
+ * that IS known — with `fix: "x g route <name>"`, which pasted into a shell is a redirect
+ * (`bash: name: No such file or directory`). The code now says what is actually wrong, and the fix
+ * is a command that runs.
+ */
+export function readName(raw: string | undefined, kind: Generator): string {
+  if (raw !== undefined) return raw;
+  throw new MissingPositionalError({
+    command: `g ${kind}`,
+    positional: 'name',
+    example: `x g ${kind} ${EXAMPLE_NAME[kind]}`,
+  });
+}
+
+/** One runnable example per generator, so the `fix:` is a command and not a shape. */
+const EXAMPLE_NAME: Readonly<Record<Generator, string>> = {
+  resource: 'invoice',
+  action: 'publish-post',
+  mutator: 'rename-post',
+  backfill: 'backfill-slugs',
+  job: 'send-digest',
+  route: 'posts',
+  policy: 'post',
+  entity: 'post',
+  query: 'recent-posts',
+  task: 'nightly-digest',
+  island: 'counter',
+  'admin:page': 'ops',
+  guard: 'migration-safety',
+};

package/src/guards.ts

@@ -0,0 +1,186 @@
+// An app's own convention, made into a build error (axiom 3). A file in `guards/` exports one
+// `guard`; the gate discovers the directory and runs each one inside the `boundaries` step. The
+// framework decides what a guard IS — a function returning findings, held to the error contract —
+// and nothing about what a guard may check.
+
+// Bun ships no equivalent for either: `existsSync` answers whether this app has a guards
+// directory, `join` builds the host-separator path, and `pathToFileURL` is the only spelling of an
+// absolute path `import()` accepts on every host.
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { renderCauseValue, renderThrowable } from '@ultimat3/core';
+import { fixProblem } from './error-contract';
+import type { Finding } from './output';
+import type { HostCheck } from './verify-step';
+
+/** The directory IS the registration. An app-side list is a list an app can forget to add to. */
+export const GUARD_DIR = 'guards';
+
+export interface Guard {
+  /** What this app refuses, in one line. It names the rule when the guard itself is the problem. */
+  readonly summary: string;
+  /**
+   * The rule, over the app root. Returns findings — it never prints, never decides an exit code
+   * and never throws for a normal result, because `--json`, the step table and the exit code are
+   * all projections of what it returns (axiom 2).
+   */
+  check(root: string): Promise<readonly Finding[]> | readonly Finding[];
+}
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === 'object' && value !== null;
+
+const isGuard = (value: unknown): value is Guard =>
+  isRecord(value) &&
+  typeof value['summary'] === 'string' &&
+  value['summary'].trim() !== '' &&
+  typeof value['check'] === 'function';
+
+const CODE = /^X_[A-Z0-9_]+$/;
+
+/**
+ * A value named in a cause, without ever throwing to name it — the one thing this validator may
+ * never do is fail while it is explaining a failure, because then a bug in an app's guard reaches
+ * its author as a stack trace out of framework internals. The rendering itself is
+ * `@ultimat3/core`'s `renderCauseValue`: the local copy this used to hold called `String(value)` on
+ * an unnarrowed `unknown`, so a guard returning an object with a throwing `toString` destroyed the
+ * refusal — the case a scan over `String(` cannot see, because the call is one helper away.
+ * The `typeof` prefix stays: "object null" and "number 42" say what a bare literal does not.
+ */
+const shown = (value: unknown): string =>
+  typeof value === 'string' ? `"${value}"` : `${typeof value} ${renderCauseValue(value)}`;
+
+/**
+ * Why a returned value is not a finding, or `undefined` when it is one. The `fix:` half is
+ * `fixProblem` — the identical rule `x verify`'s `errors` step applies to every shipped `fix:` in
+ * the framework — because a mechanism for producing errors that are not instructions is worse than
+ * no mechanism. It runs on the returned value rather than on the source, which is the half a
+ * static scan cannot reach: a `fix` assembled at run time has no literal to read.
+ */
+export function findingProblem(value: unknown): string | undefined {
+  if (!isRecord(value)) return `${shown(value)} is not a finding object`;
+  const code = value['code'];
+  if (typeof code !== 'string' || !CODE.test(code)) {
+    return `${shown(code)} is not an X_SCREAMING_SNAKE code, so nothing can explain it`;
+  }
+  const cause = value['cause'];
+  if (typeof cause !== 'string' || cause.trim() === '') return `${code} states no cause`;
+  const fix = value['fix'];
+  if (typeof fix !== 'string') return `${code} carries no fix line`;
+  return fixProblem(fix);
+}
+
+/** Only what a finding may carry, so a guard cannot smuggle fields the renderers never show. */
+function findingOf(value: Record<string, unknown>, at: string): Finding {
+  const docs = value['docs'];
+  const located = value['at'];
+  return {
+    code: value['code'] as string,
+    cause: value['cause'] as string,
+    fix: value['fix'] as string,
+    ...(typeof docs === 'string' ? { docs } : {}),
+    at: typeof located === 'string' && located !== '' ? located : at,
+  };
+}
+
+/**
+ * Every guard file, app-root-relative and sorted, so two machines report the same findings in the
+ * same order. A `*.test.ts` beside a guard is its test, never a second guard — the generator emits
+ * one, and importing it would run the suite inside the gate.
+ */
+export async function guardPaths(root: string): Promise<readonly string[]> {
+  const dir = join(root, GUARD_DIR);
+  if (!existsSync(dir)) return [];
+  const paths: string[] = [];
+  for await (const entry of new Bun.Glob('*.{ts,tsx}').scan({ cwd: dir, absolute: false })) {
+    const path = entry.split('\\').join('/');
+    if (/\.(?:test|d)\.tsx?$/.test(path)) continue;
+    paths.push(`${GUARD_DIR}/${path}`);
+  }
+  return paths.sort();
+}
+
+const failed = (path: string, cause: string): Finding => ({
+  code: 'X_GUARD_FAILED',
+  cause,
+  fix: `return a finding from ${path} instead of throwing, then: x verify`,
+  docs: 'https://ultimate.dev/errors/X_GUARD_FAILED',
+  at: path,
+});
+
+const invalid = (path: string, cause: string): Finding => ({
+  code: 'X_GUARD_INVALID',
+  cause,
+  fix: `export a \`guard\` object — { summary, check } — from ${path}, then: x verify`,
+  docs: 'https://ultimate.dev/errors/X_GUARD_INVALID',
+  at: path,
+});
+
+const findingInvalid = (path: string, cause: string): Finding => ({
+  code: 'X_GUARD_FINDING_INVALID',
+  cause: `${path} returned a finding that is not one: ${cause}`,
+  fix: `rewrite what ${path} returns as a code, a cause and a fix naming a command or a file, then: x verify`,
+  docs: 'https://ultimate.dev/errors/X_GUARD_FINDING_INVALID',
+  at: path,
+});
+
+/** Same reason as `shown`: an app's guard may throw a value that fights every way of reading it. */
+const messageOf = (error: unknown): string => renderThrowable(error);
+
+/** One guard: import it, run it, and hold what it returns to the contract. Never throws. */
+async function runGuard(root: string, path: string): Promise<readonly Finding[]> {
+  let loaded: unknown;
+  try {
+    loaded = await import(pathToFileURL(join(root, path)).href);
+  } catch (error) {
+    return [failed(path, `${path} could not be imported: ${messageOf(error)}`)];
+  }
+  const exported = isRecord(loaded) ? loaded['guard'] : undefined;
+  if (!isGuard(exported)) {
+    return [
+      invalid(
+        path,
+        exported === undefined
+          ? `${path} exports no \`guard\`, so a file in ${GUARD_DIR}/ enforces nothing`
+          : `${path} exports a \`guard\` with no summary and no check()`,
+      ),
+    ];
+  }
+  let returned: unknown;
+  try {
+    returned = await exported.check(root);
+  } catch (error) {
+    return [failed(path, `${path} ("${exported.summary}") threw: ${messageOf(error)}`)];
+  }
+  if (!Array.isArray(returned)) {
+    return [findingInvalid(path, `check() answered ${typeof returned}, not a list of findings`)];
+  }
+  const findings: Finding[] = [];
+  for (const candidate of returned as readonly unknown[]) {
+    // Reading a candidate can throw on its own — a getter that raises, a proxy that refuses — and
+    // `findingProblem` is total only for values it can read. Per candidate, so one unreadable
+    // entry costs its own line and not the readable findings beside it.
+    try {
+      const problem = findingProblem(candidate);
+      if (problem !== undefined) findings.push(findingInvalid(path, problem));
+      else findings.push(findingOf(candidate as Record<string, unknown>, path));
+    } catch (error) {
+      findings.push(findingInvalid(path, `it could not be read: ${messageOf(error)}`));
+    }
+  }
+  return findings;
+}
+
+/**
+ * Every guard this app declares, as findings the step it rides on adds to its own. Typed as a
+ * `HostCheck` because that is exactly the seam's shape — a rule the repo enforces on itself,
+ * contributed to a step that already exists. A guard can never add, remove, reorder or skip a
+ * step, which is what keeps "green" meaning one thing (axiom 5) while the app still gets to make
+ * its own convention a build error.
+ */
+export const guardFindings: HostCheck = async (root) => {
+  const findings: Finding[] = [];
+  for (const path of await guardPaths(root)) findings.push(...(await runGuard(root, path)));
+  return findings;
+};

package/src/index.ts

@@ -2,6 +2,8 @@
 // on these, and a barrel that re-exports everything would make every internal a compatibility
 // promise.
 
+/** The app's own API over HTTP — the one table `x dev` and a container both mount. */
+export { apiRoutes } from './api-routes';
 export type { BoundaryCode, SourceFile } from './app-boundaries';
 export {
   appImportGraph,
@@ -32,7 +34,8 @@ export {
   readTarget,
   requireEntry,
 } from './cmd-build';
-export { branchDatabaseName, branchSql, dbCommand, previewUrl } from './cmd-db';
+export { dbCommand } from './cmd-db';
+export { runBranchCommand } from './cmd-db-branch';
 export type { DeployPlan } from './cmd-deploy';
 export { deployCommand, planDeploy } from './cmd-deploy';
 export type { DevServer, StartDevOptions } from './cmd-dev';
@@ -50,14 +53,30 @@ export type { McpHttpServer } from './cmd-mcp';
 export { mcpCommand, startMcpHttp } from './cmd-mcp';
 export type { NewAppOptions, WrittenApp } from './cmd-new';
 export { newCommand, planNewApp, writeNewApp } from './cmd-new';
-export type { PlannedCommand } from './cmd-planned';
-export { PLANNED_COMMANDS, plannedCommands } from './cmd-planned';
+export type { PlannedCommand, PlannedSubcommand } from './cmd-planned';
+export {
+  PLANNED_COMMANDS,
+  PLANNED_SUBCOMMANDS,
+  plannedCommands,
+  plannedSubcommand,
+} from './cmd-planned';
 export { actionsCommand, entitiesCommand, queriesCommand } from './cmd-registries';
 export { renderRouteTable, routesCommand } from './cmd-routes';
-export { availableCpus, testCommand } from './cmd-test';
+export { testCommand } from './cmd-test';
 export { runVerify, VERIFY_STEPS, verifyCommand, verifyStepNames } from './cmd-verify';
 export type { CliCommand, CommandContext } from './command';
 export { failed, ok } from './command';
+export type { BranchRow, BranchSubcommand } from './db-branch';
+export {
+  BRANCH_SUBCOMMANDS,
+  branchDatabaseName,
+  branchNameOf,
+  isBranchSubcommand,
+  pgliteBranchName,
+  previewUrl,
+} from './db-branch';
+export type { GeneratedFiles, GenerateMigrationOptions } from './db-generate';
+export { generateAppMigration, migrationSql } from './db-generate';
 export type { AssetRoutesOptions } from './dev-assets';
 export {
   assetRoutes,
@@ -80,7 +99,8 @@ export type { DevServices, ServiceBinding } from './dev-services';
 export { describeServices, resolveServices } from './dev-services';
 export type { DispatchOptions } from './dispatch';
 export { dispatch } from './dispatch';
-export { checkDrift, recordedHashes, schemaHash, writeSchemaHash } from './drift';
+export type { DeclaredEntityCount } from './drift';
+export { checkSourceDrift, recordedHashes, schemaHash, writeSchemaHash } from './drift';
 export type { ErrorCatalog } from './error-catalog';
 export {
   buildErrorCatalog,
@@ -89,6 +109,8 @@ export {
   registeredErrorCodes,
   resetErrorCatalog,
 } from './error-catalog';
+export type { CliErrorCode } from './error-codes';
+export { CLI_ERROR_CODES, CLI_ERROR_TITLES } from './error-codes';
 export {
   BANNED_PHRASES,
   COMMAND_TOKENS,
@@ -102,19 +124,26 @@ export {
   RESERVED_HEADING,
   staticFix,
 } from './error-contract';
-export type { CliErrorCode } from './errors';
+export type { CodeFixIndex, CodeFixScan } from './error-fixes';
+export {
+  codeFixes,
+  codeFixScan,
+  loadCodeFixes,
+  resetCodeFixes,
+  scanScopeFixes,
+} from './error-fixes';
 export {
   BadFlagError,
   BuildEntryMissingError,
   BunVersionError,
   CatalogExistsError,
-  CLI_ERROR_CODES,
-  CLI_ERROR_TITLES,
   CliNotImplementedError,
   DeclarationUnknownError,
   ErrorCodeUnknownError,
   FixTargetUnknownError,
   JobUnknownError,
+  MissingPositionalError,
+  MissingSubcommandError,
   NoTestFilesError,
   NotInAppError,
   PortInvalidError,
@@ -124,6 +153,16 @@ export {
 } from './errors';
 export type { ExecOptions, ExecResult, Runner } from './exec';
 export { exec, execOutput } from './exec';
+export type { CitationFault, CitationRules, CommandCatalog, FixCitation } from './fix-command';
+export {
+  citationFault,
+  citationProblem,
+  citedCommandProblem,
+  fixCitations,
+  loadCommandCatalog,
+} from './fix-command';
+export type { Guard } from './guards';
+export { findingProblem, GUARD_DIR, guardFindings, guardPaths } from './guards';
 export type { DrainFailure, DrainOutcome, DrainSkip } from './jobs-drain';
 export { drainJobs } from './jobs-drain';
 export type { JobsListFilter, JobsListResult } from './jobs-report';
@@ -132,7 +171,16 @@ export { renderJobTable } from './jobs-table';
 export type { CliMcpServer, DevHostInput } from './mcp-host';
 export { createDevMcpServer, DEV_TOOL_SCOPES, localCaller } from './mcp-host';
 export { messageKeys, msg } from './messages';
-export { MIGRATIONS_DIR, migrationName, parseMigrationSql, readMigrations } from './migrations';
+export type { MetricsEndpoint, MetricsEndpointOptions } from './metrics-endpoint';
+export { DEFAULT_METRICS_PORT, startMetricsEndpoint } from './metrics-endpoint';
+export {
+  hashFileName,
+  MIGRATIONS_DIR,
+  migrationName,
+  parseMigrationSql,
+  readMigrations,
+  snapshotFileName,
+} from './migrations';
 export type { CommandResult, Finding, JsonValue, StepResult } from './output';
 export {
   exitCodeFor,
@@ -146,13 +194,19 @@ export {
 } from './output';
 export type { CommandSpec, FlagSpec, ParsedArgs } from './parse';
 export { flagBool, flagList, flagString, GLOBAL_FLAGS, nearest, parseArgs } from './parse';
-export type { PrerenderedPage, PrerenderOptions, PrerenderReport } from './prerender';
+export type {
+  PrerenderedPage,
+  PrerenderOptions,
+  PrerenderReport,
+  UnmeasuredRoute,
+} from './prerender';
 export { DEFAULT_ORIGIN, isPrerenderable, prerenderSite } from './prerender';
-export { CLI_VERSION, COMMANDS, commandFor, SPECS } from './registry';
+export { COMMANDS, cliVersion, commandFor, SPECS } from './registry';
 export type { MigratedApp, ServedApp, ServeOptions, StartedApp } from './serve';
 export {
   CONTAINER_BINDING,
   DEFAULT_PORT,
+  metricsPortFromEnv,
   portFromEnv,
   roleFromEnv,
   runMigrations,
@@ -166,19 +220,36 @@ export {
   isVendored,
   SOURCE_GLOBS,
 } from './source-files';
+export type { TestCounts } from './test-counts';
+export { countsOf } from './test-counts';
 export type { TestFile } from './test-select';
 export { belongsToType, discoverTests, sampleFiles } from './test-select';
 export type { ReproduceOptions, RunShardsOptions, Shard } from './test-shards';
 export { planShards, quoteArg, reproduceFor, runShards, shardArgs } from './test-shards';
-export type { CodeSite, FixSite, SourceSite } from './ts-scan';
+export { availableCpus, defaultWorkers, WORKER_CEILING } from './test-workers';
+export type { CodeFixSite, CodeSite, FixSite, SourceSite } from './ts-scan';
 export {
   isCodeRegistry,
   maskLiterals,
   scanBorrowedCodes,
+  scanCodeFixSites,
   scanCodes,
   scanFixes,
   stripComments,
 } from './ts-scan';
+// The one spelling rule for a `references` entry. Exported because the two gate scripts ask the
+// same question this package's `package-shape` step does, and three answers is a duplicate entry.
+export { normalizeReferencePath } from './tsconfig-references';
+export type { VerifyFloor } from './verify-floor';
+export {
+  floorProblemFindings,
+  floorRequires,
+  parseVerifyFloor,
+  readVerifyFloor,
+  skippedSuiteFinding,
+  VERIFY_FLOOR_FILE,
+  vanishedSuiteFinding,
+} from './verify-floor';
 export type {
   HostCheck,
   StepOutcome,
@@ -188,8 +259,8 @@ export type {
 } from './verify-step';
 export { VERIFY_STEP_NAMES } from './verify-step';
 export type { TestType } from './verify-tests';
-export { TEST_STEPS, TEST_TYPES, testStepCommand, typeFilterOf } from './verify-tests';
-export type { ManifestFacts } from './workspace-checks';
+export { TEST_STEPS, TEST_TYPES, testStepCommand, typeFiltersOf } from './verify-tests';
+export type { ManifestFacts, PackageShapeOptions } from './workspace-checks';
 export {
   checkFileSizes,
   checkLockstep,
@@ -198,5 +269,7 @@ export {
   hasWorkspacePackages,
   LINE_CEILING,
   PACKAGE_FILES,
+  SEMVER,
   workspacePackages,
 } from './workspace-checks';
+export { writeLine } from './write-line';