@nifrajs/cli 2.11.0 → 2.12.1

package/src/cli.ts

@@ -12,11 +12,16 @@
 import { existsSync } from "node:fs"
 import { resolve } from "node:path"
 import { inProcessClient } from "@nifrajs/client"
-import { createWebApp, DEFAULT_DEV_PORT, type RenderAdapter } from "@nifrajs/web"
+import {
+  type CreateWebAppOptions,
+  createWebApp,
+  DEFAULT_DEV_PORT,
+  type RenderAdapter,
+} from "@nifrajs/web"
 import { discoverRoutes } from "@nifrajs/web/fs"
 import type { BunPlugin } from "bun"
 import { describeProject, describeRouteGraph, describeRoutes } from "./introspect.ts"
-import { type LoadedApp, loadApp } from "./load.ts"
+import { type LoadedApp, loadApp, type NifraFramework } from "./load.ts"
 import { chooseBuildPipeline, describePipeline } from "./pipeline-guard.ts"
 
 export interface Flags {
@@ -82,8 +87,11 @@ Usage:
                                          and a "## MCP server" section in AGENTS.md. No-clobber by
                                          default (skips a file you've customized); --force overwrites the
                                          owned files. AGENTS.md is only appended to, never overwritten.
-  nifra mcp                              Start an MCP server (stdio) exposing this project to a coding
-                                         agent: nifra_context, nifra_routes (routes+schemas as JSON),
+  nifra mcp [dir]                        Start an MCP server (stdio) exposing this project to a coding
+                                         agent. The project root is [dir] when given, else resolved from
+                                         cwd (marker walk-up + the client's MCP roots); tools refuse
+                                         with a fix when no nifra project is found - never a silent
+                                         wrong-project answer. Tools: nifra_context, nifra_routes,
                                          nifra_run (backend), nifra_render (SSR a page), nifra_docs,
                                          nifra_example (verified snippets), nifra_scaffold (route→file),
                                          nifra_check (drift gate + fixes), nifra_levels (verification
@@ -96,6 +104,8 @@ Usage:
   nifra check   [--json] [--lints-only]  Gate: typecheck + lints (hand-rolled fetch(), untyped client("…"),
                                          server-only imports in routes/). Run as "done"; --json for agents;
                                          --lints-only skips tsc for a near-instant inner-loop pass.
+  nifra fix     [--code <NF-code>]       Apply a registered diagnostic recipe, then print the remaining
+                                         structured diagnostics.
   nifra sync-manifest                    Regenerate a committed web server-manifest.ts from routes/ WITHOUT
                                          a full build - clears server-manifest drift after a route add/rename
                                          (a new hydrating component still needs a full build).
@@ -111,9 +121,14 @@ Usage:
                                          closed. Exits non-zero on any breaking change - run it in CI.
   nifra sdk     --lang <python|go> [--out <file>]
                                          Generate a deterministic non-TypeScript SDK from backend.ts.
-  nifra assure  [--config <file>] [--json]  Route-assurance gate: load nifra.assurance.ts, classify every
-                                         reflected backend route, and fail when required enforcement
-                                         evidence is missing/forbidden or a route is unclassified.
+  nifra assure  [--config <file>] [--json] [--strict] [--out <file>] [--hydration] [--interact]
+                                         Emit one structured assurance bundle. The bundle records every
+                                         applicable gate as pass, fail, or skip and exits non-zero unless
+                                         its verdict is green. Without these bundle flags, the legacy
+                                         route-assurance report remains available.
+  nifra contracts snapshot [--out <file>] Write the deterministic route contract lock.
+  nifra contracts check [--json]          Check the current routes against contracts.lock.json.
+  nifra replay <file>                     Replay a token-only verification metadata file.
   nifra capabilities snapshot [--out <file>] [--config <file>]
                                          Write the deterministic, token-only capability lockfile, but
                                          only after provenance + idempotency assurance passes.
@@ -130,9 +145,15 @@ Usage:
                                          Compute the verification ladder (L0 typed contract → L1 route
                                          assurance → L2 capability lockfile → L3 route manifest → L4
                                          invariant-tested); --min <n> fails the exit code below level n.
+  nifra prove    [--json] [--file <path>] [--min <n>]
+                                         Build the static verification work graph, plan the cheapest
+                                         proofs for changed files, and report a machine-checkable stop
+                                         condition. Requires a fresh build; never probes a running app.
   nifra doctor  [--json] [--auto-fix]    Flag undeclared imports and multiple physical copies of
-                                         @nifrajs/core/React identity-sensitive dependencies;
-                                         --auto-fix writes safe local-version dependency fixes.
+                [--strict] [--target]     @nifrajs/core/React identity-sensitive dependencies;
+                                         print production readiness, with --strict making absent
+                                         applicable guarantees fail. --auto-fix writes safe local-
+                                         version dependency fixes.
   nifra upgrade <version>                Run the per-release upgrade recipe for <version>: sweep every
                 [--write] [--no-verify]  matching dependency pin (preserving ^/~/exact), move removed
                 [--list] [--json]        packages, apply exact imports, then verify with nifra check.
@@ -154,11 +175,13 @@ Port: \`dev\` and \`start\` share the default ${DEFAULT_DEV_PORT}. Override with
 \`PORT\` env var (\`--port\` wins over \`PORT\`, which wins over the default).`
 
 // Kept in lockstep with packages/cli/package.json by check:publish's version-consistency gate.
-const CLI_VERSION = "2.11.0"
+const CLI_VERSION = "2.12.1"
 
 // A render adapter + nifra server are opaque to the CLI (it just forwards them); cast at the seam.
 const asAdapter = (v: unknown): RenderAdapter => v as RenderAdapter
 const asBunPlugins = (v: readonly unknown[]): BunPlugin[] => v as BunPlugin[]
+const asUse = (v: (app: never) => void): NonNullable<CreateWebAppOptions["use"]> =>
+  v as NonNullable<CreateWebAppOptions["use"]>
 const apiOf = (backend: unknown): { api?: unknown } =>
   backend === undefined ? {} : { api: inProcessClient(backend as never) }
 
@@ -314,6 +337,7 @@ async function dev(app: LoadedApp, flags: Flags): Promise<void> {
           adapter: asAdapter(fw.adapter),
           manifest: discoverRoutes(routesDir, { importQuery }),
           clientEntry,
+          ...(fw.use ? { use: asUse(fw.use) } : {}),
           ...apiOf(backend),
         }),
     })
@@ -373,6 +397,7 @@ async function dev(app: LoadedApp, flags: Flags): Promise<void> {
         adapter: asAdapter(fw.adapter),
         manifest: discoverRoutes(routesDir, { load }),
         clientEntry,
+        ...(fw.use ? { use: asUse(fw.use) } : {}),
         ...apiOf(backend),
       }),
   })
