@miroshnik/elves 0.0.0 → 2026.1018.0

package/skills/spec/scripts/knip-hints.cjs

@@ -0,0 +1,34 @@
+/**
+ * knip-hints — a knip reporter for the harness's `deadCode`: configuration hints (a redundant `ignore`, an `entry`
+ * without matches, a redundant workspace) as a JSON line
+ * `{ "configurationHints": [{ type, identifier, workspace, file? }] }`. knip's `json` reporter doesn't print them,
+ * and `--treat-config-hints-as-errors` gives only an exit code — the hints themselves aren't visible.
+ *
+ *   knip --reporter json --reporter .agents/skills/spec/scripts/knip-hints.cjs
+ *
+ * The second output line is its own: `deadCode` joins both. CommonJS, not TypeScript: the harness takes the file
+ * path (`report.file`) with a static import — `import.meta` in a module that Playwright and Jest load as CommonJS is
+ * a syntax error (tests/standards/harness-load); knip loads it under both Node and Bun. Types — `knip-hints.d.cts`.
+ */
+"use strict";
+
+const path = require("node:path");
+
+/**
+ * Hints as knip collected them (`ReporterOptions.configurationHints`): an identifier may be a regex (an `ignore`
+ * pattern), a file path is absolute; `--no-config-hints` — the project itself opted out of hints.
+ */
+function report(options) {
+  const hints = options.isDisableConfigHints
+    ? []
+    : options.configurationHints.map((h) => ({
+        type: h.type,
+        identifier: h.identifier instanceof RegExp ? h.identifier.source.replaceAll("\\/", "/") : String(h.identifier),
+        workspace: h.workspaceName ?? ".",
+        ...(h.filePath ? { file: path.relative(options.cwd, path.resolve(options.cwd, h.filePath)).split(path.sep).join("/") } : {}),
+      }));
+  process.stdout.write(JSON.stringify({ configurationHints: hints }) + "\n");
+}
+
+report.file = __filename;
+module.exports = report;

package/skills/spec/scripts/knip-hints.d.cts

@@ -0,0 +1,17 @@
+// Types of the `knip-hints.cjs` reporter: without them a project's TypeScript with `checkJs` would check the file.
+
+/** A configuration hint as knip collected it. */
+interface Hint {
+  type: string;
+  identifier: string | RegExp;
+  workspaceName?: string;
+  filePath?: string;
+}
+
+/** knip reporter: configuration hints as a JSON line on stdout. */
+declare function report(options: { cwd: string; configurationHints: Hint[]; isDisableConfigHints?: boolean }): void;
+declare namespace report {
+  /** Path of the reporter file — for `knip --reporter`. */
+  const file: string;
+}
+export = report;

package/skills/spec/scripts/package-run.ts

@@ -0,0 +1,22 @@
+/**
+ * The package's script as a command — one form for package.json, CI, the harness's hints and the help of
+ * `elves <script>`: `bun` reads the bin itself, past its shebang, and without the flag would load the project's env
+ * files into it — the script would pass their keys on to `gh`, `git` and the checked command
+ * (tests/standards/no-env-file, #596); a step of GitHub Actions doesn't see `node_modules/.bin`, and `bunx elves`
+ * without the package in node_modules would fetch someone else's `elves` from npm (#558, question 2). The installer
+ * imports it, and so does the harness — a module of the package built for Node: constants without imports, the
+ * installer's start doesn't load the harness's parser.
+ */
+export const PACKAGE_RUN = "bun --no-env-file node_modules/.bin/elves";
+
+/**
+ * The package of the project's version through bunx — where `node_modules/.bin/elves` isn't there or doesn't run: a CI
+ * job without the project's dependencies (#597) and a project on Yarn 2+ (#608). Yarn 2+ has no `node_modules` with
+ * PnP, and with any `nodeLinker` it runs a `.ts` bin by Node, past its shebang — Node doesn't strip types under
+ * `node_modules`; bunx runs the bin by its shebang, under Bun without env files (#592). Needs `jq`; `$(…)` works in
+ * Yarn's shell too. The first run fetches the package of that version into Bun's cache.
+ */
+export const PACKAGE_BUNX = `bunx @miroshnik/elves@"$(jq -r '.devDependencies["@miroshnik/elves"]' package.json)"`;
+
+/** The package's script in a project: on Yarn 2+ (`berry` of the github skill's `packageManager`) — `PACKAGE_BUNX`. */
+export const packageRun = (berry: boolean) => (berry ? PACKAGE_BUNX : PACKAGE_RUN);

