codictator 0.0.0 → 0.1.2

package/dist/features/testing/integrity.d.ts

@@ -0,0 +1,28 @@
+import type { Finding } from "../engine/index.ts";
+export interface IntegrityException {
+    readonly id: string;
+    readonly rule: string;
+    readonly path: string;
+    readonly reason: string;
+}
+export interface IntegrityContext {
+    readonly exceptions: ReadonlyArray<IntegrityException>;
+    readonly acknowledged: ReadonlyArray<string>;
+}
+export interface FilePair {
+    readonly path: string;
+    readonly baseText: string;
+    readonly headText: string;
+}
+export declare function countAssertions(text: string): number;
+export declare function checkAssertionLoss(pair: FilePair, ctx: IntegrityContext): Array<Finding>;
+export declare function checkNoSkippedTests(pair: FilePair, ctx: IntegrityContext): Array<Finding>;
+export declare function checkNoNewSuppressions(pair: FilePair, ctx: IntegrityContext): Array<Finding>;
+export declare function checkNoFixtureShrink(pair: FilePair, stillReferenced: boolean, ctx: IntegrityContext): Array<Finding>;
+export interface Thresholds {
+    readonly lines: number;
+    readonly branches: number;
+}
+export declare function checkNoThresholdLowering(path: string, base: Thresholds, head: Thresholds): Array<Finding>;
+export declare function checkTestCommandIntact(baseCmd: ReadonlyArray<string>, headCmd: ReadonlyArray<string>): Array<Finding>;
+export declare function checkTestIntegrity(pair: FilePair, ctx: IntegrityContext): Array<Finding>;

package/dist/features/testing/integrity.js