@@ -387,6 +412,37 @@ async function dev(app: LoadedApp, flags: Flags): Promise<void> {
  * `nifra.config.ts`, which pulls in Vite plugins), and the backend from `backend.ts` when present;
  * `buildTarget` generates the per-target server entry from those + the app's `routes/`.
  */
+/**
+ * Refuse a `use` the generated server entry cannot import.
+ *
+ * `nifra build` emits `import { use } from <frameworkFile>` (framework.ts, the edge-bundlable file),
+ * but `loadApp` prefers `nifra.config.ts` - so an app with BOTH files whose `use` lives only in
+ * `nifra.config.ts` makes `fw.use` defined while `framework.ts` exports nothing of that name, and the
+ * build dies later with an opaque bundler error pointing at generated code. Refuse it here with the
+ * exact move instead, in the spirit of `assertPipelineSeparation` (load.ts).
+ *
+ * Detected by importing `frameworkFile` and checking the named export, not by comparing paths alone:
+ * a split app legitimately DEFINES `use` in framework.ts and re-exports it from nifra.config.ts
+ * (exactly how `adapter` reaches both readers), and a path compare would refuse that correct layout.
+ * The import is cheap - framework.ts is already in the loaded config's module graph in that layout.
+ */
+export async function assertUseIsEdgeExported(
+  use: NifraFramework["use"],
+  configPath: string,
+  frameworkFile: string,
+): Promise<void> {
+  if (use === undefined || configPath === frameworkFile) return
+  const mod = (await import(frameworkFile).catch(() => ({}))) as { use?: unknown }
+  if (typeof mod.use === "function") return
+  throw new Error(
+    `[nifra] \`use\` is exported from ${configPath} but not from ${frameworkFile}. ` +
+      "`nifra build` generates a server entry that imports `use` from framework.ts (the edge-bundled " +
+      "file), so this build would fail later with an opaque bundler error inside generated code.\n\n" +
+      "  - Define `use` in framework.ts and re-export it from nifra.config.ts " +
+      '(`export { use } from "./framework.ts"`) so `nifra dev` sees it too.',
+  )
+}
+
 async function buildForTarget(app: LoadedApp, target: string, flags: Flags): Promise<void> {
   const { isBuildTarget, renderSizeReport, BUILD_TARGETS } = await import("@nifrajs/web/build")
   if (!isBuildTarget(target)) {
@@ -418,6 +474,7 @@ async function buildForTarget(app: LoadedApp, target: string, flags: Flags): Pro
       ? resolve(cwd, "nifra.config.ts")
       : resolve(cwd, "framework.ts")
   const backendFile = resolve(cwd, "backend.ts")
+  await assertUseIsEdgeExported(fw.use, app.configPath, frameworkFile)
   // Plugin FORMAT differs by pipeline: the Bun build takes Bun plugins (clientPlugins/serverPlugins); the
   // Vite build takes the app's Vite plugins (fw.vitePlugins) for BOTH halves. buildTargetWith forwards
   // whatever it's given straight to the chosen bundler, which casts to its own plugin type.
@@ -436,6 +493,7 @@ async function buildForTarget(app: LoadedApp, target: string, flags: Flags): Pro
     workDir: resolve(cwd, ".nifra-build"),
     clientModule: fw.clientModule,
     adapterImport: frameworkFile,
+    ...(fw.use ? { useImport: frameworkFile } : {}),
     ...(backend !== undefined && existsSync(backendFile) ? { backendImport: backendFile } : {}),
     ...plugins,
     ...(fw.conditions ? { conditions: fw.conditions } : {}),
@@ -469,6 +527,7 @@ async function buildPrerenderApp(
       adapter: asAdapter(fw.adapter),
       manifest: discoverRoutes(routesDir),
       clientEntry: client.entry,
+      ...(fw.use ? { use: asUse(fw.use) } : {}),
       ...(client.routes ? { routePreload: client.routes } : {}),
       ...(client.css ? { styles: client.css } : {}),
       ...(client.routeStyles ? { routeStyles: client.routeStyles } : {}),
@@ -545,7 +604,10 @@ async function main(): Promise<void> {
   // the eager `loadApp` below (which would fail fast on a project that's API-only / not yet built).
   if (command === "mcp") {
     const { runMcpServer } = await import("./mcp.ts")
-    await runMcpServer(process.cwd(), CLI_VERSION)
+    // `nifra mcp [dir]` - an explicit project directory pins the root (for clients configured outside
+    // the project); otherwise the server resolves it from cwd + the client's MCP roots.
+    const dirArg = argv[1] !== undefined && !argv[1].startsWith("-") ? argv[1] : undefined
+    await runMcpServer(process.cwd(), CLI_VERSION, dirArg)
     return
   }
   // `docs-mcp` runs the PUBLIC docs MCP over HTTP - project-independent (serves the bundled corpus), so
@@ -580,12 +642,36 @@ async function main(): Promise<void> {
     if (
       !(await runCheck(process.cwd(), {
         json: argv.includes("--json"),
+        structured: argv.includes("--json"),
         lintsOnly: argv.includes("--lints-only"),
       }))
     )
       process.exitCode = 1
     return
   }
+  if (command === "fix") {
+    const codeIndex = argv.indexOf("--code")
+    const code = codeIndex === -1 ? undefined : argv[codeIndex + 1]
+    try {
+      const { collectCheckResult } = await import("./check.ts")
+      const { applyDiagnosticRecipe } = await import("./fix-recipes.ts")
+      const result = await collectCheckResult(process.cwd(), { lintsOnly: true })
+      const changed: string[] = []
+      for (const diagnostic of result.structuredDiagnostics ?? []) {
+        if (code !== undefined && diagnostic.code !== code) continue
+        changed.push(...(await applyDiagnosticRecipe(process.cwd(), diagnostic)))
+      }
+      const final = await collectCheckResult(process.cwd(), { lintsOnly: true })
+      console.log(
+        JSON.stringify({ changed, diagnostics: final.structuredDiagnostics ?? [] }, null, 2),
+      )
+      if (final.ok === false) process.exitCode = 1
+    } catch (err) {
+      console.error(formatCliError(err))
+      process.exitCode = 1
+    }
+    return
+  }
   // `init-agents` retrofits the agent-discovery files (.mcp.json, CLAUDE.md, …) into the cwd. It's a
   // pure file-writing command independent of the app loading, so dispatch it before the eager `loadApp`
   // (an existing app might be API-only or not yet built). It always succeeds unless a write throws.
@@ -616,10 +702,19 @@ async function main(): Promise<void> {
   // so it runs on an API-only / not-yet-built project.
   if (command === "doctor") {
     const { runDoctor } = await import("./doctor.ts")
+    const targetIdx = argv.indexOf("--target")
+    const target = targetIdx !== -1 ? argv[targetIdx + 1] : undefined
+    if (targetIdx !== -1 && (target === undefined || target.startsWith("-"))) {
+      console.error("[nifra] --target needs a value: bun | node | deno | cf-pages | vercel")
+      process.exitCode = 1
+      return
+    }
     if (
       !(await runDoctor(process.cwd(), {
         json: argv.includes("--json"),
         autoFix: argv.includes("--auto-fix") || argv.includes("--fix"),
+        strict: argv.includes("--strict"),
+        ...(target === undefined ? {} : { target }),
       }))
     )
       process.exitCode = 1
@@ -696,6 +791,16 @@ async function main(): Promise<void> {
       if (
         !(await runAssurance(process.cwd(), {
           json: argv.includes("--json"),
+          bundle:
+            argv.includes("--json") ||
+            argv.includes("--strict") ||
+            argv.includes("--hydration") ||
+            argv.includes("--interact") ||
+            argv.includes("--out"),
+          strict: argv.includes("--strict"),
+          hydration: argv.includes("--hydration"),
+          interact: argv.includes("--interact"),
+          ...(argv.includes("--out") ? { out: argv[argv.indexOf("--out") + 1] } : {}),
           ...(config !== undefined ? { config } : {}),
         }))
       )
@@ -706,6 +811,49 @@ async function main(): Promise<void> {
     }
     return
   }
+  if (command === "contracts") {
+    const action = argv[1]
+    const outIndex = argv.indexOf("--out")
+    const out = outIndex === -1 ? undefined : argv[outIndex + 1]
+    try {
+      const { checkContractsLock, snapshotContracts } = await import("./contracts.ts")
+      if (action === "snapshot") {
+        const lock = await snapshotContracts(process.cwd(), out)
+        if (argv.includes("--json")) console.log(JSON.stringify(lock, null, 2))
+        else console.log(`[nifra] wrote ${Object.keys(lock.routes).length} contract digests`)
+      } else if (action === "check") {
+        const result = await checkContractsLock(process.cwd())
+        const output = { ok: result.present && result.diagnostics.length === 0, ...result }
+        console.log(JSON.stringify(output, null, 2))
+        if (!output.ok) process.exitCode = 1
+      } else {
+        console.error("[nifra] contracts needs snapshot or check")
+        process.exitCode = 1
+      }
+    } catch (err) {
+      console.error(formatCliError(err))
+      process.exitCode = 1
+    }
+    return
+  }
+  if (command === "replay") {
+    const file = argv[1]
+    if (file === undefined || file.startsWith("-")) {
+      console.error("[nifra] replay needs a file path")
+      process.exitCode = 1
+      return
+    }
+    try {
+      const { runReplay } = await import("./replay.ts")
+      const result = await runReplay(process.cwd(), file)
+      console.log(JSON.stringify(result, null, 2))
+      if (!result.ok) process.exitCode = 1
+    } catch (err) {
+      console.error(formatCliError(err))
+      process.exitCode = 1
+    }
+    return
+  }
   if (command === "capabilities") {
     const action = argv[1]
     const valueAfter = (flag: string): string | undefined => {
@@ -820,6 +968,45 @@ async function main(): Promise<void> {
     }
     return
   }
+  if (command === "prove") {
+    const valueAfter = (flag: string): string | undefined => {
+      const index = argv.indexOf(flag)
+      const value = index === -1 ? undefined : argv[index + 1]
+      if (index !== -1 && (value === undefined || value.startsWith("-"))) {
+        throw new Error(`[nifra] ${flag} needs a value`)
+      }
+      return value
+    }
+    try {
+      const minRaw = valueAfter("--min")
+      const min = minRaw === undefined ? undefined : Number(minRaw)
+      if (min !== undefined && (!Number.isInteger(min) || min < 0 || min > 4)) {
+        throw new Error("[nifra] --min must be an integer level between 0 and 4")
+      }
+      const changedFiles: string[] = []
+      for (let index = 0; index < argv.length; index++) {
+        if (argv[index] !== "--file") continue
+        const file = argv[index + 1]
+        if (file === undefined || file.startsWith("-"))
+          throw new Error("[nifra] --file needs a path")
+        changedFiles.push(file)
+        index++
+      }
+      const { runWorkGraph } = await import("./work-graph.ts")
+      if (
+        !(await runWorkGraph(process.cwd(), {
+          json: argv.includes("--json"),
+          ...(changedFiles.length === 0 ? {} : { changedFiles }),
+          ...(min === undefined ? {} : { minLevel: min }),
+        }))
+      )
+        process.exitCode = 1
+    } catch (err) {
+      console.error(formatCliError(err))
+      process.exitCode = 1
+    }
+    return
+  }
   // `upgrade` is a pure cwd file-transformer (package.json pins + import moves) driven by a per-release
   // recipe, then verified with `nifra check`. Dispatch before the eager `loadApp` - it must run on any
   // repo (API-only, not built, or mid-upgrade with edits that don't yet typecheck under dry-run).

package/src/contract-proof.ts

@@ -0,0 +1,194 @@
+import { existsSync, realpathSync } from "node:fs"
+import { resolve, sep } from "node:path"
+import type { AssuranceFinding, AssuranceReport, AssuredRoute } from "@nifrajs/core/assurance"
+import type {
+  AssuredCapabilityRoute,
+  CapabilityAssuranceReport,
+  CapabilityFinding,
+} from "@nifrajs/core/capabilities"
+import { diffRouteSnapshots, type RouteChange, type RoutesDiff } from "@nifrajs/core/diff"
+import type { CheckResult } from "./check.ts"
+import { DEFAULT_SNAPSHOT_FILE, parseSnapshotFile, snapshotBackend } from "./diff-tool.ts"
+import { collectProjectVerification } from "./verification.ts"
+
+const routeKey = (method: string, path: string): string => `${method.toUpperCase()}\n${path}`
+
+export interface ContractProofRoute {
+  readonly method: string
+  readonly path: string
+  readonly changes: readonly RouteChange[]
+  readonly assurance?: {
+    readonly route?: AssuredRoute
+    readonly findings: readonly AssuranceFinding[]
+  }
+  readonly capability?: {
+    readonly route?: AssuredCapabilityRoute
+    readonly findings: readonly CapabilityFinding[]
+  }
+}
+
+export interface ContractProofVerification {
+  readonly assuranceConfigPresent: boolean
+  readonly configError?: string
+  readonly assurance?: {
+    readonly ok: boolean
+    readonly routeCount: number
+    readonly findings: readonly AssuranceFinding[]
+  }
+  readonly capability?: {
+    readonly ok: boolean
+    readonly routeCount: number
+    readonly findings: readonly CapabilityFinding[]
+  }
+  readonly check?: CheckResult
+}
+
+export interface ContractProofReport {
+  readonly baseline: string
+  readonly hasBreaking: boolean
+  readonly changes: readonly RouteChange[]
+  readonly routes: readonly ContractProofRoute[]
+  readonly verification: ContractProofVerification
+}
+
+export interface ContractProofOptions {
+  /** Baseline path relative to the project directory. Defaults to api-snapshot.json. */
+  readonly baselinePath?: string
+  /** Run the lazy typed-contract check only when explicitly requested. */
+  readonly check?: boolean
+  readonly signal?: AbortSignal
+}
+
+function safeBaselinePath(cwd: string, baselinePath: string): string {
+  const root = resolve(cwd)
+  const target = resolve(root, baselinePath)
+  if (target !== root && !target.startsWith(`${root}${sep}`)) {
+    throw new Error("contract proof baseline must stay inside the project directory")
+  }
+  return target
+}
+
+function errorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : String(error)
+}
+
+function changedRoutes(
+  diff: RoutesDiff,
+  assurance: AssuranceReport | undefined,
+  capability: CapabilityAssuranceReport | undefined,
+): readonly ContractProofRoute[] {
+  const changes = new Map<string, RouteChange[]>()
+  for (const change of diff.changes) {
+    const key = routeKey(change.method, change.path)
+    const current = changes.get(key)
+    if (current === undefined) changes.set(key, [change])
+    else current.push(change)
+  }
+
+  const assured = new Map(
+    (assurance?.routes ?? []).map((route) => [routeKey(route.method, route.path), route]),
+  )
+  const assuranceFindings = new Map<string, AssuranceFinding[]>()
+  for (const finding of assurance?.findings ?? []) {
+    const key = routeKey(finding.method, finding.path)
+    const current = assuranceFindings.get(key)
+    if (current === undefined) assuranceFindings.set(key, [finding])
+    else current.push(finding)
+  }
+
+  const capable = new Map(
+    (capability?.routes ?? []).map((route) => [routeKey(route.method, route.path), route]),
+  )
+  const capabilityFindings = new Map<string, CapabilityFinding[]>()
+  for (const finding of capability?.findings ?? []) {
+    const key = routeKey(finding.method, finding.path)
+    const current = capabilityFindings.get(key)
+    if (current === undefined) capabilityFindings.set(key, [finding])
+    else current.push(finding)
+  }
+
+  return Object.freeze(
+    [...changes].map(([key, routeChanges]) => {
+      const first = routeChanges[0]
+      if (first === undefined) throw new Error("contract proof: missing route change")
+      const assuredRoute = assured.get(key)
+      const capableRoute = capable.get(key)
+      return {
+        method: first.method,
+        path: first.path,
+        changes: Object.freeze([...routeChanges]),
+        ...(assurance === undefined
+          ? {}
+          : {
+              assurance: {
+                ...(assuredRoute === undefined ? {} : { route: assuredRoute }),
+                findings: Object.freeze([...(assuranceFindings.get(key) ?? [])]),
+              },
+            }),
+        ...(capability === undefined
+          ? {}
+          : {
+              capability: {
+                ...(capableRoute === undefined ? {} : { route: capableRoute }),
+                findings: Object.freeze([...(capabilityFindings.get(key) ?? [])]),
+              },
+            }),
+      }
+    }),
+  )
+}
+
+/** Compose route diff, route assurance, capability evidence, and an optional check result. */
+export async function collectContractProof(
+  cwd: string,
+  options: ContractProofOptions = {},
+): Promise<ContractProofReport> {
+  const baselinePath = options.baselinePath ?? DEFAULT_SNAPSHOT_FILE
+  const resolvedBaseline = safeBaselinePath(cwd, baselinePath)
+  if (!existsSync(resolvedBaseline)) {
+    throw new Error(`contract proof baseline not found: ${resolvedBaseline}`)
+  }
+  const realRoot = realpathSync(resolve(cwd))
+  const realBaseline = realpathSync(resolvedBaseline)
+  if (realBaseline !== realRoot && !realBaseline.startsWith(`${realRoot}${sep}`)) {
+    throw new Error("contract proof baseline must stay inside the project directory")
+  }
+  const baseline = parseSnapshotFile(await Bun.file(resolvedBaseline).text(), baselinePath)
+  const current = await snapshotBackend(cwd)
+  const diff = diffRouteSnapshots(baseline.routes, current)
+  const verification = await collectProjectVerification(cwd, {
+    ...(options.signal === undefined ? {} : { signal: options.signal }),
+  })
+  const proof: ContractProofVerification = {
+    assuranceConfigPresent: verification.assuranceConfigPresent,
+    ...(verification.configError === undefined
+      ? {}
+      : { configError: errorMessage(verification.configError) }),
+    ...(verification.routeAssurance === undefined
+      ? {}
+      : {
+          assurance: {
+            ok: verification.routeAssurance.ok,
+            routeCount: verification.routeAssurance.routes.length,
+            findings: verification.routeAssurance.findings,
+          },
+        }),
+    ...(verification.capability === undefined
+      ? {}
+      : {
+          capability: {
+            ok: verification.capability.report.ok,
+            routeCount: verification.capability.report.routes.length,
+            findings: verification.capability.report.findings,
+          },
+        }),
+    ...(options.check === true ? { check: await verification.check() } : {}),
+  }
+  return Object.freeze({
+    baseline: baselinePath,
+    hasBreaking: diff.hasBreaking,
+    changes: diff.changes,
+    routes: changedRoutes(diff, verification.routeAssurance, verification.capability?.report),
+    verification: proof,
+  })
+}