package/skills/spec/scripts/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/skills/spec/scripts/spec-break.ts

@@ -0,0 +1,232 @@
+#!/usr/bin/env bun
+/**
+ * spec-break — a check by breaking: can the check fail. Applies an edit to the project's source, runs the test command,
+ * expects red and always rolls the edit back; prints ✅ (failed) / ❌ (didn't fail) for each break. The agent picks the
+ * break for one check — this is a proof, not mutation testing.
+ *
+ *   bun spec-break.ts --file <file> --find <fragment> --replace <replacement> [--name <name>] [--no-baseline] -- <test command…>
+ *   bun spec-break.ts --plan breaks.json [--no-baseline] [-- <test command…>]
+ *   bun spec-break.ts --restore
+ *
+ * A plan is JSON `[{ name, file, find, replace, cmd? }]`: `cmd` — a string for `sh -c`, without it — the command after
+ * `--`. The `find` fragment occurs in the file exactly once. Each break is a separate run: the first red test in a serial
+ * group hides the rest. Before the breaks — a baseline run of each command: red even without a break, ✅ would prove
+ * nothing — code 2 (`--no-baseline` skips it).
+ *
+ * Rollback: after the run; on SIGINT, SIGTERM, SIGHUP the test command is killed together with its processes and the
+ * file is restored. For an abort with no chance of rollback (kill -9, a closed session) a journal is written before the
+ * break (`.git/spec-break.json`, outside git — `.spec-break.json`), and the next run or `--restore` restores the file
+ * from it; the file was edited after the abort — the journal doesn't touch it, code 2. Codes: 0 — failed on every break,
+ * 1 — there is a ❌, 2 — a call error, a red baseline run, the journal not applied.
+ */
+
+import { spawn, spawnSync } from "node:child_process";
+import { existsSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { parseArgs } from "node:util";
+
+const USAGE = [
+  "spec-break --file <file> --find <fragment> --replace <replacement> [--name <name>] [--no-baseline] -- <test command…>",
+  "spec-break --plan breaks.json [--no-baseline] [-- <test command…>]",
+  "spec-break --restore",
+].join("\n");
+/** `--help`, `-h` (tests/standards/cli-help): the synopsis, what it does and examples; `elves` prints it under its name. */
+export const HELP = `${USAGE}
+
+Can the check fail: applies the break, runs the test command, expects red and always rolls the break back; ✅ — failed,
+❌ — didn't. Code 0 — failed on every break, 1 — there is a ❌, 2 — a call error, a red baseline run, the journal not
+applied.
+
+Examples:
+  spec-break --file src/audit.ts --find "writeAudit(" --replace "void (" -- bun test tests/standards/audit
+  spec-break --plan breaks.json -- bun test`;
+
+interface Break {
+  name: string;
+  file: string;
+  find: string;
+  replace: string;
+  cmd?: string;
+}
+
+/** The test command: argv after `--` or a plan string for `sh -c`. */
+type Command = string[];
+
+/** A record of an applied break: by it the next run restores the file if the rollback didn't happen. */
+interface Journal {
+  name: string;
+  file: string;
+  original: string;
+  broken: string;
+}
+
+class Failure extends Error {}
+
+function journalPath(): string {
+  const r = spawnSync("git", ["rev-parse", "--git-path", "spec-break.json"], { encoding: "utf8" });
+  return r.status === 0 && r.stdout.trim() ? path.resolve(r.stdout.trim()) : path.resolve(".spec-break.json");
+}
+
+/** Restore the file from the journal of an aborted run; no journal — nothing. The file was edited after the break — leave it. */
+function restoreJournal(journal: string): void {
+  if (!existsSync(journal)) return;
+  const j = JSON.parse(readFileSync(journal, "utf8")) as Journal;
+  const rel = path.relative(process.cwd(), j.file) || j.file;
+  const now = existsSync(j.file) ? readFileSync(j.file, "utf8") : null;
+  if (now === j.original) {
+    rmSync(journal);
+    return;
+  }
+  if (now !== j.broken) {
+    throw new Failure(`${rel} changed after the breakage «${j.name}» — journal ${journal} not applied: compare the file by hand and delete the journal`);
+  }
+  writeFileSync(j.file, j.original);
+  rmSync(journal);
+  console.log(`spec-break: restored ${rel} after an interrupted run (breakage «${j.name}»)`);
+}
+
+/** The break is applicable: the file exists, the fragment occurs in it exactly once. */
+function check(b: Break): void {
+  if (!existsSync(b.file)) throw new Failure(`breakage «${b.name}»: no file ${b.file}`);
+  const n = readFileSync(b.file, "utf8").split(b.find).length - 1;
+  if (n === 0) throw new Failure(`breakage «${b.name}»: «${b.find}» not found in ${b.file}`);
+  if (n > 1) throw new Failure(`breakage «${b.name}»: «${b.find}» occurs ${n} times in ${b.file} — make the fragment longer`);
+}
+
+let child: ReturnType<typeof spawn> | null = null;
+let applied: { journal: string; j: Journal } | null = null;
+
+/** Roll the applied break back: the file to its original state, the journal away. */
+function undo(): void {
+  if (!applied) return;
+  writeFileSync(applied.j.file, applied.j.original);
+  rmSync(applied.journal, { force: true });
+  applied = null;
+}
+
+/** Run the command in its own process group (a signal goes to the whole group); the exit code and the output tail. */
+function run(cmd: Command): Promise<{ code: number; tail: string }> {
+  return new Promise((resolve, reject) => {
+    const out: string[] = [];
+    const p = spawn(cmd[0]!, cmd.slice(1), { detached: true, stdio: ["ignore", "pipe", "pipe"] });
+    child = p;
+    const keep = (d: Buffer) => {
+      out.push(d.toString("utf8"));
+      if (out.length > 200) out.splice(0, out.length - 200);
+    };
+    p.stdout!.on("data", keep);
+    p.stderr!.on("data", keep);
+    p.on("error", (e) => {
+      child = null;
+      reject(new Failure(`the test command didn't start: ${cmd.join(" ")}: ${e.message}`));
+    });
+    p.on("close", (code, signal) => {
+      child = null;
+      resolve({ code: code ?? (signal ? 128 : 1), tail: out.join("").split("\n").slice(-20).join("\n") });
+    });
+  });
+}
+
+function onSignal(signal: NodeJS.Signals): void {
+  if (child?.pid) {
+    try {
+      process.kill(-child.pid, "SIGKILL");
+    } catch {
+      /* the group has already exited */
+    }
+  }
+  const file = applied && path.relative(process.cwd(), applied.j.file);
+  undo();
+  console.error(`spec-break: interrupted (${signal})${file ? ` — ${file} restored` : ""}`);
+  process.exit(signal === "SIGINT" ? 130 : signal === "SIGHUP" ? 129 : 143);
+}
+
+const label = (cmd: Command) => (cmd[0] === "sh" && cmd[1] === "-c" ? cmd[2]! : cmd.join(" "));
+
+export async function main(argv: string[]): Promise<number> {
+  let opts;
+  try {
+    opts = parseArgs({
+      args: argv,
+      allowPositionals: true,
+      options: {
+        file: { type: "string" },
+        find: { type: "string" },
+        replace: { type: "string" },
+        name: { type: "string" },
+        plan: { type: "string" },
+        restore: { type: "boolean", default: false },
+        "no-baseline": { type: "boolean", default: false },
+        help: { type: "boolean", short: "h", default: false },
+      },
+    });
+  } catch (e) {
+    console.error(`spec-break: ${(e as Error).message}\n${USAGE}`);
+    return 2;
+  }
+  const v = opts.values;
+  if (v.help) return console.log(HELP), 0;
+  const journal = journalPath();
+  try {
+    restoreJournal(journal);
+    if (v.restore) return 0;
+
+    const fallback: Command = opts.positionals;
+    let breaks: Break[];
+    if (v.plan) {
+      breaks = JSON.parse(readFileSync(v.plan, "utf8")) as Break[];
+      if (!Array.isArray(breaks) || !breaks.length) throw new Failure(`plan ${v.plan} must be a non-empty array [{ name, file, find, replace, cmd? }]`);
+    } else if (v.file && v.find !== undefined && v.replace !== undefined) {
+      breaks = [{ name: v.name ?? `${v.find} → ${v.replace}`, file: v.file, find: v.find, replace: v.replace }];
+    } else {
+      throw new Failure(`a breakage is needed: --file, --find and --replace, or --plan\n${USAGE}`);
+    }
+    const cmdOf = (b: Break): Command => (b.cmd ? ["sh", "-c", b.cmd] : fallback);
+    for (const b of breaks) {
+      if (!cmdOf(b).length) throw new Failure(`breakage «${b.name}»: no test command — after -- or in the plan's cmd`);
+      check(b);
+    }
+
+    for (const s of ["SIGINT", "SIGTERM", "SIGHUP"] as const) process.on(s, onSignal);
+
+    if (!v["no-baseline"]) {
+      const cmds = new Map(breaks.map((b) => [JSON.stringify(cmdOf(b)), cmdOf(b)]));
+      for (const cmd of cmds.values()) {
+        const r = await run(cmd);
+        if (r.code !== 0) throw new Failure(`the run is red even without a breakage — breakages not applied: ${label(cmd)} (code ${r.code})\n${r.tail}`);
+      }
+    }
+
+    let caught = 0;
+    for (const b of breaks) {
+      const original = readFileSync(b.file, "utf8");
+      const j: Journal = { name: b.name, file: path.resolve(b.file), original, broken: original.replace(b.find, () => b.replace) };
+      // the journal goes before the edit: if aborted after it, the next run finds what to restore
+      writeFileSync(journal, JSON.stringify(j));
+      applied = { journal, j };
+      writeFileSync(j.file, j.broken);
+      let r: { code: number };
+      try {
+        r = await run(cmdOf(b));
+      } finally {
+        undo();
+      }
+      if (r.code !== 0) {
+        caught++;
+        console.log(`✅ failed: ${b.name} (${b.file})`);
+      } else {
+        console.log(`❌ didn't fail: ${b.name} (${b.file}) — the check doesn't catch this breakage`);
+      }
+    }
+    console.log(`total: ${caught} of ${breaks.length} breakages made the check fail; files are in their original state`);
+    return caught === breaks.length ? 0 : 1;
+  } catch (e) {
+    if (!(e instanceof Failure)) throw e;
+    console.error(`spec-break: ${e.message}`);
+    return 2;
+  }
+}
+
+if (import.meta.main) {
+  process.exitCode = await main(process.argv.slice(2));
+}

package/skills/spec/scripts/spec-claims.ts

@@ -0,0 +1,198 @@
+#!/usr/bin/env bun
+/**
+ * spec-claims — checks the entry-point registry against the call log: every entry point (route, page, job, command) is
+ * called by at least one capability test. The log is written by the harness's `journal` during the run; logs of shards
+ * and runners are gathered from the directory and its subdirectories (a directory per runner). A call not from
+ * `tests/capabilities/` doesn't count: claimed behavior is a capability, not a standard or a helper. Ids in the
+ * registry don't repeat (a repeat would hide an uncovered entry point behind a covered one), every id of the log is in
+ * the registry (otherwise the format diverged or the registry is incomplete).
+ *
+ *   bun spec-claims.ts --entries <entries.json | entries.ts> [--journal .spec-journal] [--exceptions <directory>]
+ *                      [--standard tests/standards/entry-points] [--report .spec-claims.xml]
+ *
+ * The registry is a JSON array of strings or a project module (default — an array or a function that returns it): entry
+ * points from the code, not a hand-written list. Exceptions — the standard folder's `exceptions/` directory, a file per
+ * exception (`{ item, issue, reason }`): an entry point without a test, with a task, until a test appears; once it
+ * appears — "remove the exception". The report is JUnit in the standard's folder (`spec-doc` puts it into the spec with
+ * the description from the standard's `<folder>.md`). Codes: 0 — everything is claimed, 1 — there are unclaimed ones or
+ * exception errors, 2 — a call error.
+ */
+
+import { existsSync, readdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { parseArgs } from "node:util";
+
+import locale from "../../github/scripts/locale.ts";
+import { exceptionFiles } from "./harness.ts";
+import type { Exception } from "./harness.ts";
+
+const USAGE =
+  "spec-claims --entries <entries.json | entries.ts> [--journal .spec-journal] [--exceptions tests/standards/entry-points/exceptions] [--standard tests/standards/entry-points] [--report .spec-claims.xml]";
+/** `--help`, `-h` (tests/standards/cli-help): the synopsis, what it does and examples; `elves` prints it under its name. */
+export const HELP = `${USAGE}
+
+Every entry point of the registry is called by at least one capability test (the harness's journal). Code 0 — everything
+is claimed, 1 — there are unclaimed ones or exception errors, 2 — a call error.
+
+Examples:
+  spec-claims --entries tests/standards/entry-points/entries.ts
+  spec-claims --entries entries.json --journal .spec-journal --report .spec-claims.xml`;
+const CAPABILITIES = "tests/capabilities/";
+
+interface Case {
+  name: string;
+  failure?: string;
+}
+
+/** A JSON file or a project module: default — a value or a function that returns it. */
+async function load(file: string): Promise<unknown> {
+  if (file.endsWith(".json")) return JSON.parse(readFileSync(file, "utf8"));
+  const mod = (await import(pathToFileURL(file).href)) as { default?: unknown };
+  const v = mod.default;
+  return typeof v === "function" ? await (v as () => unknown)() : v;
+}
+
+/** Entry point → test files that called it (all logs of the directory and subdirectories — a directory per runner). */
+function readJournal(dir: string): Map<string, Set<string>> {
+  const calls = new Map<string, Set<string>>();
+  const files = readdirSync(dir, { recursive: true, encoding: "utf8" });
+  for (const f of files.filter((f) => f.endsWith(".jsonl")).sort()) {
+    for (const line of readFileSync(path.join(dir, f), "utf8").split("\n")) {
+      if (!line.trim()) continue;
+      const { id, test } = JSON.parse(line) as { id: string; test: string | null };
+      calls.set(id, (calls.get(id) ?? new Set()).add(test ?? "(not from a test)"));
+    }
+  }
+  return calls;
+}
+
+const esc = (s: string) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+
+/** JUnit as in `bun test`: a suite per file, a nested suite — describe, testcase with file. */
+function junit(file: string, describe: string, cases: Case[]): string {
+  const f = esc(file);
+  const body = cases
+    .map((c) =>
+      c.failure
+        ? `      <testcase name="${esc(c.name)}" file="${f}">\n        <failure message="${esc(c.failure)}" />\n      </testcase>`
+        : `      <testcase name="${esc(c.name)}" file="${f}" />`,
+    )
+    .join("\n");
+  const failures = cases.filter((c) => c.failure).length;
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<testsuites name="spec-claims" tests="${cases.length}" failures="${failures}">
+  <testsuite name="${f}" file="${f}" tests="${cases.length}" failures="${failures}">
+    <testsuite name="${esc(describe)}" file="${f}" tests="${cases.length}" failures="${failures}">
+${body}
+    </testsuite>
+  </testsuite>
+</testsuites>
+`;
+}
+
+export async function main(argv: string[]): Promise<number> {
+  let opts;
+  try {
+    opts = parseArgs({
+      args: argv,
+      options: {
+        entries: { type: "string" },
+        journal: { type: "string", default: ".spec-journal" },
+        exceptions: { type: "string" },
+        standard: { type: "string", default: "tests/standards/entry-points" },
+        report: { type: "string", default: ".spec-claims.xml" },
+        help: { type: "boolean", short: "h", default: false },
+      },
+    });
+  } catch (e) {
+    console.error(`spec-claims: ${(e as Error).message}\n${USAGE}`);
+    return 2;
+  }
+  const v = opts.values;
+  if (v.help) return console.log(HELP), 0;
+  if (!v.entries) return console.error(USAGE), 2;
+  let entries: string[];
+  let repeated: string[];
+  let exceptions: Exception[] = [];
+  let calls: Map<string, Set<string>>;
+  try {
+    const raw = await load(path.resolve(v.entries));
+    if (!Array.isArray(raw)) throw new Error(`${v.entries}: the registry is an array of entry points`);
+    const ids = raw.map((e) => (typeof e === "string" ? e : String((e as { id?: unknown }).id)));
+    const count = new Map<string, number>();
+    for (const id of ids) count.set(id, (count.get(id) ?? 0) + 1);
+    entries = [...count.keys()].sort();
+    repeated = entries.filter((id) => count.get(id)! > 1).map((id) => `${id} ×${count.get(id)}`);
+    if (v.exceptions) {
+      // a file per exception: the old array in one file is migrated by a command, not read by a second path
+      if (existsSync(v.exceptions) && !statSync(v.exceptions).isDirectory()) {
+        throw new Error(`--exceptions is an exceptions/ directory (a file per exception), not the file ${v.exceptions} — move it with spec-exceptions`);
+      }
+      exceptions = exceptionFiles(v.exceptions);
+    }
+    if (!existsSync(v.journal)) {
+      throw new Error(`no log ${v.journal} — the harness's journal writes it during the test run (shard logs go into one directory)`);
+    }
+    calls = readJournal(v.journal);
+  } catch (e) {
+    console.error(`spec-claims: ${(e as Error).message}`);
+    return 2;
+  }
+
+  // check test names are in the project language, like the harness's names: they go into the spec
+  const N = locale.names(locale.projectLanguage());
+  const claimed = (id: string) => [...(calls.get(id) ?? [])].some((t) => t.startsWith(CAPABILITIES));
+  const excepted = new Map(exceptions.map((e) => [e.item, e]));
+  const cases: Case[] = [];
+  cases.push({
+    name: locale.fill(N.spec.harness.registryNotEmpty, { registry: N.spec.claims.registry, tag: "" }),
+    failure: entries.length ? undefined : "the entry-point registry is empty — the selection from the code is wrong",
+  });
+  cases.push({
+    name: N.spec.claims.unique,
+    failure: repeated.length
+      ? `an id repeats in the registry: ${repeated.join(", ")} — each entry point has its own id, otherwise an uncovered one hides behind a covered one`
+      : undefined,
+  });
+  for (const id of entries.filter((id) => !excepted.has(id))) {
+    const from = [...(calls.get(id) ?? [])].sort();
+    cases.push({
+      name: locale.fill(N.spec.claims.called, { entry: id }),
+      failure: claimed(id) ? undefined : `${id} is not called by any capability test${from.length ? ` (calls: ${from.join(", ")})` : ""} — add a test or remove the entry point`,
+    });
+  }
+  const registered = new Set(entries);
+  const unknown = [...calls.keys()]
+    .filter((id) => !registered.has(id))
+    .sort()
+    .map((id) => `${id} (calls: ${[...calls.get(id)!].sort().join(", ")})`);
+  cases.push({
+    name: N.spec.claims.known,
+    failure: unknown.length
+      ? `ids from the log are not in the registry: ${unknown.join("; ")} — the log's id format diverged from the registry, the registry is incomplete, or the log is left over from a previous run (resetJournal)`
+      : undefined,
+  });
+  for (const e of [...excepted.values()].sort((a, b) => (a.item < b.item ? -1 : 1))) {
+    let failure: string | undefined;
+    if (!Number.isInteger(e.issue) || e.issue <= 0) failure = `exception ${e.item} has no issue`;
+    else if (!e.reason?.trim()) failure = `exception ${e.item} has no reason`;
+    else if (!entries.includes(e.item)) failure = `entry point ${e.item} is not in the registry — remove the exception: delete ${e.file}`;
+    else if (claimed(e.item)) failure = `${e.item} is already called by a capability test — remove the exception: delete ${e.file} (#${e.issue})`;
+    cases.push({ name: locale.fill(N.spec.harness.exception, { tag: "", item: e.item, issue: e.issue }), failure });
+  }
+
+  const standard = v.standard.replace(/\/+$/, "");
+  writeFileSync(v.report, junit(`${standard}/${path.posix.basename(standard)}.test.ts`, N.spec.claims.describe, cases));
+  const unclaimed = entries.filter((id) => !excepted.has(id) && !claimed(id));
+  const failed = cases.filter((c) => c.failure);
+  console.error(
+    `spec-claims: entry points: ${entries.length}, not called by capability tests: ${unclaimed.length}, exceptions: ${excepted.size}; report: ${v.report}`,
+  );
+  for (const c of failed) console.error(`spec-claims: ✗ ${c.failure}`);
+  return failed.length ? 1 : 0;
+}
+
+if (import.meta.main) {
+  process.exitCode = await main(process.argv.slice(2));
+}