@@ -0,0 +1,140 @@
+// SPEC §6.1 TypeScript assertion, skip and suppression shapes. The language
+// pack owns the full patterns; these defaults judge the self-hosted suite.
+const TS_ASSERTION = /\b(?:assert\s*\(|assert\.[A-Za-z]+|expect\s*\(|expect\.[A-Za-z]+)/g;
+const TS_SKIP_LINE = /^\s*(?:test|it|describe)\s*\.\s*(?:skip|only|todo)\s*\(|^\s*(?:xit|xdescribe|xtest|fit|fdescribe)\s*\(/;
+const SUPPRESSIONS = [
+    "eslint-disable",
+    "biome-ignore",
+    "@ts-ignore",
+    "@ts-expect-error",
+    "istanbul ignore",
+    "c8 ignore",
+    "#pragma warning disable",
+    "SuppressMessage",
+    "noqa",
+    "type: ignore",
+    "pragma: no cover",
+];
+export function countAssertions(text) {
+    return text.match(TS_ASSERTION)?.length ?? 0;
+}
+function addedLines(baseText, headText) {
+    const remaining = new Map();
+    for (const line of baseText.split("\n")) {
+        remaining.set(line, (remaining.get(line) ?? 0) + 1);
+    }
+    const added = [];
+    for (const line of headText.split("\n")) {
+        const left = remaining.get(line) ?? 0;
+        if (left > 0) {
+            remaining.set(line, left - 1);
+        }
+        else {
+            added.push(line);
+        }
+    }
+    return added;
+}
+function exceptionLifts(rule, path, ctx) {
+    return ctx.exceptions.some((exception) => exception.rule === rule &&
+        exception.path === path &&
+        exception.reason.trim().length >= 20 &&
+        ctx.acknowledged.includes(exception.id));
+}
+function integrityFinding(rule, path, message, remediation) {
+    return { ruleId: rule, path, message, remediation };
+}
+function maybeFinding(rule, path, message, remediation, ctx) {
+    if (exceptionLifts(rule, path, ctx)) {
+        return [];
+    }
+    return [integrityFinding(rule, path, message, remediation)];
+}
+// SPEC §4.10.4 core/no-assertion-loss: the pack assertion-token count in a
+// test file falls. Deleting the file with its feature is the same loss, so
+// it reports here and needs the same exception.
+export function checkAssertionLoss(pair, ctx) {
+    const lost = countAssertions(pair.baseText) - countAssertions(pair.headText);
+    if (lost <= 0) {
+        return [];
+    }
+    return maybeFinding("core/no-assertion-loss", pair.path, `assertion count falls by ${lost} in ${pair.path}`, `Restore the ${lost} lost assertion(s) in ${pair.path}, or record an integrity exception the final review acknowledges.`, ctx);
+}
+// SPEC §4.10.4 core/no-skipped-tests: added skip, only, todo, focus markers.
+// Ratcheted instances predate the check; only added markers report.
+export function checkNoSkippedTests(pair, ctx) {
+    const added = addedLines(pair.baseText, pair.headText).filter((line) => TS_SKIP_LINE.test(line));
+    if (added.length === 0) {
+        return [];
+    }
+    return maybeFinding("core/no-skipped-tests", pair.path, `skip or focus marker added in ${pair.path}: ${added[0]?.trim() ?? ""}`, `Remove the marker in ${pair.path}, or record an integrity exception the final review acknowledges.`, ctx);
+}
+// SPEC §4.10.4 core/no-new-suppressions: added lint, type, coverage or
+// analyzer suppressions, and grown ignore files, need an exception.
+export function checkNoNewSuppressions(pair, ctx) {
+    const added = addedLines(pair.baseText, pair.headText).filter((line) => SUPPRESSIONS.some((marker) => line.includes(marker)));
+    if (added.length === 0) {
+        return [];
+    }
+    return maybeFinding("core/no-new-suppressions", pair.path, `suppression added in ${pair.path}: ${added[0]?.trim().slice(0, 80) ?? ""}`, `Remove the suppression in ${pair.path}, or record an integrity exception the final review acknowledges.`, ctx);
+}
+// SPEC §4.10.4 core/no-fixture-shrink: a fixture or snapshot file loses more
+// lines than it gains, or is deleted while a test still references it.
+export function checkNoFixtureShrink(pair, stillReferenced, ctx) {
+    const baseLines = pair.baseText.split("\n").length;
+    const headLines = pair.headText.split("\n").length;
+    const deleted = pair.headText === "";
+    const shrinks = deleted ? stillReferenced : headLines < baseLines;
+    if (!shrinks) {
+        return [];
+    }
+    return maybeFinding("core/no-fixture-shrink", pair.path, deleted
+        ? `fixture deleted while still referenced: ${pair.path}`
+        : `fixture shrinks from ${baseLines} to ${headLines} lines: ${pair.path}`, `Restore ${pair.path}, or record an integrity exception the final review acknowledges.`, ctx);
+}
+// SPEC §4.10.4 core/no-threshold-lowering: a coverage threshold in a
+// pack-known config key falls. Tightening is free.
+export function checkNoThresholdLowering(path, base, head) {
+    const findings = [];
+    if (head.lines < base.lines) {
+        findings.push(integrityFinding("core/no-threshold-lowering", path, `line coverage threshold falls ${base.lines} to ${head.lines} in ${path}`, `Restore the line coverage threshold in ${path}; tightening only.`));
+    }
+    if (head.branches < base.branches) {
+        findings.push(integrityFinding("core/no-threshold-lowering", path, `branch coverage threshold falls ${base.branches} to ${head.branches} in ${path}`, `Restore the branch coverage threshold in ${path}; tightening only.`));
+    }
+    return findings;
+}
+const COMMAND_WEAKENERS = [
+    "|| true",
+    "; exit 0",
+    "--passWithNoTests",
+    "continue-on-error",
+];
+// SPEC §4.10.4 core/test-command-intact: the test command never weakens.
+export function checkTestCommandIntact(baseCmd, headCmd) {
+    const base = baseCmd.join(" ");
+    const head = headCmd.join(" ");
+    for (const weakener of COMMAND_WEAKENERS) {
+        if (!base.includes(weakener) && head.includes(weakener)) {
+            return [
+                integrityFinding("core/test-command-intact", "(test command)", `test command weakens with "${weakener}"`, `Remove "${weakener}" from the test command; a passing run must mean passing tests.`),
+            ];
+        }
+    }
+    const baseGlobs = baseCmd.filter((token) => token.includes("tests/"));
+    const dropped = baseGlobs.filter((glob) => !head.includes(glob));
+    if (dropped.length > 0) {
+        return [
+            integrityFinding("core/test-command-intact", "(test command)", `test command drops its globs: ${dropped.join(", ")}`, `Restore the dropped test globs; the test command keeps its scope.`),
+        ];
+    }
+    return [];
+}
+// The per-file evaluation entry: loss, skips and suppressions together.
+export function checkTestIntegrity(pair, ctx) {
+    return [
+        ...checkAssertionLoss(pair, ctx),
+        ...checkNoSkippedTests(pair, ctx),
+        ...checkNoNewSuppressions(pair, ctx),
+    ];
+}

package/dist/features/testing/ledger.d.ts

@@ -0,0 +1,11 @@
+export interface LedgerFile {
+    readonly version: 1;
+    readonly red: readonly string[];
+}
+export declare function formatTestId(file: string, title: string): string;
+export interface SplitTestId {
+    readonly file: string;
+    readonly title: string;
+}
+export declare function splitTestId(testId: string): SplitTestId | undefined;
+export declare function parseLedgerFile(value: unknown): LedgerFile;

package/dist/features/testing/ledger.js

@@ -0,0 +1,51 @@
+export function formatTestId(file, title) {
+    return `${file}::${title}`;
+}
+export function splitTestId(testId) {
+    const separator = testId.indexOf("::");
+    if (separator < 1 || separator + 2 >= testId.length) {
+        return undefined;
+    }
+    return {
+        file: testId.slice(0, separator),
+        title: testId.slice(separator + 2),
+    };
+}
+function isLedgerShape(value) {
+    return typeof value === "object" && value !== null;
+}
+function isStringArray(value) {
+    return (Array.isArray(value) && value.every((entry) => typeof entry === "string"));
+}
+function checkSortedUnique(red) {
+    for (let index = 1; index < red.length; index += 1) {
+        const previous = red[index - 1];
+        const current = red[index];
+        if (previous === undefined ||
+            current === undefined ||
+            !(previous < current)) {
+            throw new Error(`red ledger entries must be sorted with no duplicates; fix entry ${index}`);
+        }
+    }
+}
+// The kernel will own Result<T> (§4.1); until it lands, invalid ledger content
+// is a fail-closed throw caught by the driver, never a silent default-allow.
+export function parseLedgerFile(value) {
+    if (!isLedgerShape(value)) {
+        throw new Error("red ledger must be a JSON object with version 1 and a red list");
+    }
+    if (value.version !== 1) {
+        throw new Error("red ledger version must be 1");
+    }
+    const red = value.red;
+    if (!isStringArray(red)) {
+        throw new Error("red ledger red must be a list of test id strings");
+    }
+    for (const entry of red) {
+        if (splitTestId(entry) === undefined) {
+            throw new Error("red ledger entry must look like <test file path>::<full test title>");
+        }
+    }
+    checkSortedUnique(red);
+    return { version: 1, red };
+}

package/dist/features/testing/proofs.d.ts

@@ -0,0 +1,26 @@
+import type { Finding } from "../engine/index.ts";
+export interface DeclaredTest {
+    readonly path: string;
+    readonly title: string;
+}
+export type ProofRule = "core/red-before-green" | "core/regression-test-for-fix";
+export interface RedProofInput {
+    readonly declared: ReadonlyArray<DeclaredTest>;
+    readonly reportXml: string;
+    readonly implementationStarted: boolean;
+    readonly rule?: ProofRule;
+}
+export interface GreenProofInput {
+    readonly declared: ReadonlyArray<DeclaredTest>;
+    readonly reportXml: string;
+    readonly rule?: ProofRule;
+}
+export interface ReRunInput {
+    readonly declared: ReadonlyArray<DeclaredTest>;
+    readonly rerunReportXml: string;
+    readonly rule?: ProofRule;
+}
+export declare function checkRedProof(input: RedProofInput): Array<Finding>;
+export declare function checkGreenProof(input: GreenProofInput): Array<Finding>;
+export declare function checkRedProofReRun(input: ReRunInput): Array<Finding>;
+export declare function checkRunnerAvailable(runnerPresent: boolean, runner: string): Array<Finding>;

package/dist/features/testing/proofs.js

@@ -0,0 +1,88 @@
+// SPEC §4.10.2: red and green proofs from JUnit reports. The runner
+// produces the report and the Git port performs the worktree re-run; these
+// checks judge the recorded inputs, so a forged record fails against the
+// re-run report. Report parsing reuses the kernel JUnit reader.
+import { readTestReport } from "../../kernel/index.js";
+function ruleOf(rule) {
+    return rule ?? "core/red-before-green";
+}
+function proofFinding(rule, code, path, message, remediation) {
+    return { ruleId: rule, path, code, message, remediation };
+}
+function reportCases(reportXml) {
+    const parsed = readTestReport(reportXml);
+    if (!parsed.ok) {
+        return undefined;
+    }
+    const byTitle = new Map();
+    for (const testCase of parsed.value) {
+        if (!byTitle.has(testCase.title)) {
+            byTitle.set(testCase.title, testCase.outcome);
+        }
+    }
+    return byTitle;
+}
+// SPEC §4.10.2: non-test files untouched (implementationStarted false) and
+// every declared test executed and failed; an absent test never counts, so
+// an uncompilable test file is CDX-E602, not a proof.
+export function checkRedProof(input) {
+    const rule = ruleOf(input.rule);
+    if (input.implementationStarted) {
+        return [
+            proofFinding(rule, "CDX-E601", input.declared[0]?.path ?? "(task)", "red proof attempted after implementation began", "Restore the base non-test files, then re-run the declared tests to record the red proof."),
+        ];
+    }
+    const cases = reportCases(input.reportXml);
+    const findings = [];
+    for (const test of input.declared) {
+        const outcome = cases?.get(test.title);
+        if (outcome !== "failed") {
+            findings.push(proofFinding(rule, "CDX-E602", test.path, outcome === undefined
+                ? `declared test absent from the report, not a red proof: ${test.title}`
+                : `declared test did not fail its red proof: ${test.title}`, `Run the declared tests first and record the failing run; a test absent from the report (load or compile failure) never counts.`));
+        }
+    }
+    return findings;
+}
+// SPEC §4.10.2: the green proof runs the same tests and requires all to pass.
+export function checkGreenProof(input) {
+    const rule = ruleOf(input.rule);
+    const cases = reportCases(input.reportXml);
+    const findings = [];
+    for (const test of input.declared) {
+        const outcome = cases?.get(test.title);
+        if (outcome !== "passed") {
+            findings.push(proofFinding(rule, "CDX-E602", test.path, `declared test not passing its green proof: ${test.title}`, `Fix ${test.path} until every declared test passes, then record the green proof.`));
+        }
+    }
+    return findings;
+}
+// SPEC §4.10.2 L4: CI checks out redProof.commit in a temporary worktree and
+// re-runs the declared tests; any passing (or absent) test fails the gate,
+// so a forged record cannot stand.
+export function checkRedProofReRun(input) {
+    const rule = ruleOf(input.rule);
+    const cases = reportCases(input.rerunReportXml);
+    const findings = [];
+    for (const test of input.declared) {
+        const outcome = cases?.get(test.title);
+        if (outcome !== "failed") {
+            findings.push(proofFinding(rule, "CDX-E602", test.path, `red-proof re-run does not fail: ${test.title}`, `The red-proof record claims failure at its commit, but the worktree re-run shows otherwise; record an honest red proof.`));
+        }
+    }
+    return findings;
+}
+// SPEC §4.10.5 EC-14: a missing runner blocks with CDX-E903.
+export function checkRunnerAvailable(runnerPresent, runner) {
+    if (runnerPresent) {
+        return [];
+    }
+    return [
+        {
+            ruleId: "core/red-before-green",
+            code: "CDX-E903",
+            message: `test runner missing from the machine: ${runner}`,
+            remediation: `Install ${runner} before recording proofs; without it no red proof can run.`,
+        },
+    ];
+}

package/dist/features/testing/report.d.ts

@@ -0,0 +1,6 @@
+import type { RunVerdict } from "./evaluate.ts";
+export interface PackageRunReport {
+    readonly packageName: string;
+    readonly verdict: RunVerdict;
+}
+export declare function formatRunReport(reports: readonly PackageRunReport[]): string;

package/dist/features/testing/report.js

@@ -0,0 +1,16 @@
+export function formatRunReport(reports) {
+    const lines = [];
+    for (const report of reports) {
+        const verdict = report.verdict;
+        const status = verdict.ok ? "ok" : "FAIL";
+        lines.push(`${status} ${report.packageName}: ${verdict.passed} passed, ${verdict.failed} failed, ${verdict.expectedRed.length} expected-red`);
+        for (const testId of verdict.expectedRed) {
+            lines.push(`  red ${testId}`);
+        }
+        for (const violation of verdict.violations) {
+            const detail = violation.detail === undefined ? "" : ` ${violation.detail}`;
+            lines.push(`  FAIL ${violation.mode} ${violation.testId}${detail}`);
+        }
+    }
+    return lines.join("\n");
+}

package/dist/features/testing/scenarios.d.ts

@@ -0,0 +1,34 @@
+import type { Finding } from "../engine/index.ts";
+export type TestKind = "acceptance" | "unit" | "integration" | "architecture" | "stress" | "load" | "regression";
+export interface ScenarioChange {
+    readonly path: string;
+    readonly trivialOnly: boolean;
+    readonly isTest: boolean;
+    readonly isDoc: boolean;
+    readonly isEntryPoint: boolean;
+    readonly addsCrossModuleImport: boolean;
+    readonly importsIoPackage: boolean;
+    readonly isNewModule: boolean;
+    readonly isDeletedModule: boolean;
+    readonly isRenamedModule: boolean;
+}
+export interface ScenarioOptions {
+    readonly hotPaths: ReadonlyArray<string>;
+    readonly taskType: string;
+    readonly archConfigChanged: boolean;
+}
+export interface ChangedTest {
+    readonly path: string;
+    readonly imports: ReadonlyArray<string>;
+}
+export interface TestKindsInput {
+    readonly required: ReadonlyArray<TestKind>;
+    readonly changedTests: ReadonlyArray<ChangedTest>;
+    readonly changedModules: ReadonlyArray<string>;
+    readonly importMap: Readonly<Record<string, ReadonlyArray<string>>>;
+    readonly mappedModules: ReadonlyArray<string>;
+    readonly kindGlobs: Readonly<Record<string, ReadonlyArray<string>>>;
+    readonly budgets: Readonly<Record<string, boolean>>;
+}
+export declare function requiredTestKinds(changes: ReadonlyArray<ScenarioChange>, options: ScenarioOptions): Array<TestKind>;
+export declare function checkTestKinds(input: TestKindsInput): Array<Finding>;

package/dist/features/testing/scenarios.js

@@ -0,0 +1,90 @@
+// SPEC §4.10.3: the scenario classifier. Inputs are caller-supplied facts
+// (changed paths, import edges, pack patterns); the import graph of §4.11
+// arrives as data, so this module never imports it.
+import { globMatch } from "../../kernel/index.js";
+// SPEC §4.10.3: the detected facts map to required kinds.
+export function requiredTestKinds(changes, options) {
+    const required = new Set();
+    for (const change of changes) {
+        if (change.isTest || change.isDoc || change.trivialOnly) {
+            continue;
+        }
+        required.add("acceptance");
+        required.add("unit");
+        if (change.isEntryPoint ||
+            change.addsCrossModuleImport ||
+            change.importsIoPackage) {
+            required.add("integration");
+        }
+        if (change.isNewModule ||
+            change.isDeletedModule ||
+            change.isRenamedModule ||
+            change.addsCrossModuleImport ||
+            options.archConfigChanged) {
+            required.add("architecture");
+        }
+        if (options.hotPaths.some((glob) => globMatch(glob, change.path))) {
+            required.add("stress");
+            required.add("load");
+        }
+    }
+    if (options.taskType === "fix") {
+        required.add("regression");
+    }
+    return [...required].sort();
+}
+function reachableModules(test, importMap) {
+    const reached = new Set(test.imports);
+    for (const direct of test.imports) {
+        for (const second of importMap[direct] ?? []) {
+            reached.add(second);
+        }
+    }
+    return reached;
+}
+// A kind is satisfied by a changed test file under its kind globs that
+// imports (transitively, depth 2) a changed module. Architecture is
+// satisfied when config.architecture maps every changed module, because
+// the arch guard (§4.11) is the architecture test. Stress and load tests
+// each declare a codictator:budget line.
+export function checkTestKinds(input) {
+    const findings = [];
+    const changed = new Set(input.changedModules);
+    for (const kind of input.required) {
+        if (kind === "architecture") {
+            const unmapped = [...changed].filter((module) => !input.mappedModules.includes(module));
+            if (unmapped.length === 0) {
+                continue;
+            }
+            findings.push(kindFinding(`architecture test missing: ${unmapped.join(", ")} map to no architecture module`, `Map ${unmapped.join(", ")} in config.architecture so the arch guard covers them.`));
+            continue;
+        }
+        const globs = input.kindGlobs[kind] ?? [];
+        const covering = input.changedTests.filter((test) => {
+            if (!globs.some((glob) => globMatch(glob, test.path))) {
+                return false;
+            }
+            const reached = reachableModules(test, input.importMap);
+            return [...changed].some((module) => reached.has(module));
+        });
+        if (covering.length === 0) {
+            findings.push(kindFinding(`${kind} test missing for changed ${[...changed].join(", ") || "files"}`, `Add a ${kind} test under ${globs.join(", ") || "its kind globs"} importing a changed module.`));
+            continue;
+        }
+        if (kind === "stress" || kind === "load") {
+            for (const test of covering) {
+                if (input.budgets[test.path] !== true) {
+                    findings.push(kindFinding(`${kind} test without a budget line: ${test.path}`, `Declare a codictator:budget line (p95, p99, rps or maxMs) in ${test.path}.`));
+                }
+            }
+        }
+    }
+    return findings;
+}
+function kindFinding(message, remediation) {
+    return {
+        ruleId: "core/test-kinds-by-scenario",
+        message,
+        remediation,
+    };
+}

package/dist/features/testing/tap-parser.d.ts

@@ -0,0 +1,9 @@
+export interface TapOutcome {
+    readonly title: string;
+    readonly passed: boolean;
+}
+export interface TapFileResult {
+    readonly outcomes: readonly TapOutcome[];
+    readonly loadFailed: boolean;
+}
+export declare function parseTap(tap: string, filePath: string): TapFileResult;

package/dist/features/testing/tap-parser.js

@@ -0,0 +1,84 @@
+function unescapeTapName(name) {
+    return name.replace(/\\\\/g, "\\");
+}
+function countIndent(line) {
+    let indent = 0;
+    while (line.charCodeAt(indent) === 32) {
+        indent += 1;
+    }
+    return indent;
+}
+function openChild(parent) {
+    const top = parent[parent.length - 1];
+    if (top !== undefined) {
+        top.hasChildren = true;
+    }
+}
+function closeSubtests(stack, indent) {
+    while (stack.length > 0) {
+        const top = stack[stack.length - 1];
+        if (top === undefined || top.indent <= indent) {
+            return;
+        }
+        stack.pop();
+    }
+}
+function recordResult(stack, indent, name, passed, outcomes) {
+    closeSubtests(stack, indent);
+    const top = stack[stack.length - 1];
+    if (top !== undefined && top.indent === indent && top.name === name) {
+        stack.pop();
+        if (!top.hasChildren) {
+            outcomes.push({
+                title: stack
+                    .map((entry) => entry.name)
+                    .concat(name)
+                    .join(" > "),
+                passed,
+            });
+        }
+        return top.hasChildren;
+    }
+    outcomes.push({
+        title: stack
+            .map((entry) => entry.name)
+            .concat(name)
+            .join(" > "),
+        passed,
+    });
+    return false;
+}
+export function parseTap(tap, filePath) {
+    const stack = [];
+    const outcomes = [];
+    for (const rawLine of tap.split("\n")) {
+        const line = rawLine.endsWith("\r") ? rawLine.slice(0, -1) : rawLine;
+        const trimmed = line.trimStart();
+        if (trimmed.startsWith("# Subtest: ")) {
+            openChild(stack);
+            stack.push({
+                name: unescapeTapName(trimmed.slice("# Subtest: ".length).trimEnd()),
+                indent: countIndent(line),
+                hasChildren: false,
+            });
+            continue;
+        }
+        if (trimmed.startsWith("#")) {
+            continue;
+        }
+        const match = /^( *)(not )?ok [0-9]+ - (.*)$/.exec(line);
+        if (match === null) {
+            continue;
+        }
+        const indent = (match[1] ?? "").length;
+        const passed = match[2] === undefined;
+        const name = unescapeTapName((match[3] ?? "").trimEnd());
+        recordResult(stack, indent, name, passed, outcomes);
+    }
+    const leaves = outcomes.filter((outcome) => outcome.title !== filePath);
+    const fileLevelFailed = outcomes.some((outcome) => outcome.title === filePath && !outcome.passed);
+    return {
+        outcomes: leaves,
+        loadFailed: fileLevelFailed && leaves.length === 0,
+    };
+}

package/dist/features/testing/trace.d.ts

@@ -0,0 +1,23 @@
+import type { Finding } from "../engine/index.ts";
+export declare const DEFAULT_REF_PATTERN = "\\[(\u00A7[\\d.]+(?: EC-\\d+)?)\\]";
+export interface SpecReference {
+    readonly section: string;
+    readonly ec: number | undefined;
+    readonly raw: string;
+}
+export interface SpecIndex {
+    readonly headings: ReadonlySet<string>;
+    readonly ecRows: ReadonlyMap<string, ReadonlySet<number>>;
+}
+export interface TracedTest {
+    readonly path: string;
+    readonly title: string;
+}
+export declare function parseSpecRefs(title: string, refPattern?: string): Array<SpecReference>;
+export declare function checkSpecTrace(tests: ReadonlyArray<TracedTest>, spec: SpecIndex, acceptanceGlobs?: ReadonlyArray<string>, refPattern?: string): Array<Finding>;
+export interface PlannedTask {
+    readonly type: string;
+    readonly specRefs: ReadonlyArray<string>;
+    readonly declaredTests: ReadonlyArray<TracedTest>;
+}
+export declare function checkPlanningGate(task: PlannedTask): Array<Finding>;