@nexrall/code-core 1.4.76 → 1.4.78

package/dist/verify/failureTimeline.d.ts

@@ -0,0 +1,100 @@
+export interface Retest {
+    at: number;
+    /** The command as typed, clipped for display. */
+    command: string;
+    ok: boolean;
+}
+export interface Incident {
+    id: number;
+    /** The command that first failed, clipped. */
+    command: string;
+    /** Process exit code when the tool reported one. */
+    exitCode: number | null;
+    at: number;
+    /** Tool-output store entry holding this command's full output, for Ctrl+O. */
+    outputId?: number;
+    /** Files a mutating tool touched while this incident was open, first-touch order. */
+    files: string[];
+    /** Same-family commands run afterwards, newest last. */
+    retests: Retest[];
+    /** Set when a same-family command exited 0. */
+    resolvedAt?: number;
+}
+/** Incidents kept per session. Older ones are dropped — a failure from an hour ago is noise. */
+export declare const MAX_INCIDENTS = 10;
+/** Files listed per incident. */
+export declare const MAX_FILES = 6;
+/** Retests kept per incident. */
+export declare const MAX_RETESTS = 6;
+/** Command text kept for display. */
+export declare const MAX_CMD_CHARS = 72;
+/**
+ * Do two commands belong to the same "run" of the same check?
+ *
+ * Needed because a fix is followed by a re-run that is rarely byte-identical:
+ * `npm test` → `npm test -- --watch=false`, `npm test` → `npm run test`, `pytest` →
+ * `pytest -x tests/test_x.py`. Comparing the first token alone would call `npm install`
+ * a re-run of `npm test`; comparing whole strings would miss every one of those.
+ *
+ * Rule: the first token must match (the tool — npm/npm, pytest/pytest) AND the commands
+ * must share at least one non-flag word OR an identical second token. `npm run test` vs
+ * `npm test` share the literal word `test`; `npm install` shares nothing with `npm test`
+ * except the tool, so it stays a different command.
+ */
+export declare function sameCommandFamily(a: string, b: string): boolean;
+export interface NoteBashOptions {
+    /** Process exit code when the tool reported one; undefined for non-bash paths. */
+    exitCode?: number | null;
+    /** Tool-output store entry id, so the rescue can point at the full text. */
+    outputId?: number;
+    /** Current time — injected so the chain is testable. */
+    at: number;
+}
+export declare function isCheckCommand(command: string): boolean;
+export declare class FailureLedger {
+    incidents: Incident[];
+    private nextId;
+    /**
+     * Record one main-agent bash result. A non-zero exit (or an explicit `error` that is
+     * not an interrupt — timeout, spawn failure) either extends the open incident of the
+     * same command family or opens a new one; a zero exit resolves the open incident of
+     * that family.
+     *
+     * Interrupts are deliberately NOT failures: "Command stopped by user" is something the
+     * user chose, and offering to "fix" it would be nonsense.
+     */
+    noteBash(command: string, ok: boolean, opts: NoteBashOptions): void;
+    /** A mutating tool touched `path` — recorded only while something is actually broken. */
+    noteEdit(path: string): void;
+    /** The most recent incident with no successful same-family re-run. */
+    lastUnresolved(): Incident | undefined;
+    reset(): void;
+    private openFor;
+}
+/**
+ * The §65 chain, one line per event, newest last:
+ *
+ *   ✗ npm test — exit 1 · 2m 4s in
+ *     ↳ edited src/util.ts, src/expr.ts
+ *     ↳ re-ran npm test — still failing
+ *     ✓ npm test — passed after 4m 10s
+ *
+ * Relative offsets, not wall-clock times: the transcript has no timestamps anywhere
+ * else, so "2m 4s in" is the only reading that means anything in context.
+ */
+export declare function formatTimeline(inc: Incident, cols: number): string[];
+/**
+ * The one line that names the rescue, printed under the timeline. `/failures` re-prints
+ * the whole chain later; Ctrl+O shows the failing command's full output (it is the last
+ * tool output when the turn ended on it); Ctrl+G opens a file.
+ */
+export declare function rescueHint(inc: Incident, cols: number): string;
+/**
+ * The message Ctrl+F sends. It is NOT a pretend user message: it names itself, states the
+ * command and its exit code, and includes the last lines of the real output — so the
+ * model's next step is grounded in the failure even after a compaction dropped the body.
+ */
+export declare function rescuePrompt(inc: Incident, outputTail: string, maxChars?: number): string;
+/** `/failures` listing: every incident, newest first, with the chain inline. */
+export declare function formatIncidents(ledger: FailureLedger, cols: number): string[];
+//# sourceMappingURL=failureTimeline.d.ts.map

package/dist/verify/failureTimeline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"failureTimeline.d.ts","sourceRoot":"","sources":["../../src/verify/failureTimeline.ts"],"names":[],"mappings":"AAuBA,MAAM,WAAW,MAAM;IACrB,EAAE,EAAE,MAAM,CAAC;IACX,iDAAiD;IACjD,OAAO,EAAE,MAAM,CAAC;IAChB,EAAE,EAAE,OAAO,CAAC;CACb;AAED,MAAM,WAAW,QAAQ;IACvB,EAAE,EAAE,MAAM,CAAC;IACX,8CAA8C;IAC9C,OAAO,EAAE,MAAM,CAAC;IAChB,oDAAoD;IACpD,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,8EAA8E;IAC9E,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,qFAAqF;IACrF,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,wDAAwD;IACxD,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,+CAA+C;IAC/C,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,gGAAgG;AAChG,eAAO,MAAM,aAAa,KAAK,CAAC;AAChC,iCAAiC;AACjC,eAAO,MAAM,SAAS,IAAI,CAAC;AAC3B,iCAAiC;AACjC,eAAO,MAAM,WAAW,IAAI,CAAC;AAC7B,qCAAqC;AACrC,eAAO,MAAM,aAAa,KAAK,CAAC;AAEhC;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAmB/D;AAED,MAAM,WAAW,eAAe;IAC9B,kFAAkF;IAClF,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,4EAA4E;IAC5E,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,wDAAwD;IACxD,EAAE,EAAE,MAAM,CAAC;CACZ;AAmBD,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAUvD;AAED,qBAAa,aAAa;IACxB,SAAS,EAAE,QAAQ,EAAE,CAAM;IAC3B,OAAO,CAAC,MAAM,CAAK;IAEnB;;;;;;;;OAQG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,eAAe,GAAG,IAAI;IA2BnE,yFAAyF;IACzF,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAO5B,sEAAsE;IACtE,cAAc,IAAI,QAAQ,GAAG,SAAS;IAOtC,KAAK,IAAI,IAAI;IAKb,OAAO,CAAC,OAAO;CAOhB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAiBpE;AAED;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAG9D;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,EAAE,QAAQ,SAAO,GAAG,MAAM,CAkBvF;AAED,gFAAgF;AAChF,wBAAgB,eAAe,CAAC,MAAM,EAAE,aAAa,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAO7E"}

package/dist/verify/failureTimeline.js

@@ -0,0 +1,253 @@
+"use strict";
+// The failure timeline (spec §65) and the one-key rescue (spec §64).
+//
+// WHY: a failing command in the middle of an agentic turn scrolls past like everything
+// else. Ten minutes later the user sees "✗ 2 files changed" and has no idea whether the
+// tests they care about ever passed, or whether the fix the agent attempted worked. The
+// turn summary already reports test outcomes (turnSummary.ts), but it is ONE line: it
+// cannot show that a test failed, the agent edited two files, re-ran it, and it passed.
+//
+// This ledger watches the tool events the CLI already receives and reconstructs that
+// chain: which command failed, what was edited while it was broken, and when (if ever) a
+// same-family command came back green. Everything in it is OBSERVED — a command's exit
+// code, a file tool's path — nothing is inferred from the model's prose, so a chain is
+// never claimed for a fix that did not happen.
+//
+// The same ledger answers "what do I do now?" (§64): the last unresolved incident can be
+// handed back to the model with one keystroke (Ctrl+F), because the failing output is
+// already in its context.
+//
+// Pure (no console, no chalk, no fs) so the chain rules and the line-width behaviour are
+// unit-testable — see test/failureTimeline.test.ts.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FailureLedger = exports.MAX_CMD_CHARS = exports.MAX_RETESTS = exports.MAX_FILES = exports.MAX_INCIDENTS = void 0;
+exports.sameCommandFamily = sameCommandFamily;
+exports.isCheckCommand = isCheckCommand;
+exports.formatTimeline = formatTimeline;
+exports.rescueHint = rescueHint;
+exports.rescuePrompt = rescuePrompt;
+exports.formatIncidents = formatIncidents;
+const duration_1 = require("../util/duration");
+/** Incidents kept per session. Older ones are dropped — a failure from an hour ago is noise. */
+exports.MAX_INCIDENTS = 10;
+/** Files listed per incident. */
+exports.MAX_FILES = 6;
+/** Retests kept per incident. */
+exports.MAX_RETESTS = 6;
+/** Command text kept for display. */
+exports.MAX_CMD_CHARS = 72;
+/**
+ * Do two commands belong to the same "run" of the same check?
+ *
+ * Needed because a fix is followed by a re-run that is rarely byte-identical:
+ * `npm test` → `npm test -- --watch=false`, `npm test` → `npm run test`, `pytest` →
+ * `pytest -x tests/test_x.py`. Comparing the first token alone would call `npm install`
+ * a re-run of `npm test`; comparing whole strings would miss every one of those.
+ *
+ * Rule: the first token must match (the tool — npm/npm, pytest/pytest) AND the commands
+ * must share at least one non-flag word OR an identical second token. `npm run test` vs
+ * `npm test` share the literal word `test`; `npm install` shares nothing with `npm test`
+ * except the tool, so it stays a different command.
+ */
+function sameCommandFamily(a, b) {
+    const words = (s) => s
+        .trim()
+        .split(/\s+/)
+        .filter((t) => t && !t.startsWith('-'))
+        .map((t) => t.replace(/^['"]|['"]$/g, ''));
+    const rawCount = (s) => s.trim().split(/\s+/).filter(Boolean).length;
+    const A = words(a);
+    const B = words(b);
+    if (!A.length || !B.length)
+        return false;
+    if (A[0] !== B[0])
+        return false;
+    // A BARE tool (`pytest`, then `pytest -x tests/test_x.py`) has no word to share, so the
+    // tool name is the only signal there is. `npm --silent` does not qualify as bare: it
+    // carries a flag, and flags never establish a family.
+    if (rawCount(a) === 1 || rawCount(b) === 1)
+        return true;
+    if (A[1] !== undefined && A[1] === B[1])
+        return true;
+    const rest = new Set(A.slice(1));
+    return B.slice(1).some((t) => rest.has(t));
+}
+/**
+ * Commands a user reads as "a check": test / build / lint / typecheck. Only these may
+ * open an incident — `grep foo` exiting 1 means "not found", `diff` exits 1 when files
+ * differ, and a rescue banner over either of those would be noise on every turn.
+ *
+ * Wider than turnSummary's TEST_RE on purpose: that one answers "should the summary
+ * claim tests ran", this answers "is this a verification the user is waiting on".
+ * Script names are matched by WORD so custom ones work (`npm run verify:all`,
+ * `npm run typecheck:ci`) while `npm run dev` never counts.
+ */
+const BINARY_RE = /(^|[\s;&|])(jest|vitest|mocha|pytest|tsc|vue-tsc|mypy|pyright|eslint|oxlint|stylelint|biome|golangci-lint|staticcheck|shellcheck|hadolint|rubocop|swiftlint|ktlint|detekt|phpcs|phpstan|psalm|cppcheck|clang-tidy|luacheck|svelte-check|phpunit|rspec|xcodebuild|gradle)(\s|$)|(^|[\s;&|])(go (test|build|vet)|cargo (test|check|build|clippy)|python3? -m (pytest|unittest)|node --test|make|mvn (test|verify|compile)|dotnet (test|build)|swift (test|build)|ruff check|(playwright|cypress|newman) (test|run)|webpack|rollup|esbuild|parcel|(vite|next|ng|nx) (build|bundle|compile))(\s|$)/i;
+const RUNNER_RE = /\b(?:npm|yarn|pnpm|bun)(?:\s+run)?\s+([^\s;&|]+)/gi;
+// `t` is npm's own shorthand for `test`, and the boundary rule keeps `npm ts`/`npm tw` out.
+const SCRIPT_WORD_RE = /(^|[:.-])(t|test|tests|lint|build|check|typecheck|types|verify|e2e|ci|coverage|validate)([:.-]|$)/i;
+function isCheckCommand(command) {
+    const cmd = command.trim();
+    if (!cmd)
+        return false;
+    if (BINARY_RE.test(cmd))
+        return true;
+    RUNNER_RE.lastIndex = 0; // global regex: state persists between calls
+    let m;
+    while ((m = RUNNER_RE.exec(cmd)) !== null) {
+        if (SCRIPT_WORD_RE.test(m[1]))
+            return true;
+    }
+    return false;
+}
+class FailureLedger {
+    constructor() {
+        this.incidents = [];
+        this.nextId = 1;
+    }
+    /**
+     * Record one main-agent bash result. A non-zero exit (or an explicit `error` that is
+     * not an interrupt — timeout, spawn failure) either extends the open incident of the
+     * same command family or opens a new one; a zero exit resolves the open incident of
+     * that family.
+     *
+     * Interrupts are deliberately NOT failures: "Command stopped by user" is something the
+     * user chose, and offering to "fix" it would be nonsense.
+     */
+    noteBash(command, ok, opts) {
+        const cmd = command.replace(/\s+/g, ' ').trim();
+        if (!cmd)
+            return;
+        if (ok) {
+            const open = this.openFor(cmd);
+            if (open)
+                open.resolvedAt = opts.at;
+            return;
+        }
+        const clipped = cmd.length > exports.MAX_CMD_CHARS ? cmd.slice(0, exports.MAX_CMD_CHARS - 1) + '…' : cmd;
+        const open = this.openFor(cmd);
+        if (open) {
+            open.retests.push({ at: opts.at, command: clipped, ok: false });
+            if (open.retests.length > exports.MAX_RETESTS)
+                open.retests.splice(0, open.retests.length - exports.MAX_RETESTS);
+            return;
+        }
+        this.incidents.push({
+            id: this.nextId++,
+            command: clipped,
+            exitCode: opts.exitCode ?? null,
+            at: opts.at,
+            outputId: opts.outputId,
+            files: [],
+            retests: [],
+        });
+        if (this.incidents.length > exports.MAX_INCIDENTS)
+            this.incidents.splice(0, this.incidents.length - exports.MAX_INCIDENTS);
+    }
+    /** A mutating tool touched `path` — recorded only while something is actually broken. */
+    noteEdit(path) {
+        const open = this.lastUnresolved();
+        if (!open || !path)
+            return;
+        if (!open.files.includes(path))
+            open.files.push(path);
+        if (open.files.length > exports.MAX_FILES)
+            open.files.splice(0, open.files.length - exports.MAX_FILES);
+    }
+    /** The most recent incident with no successful same-family re-run. */
+    lastUnresolved() {
+        for (let i = this.incidents.length - 1; i >= 0; i--) {
+            if (!this.incidents[i].resolvedAt)
+                return this.incidents[i];
+        }
+        return undefined;
+    }
+    reset() {
+        this.incidents = [];
+        this.nextId = 1;
+    }
+    openFor(cmd) {
+        for (let i = this.incidents.length - 1; i >= 0; i--) {
+            const inc = this.incidents[i];
+            if (!inc.resolvedAt && sameCommandFamily(inc.command, cmd))
+                return inc;
+        }
+        return undefined;
+    }
+}
+exports.FailureLedger = FailureLedger;
+/**
+ * The §65 chain, one line per event, newest last:
+ *
+ *   ✗ npm test — exit 1 · 2m 4s in
+ *     ↳ edited src/util.ts, src/expr.ts
+ *     ↳ re-ran npm test — still failing
+ *     ✓ npm test — passed after 4m 10s
+ *
+ * Relative offsets, not wall-clock times: the transcript has no timestamps anywhere
+ * else, so "2m 4s in" is the only reading that means anything in context.
+ */
+function formatTimeline(inc, cols) {
+    const clip = (s) => (cols > 8 && s.length > cols ? s.slice(0, cols - 1) + '…' : s);
+    const lines = [];
+    const exit = inc.exitCode !== null ? `exit ${inc.exitCode}` : 'failed';
+    const resolved = inc.resolvedAt !== undefined;
+    lines.push(clip(`✗ ${inc.command} — ${exit}`));
+    if (inc.files.length)
+        lines.push(clip(`  ↳ edited ${inc.files.join(', ')}`));
+    for (const r of inc.retests) {
+        lines.push(clip(`  ↳ re-ran ${r.command} — still failing`));
+    }
+    if (resolved) {
+        const took = (0, duration_1.formatDuration)(inc.resolvedAt - inc.at);
+        lines.push(clip(`  ✓ ${inc.command} — passed after ${took}`));
+    }
+    else {
+        lines.push(clip(`  · still failing — nothing has re-run it successfully since`));
+    }
+    return lines;
+}
+/**
+ * The one line that names the rescue, printed under the timeline. `/failures` re-prints
+ * the whole chain later; Ctrl+O shows the failing command's full output (it is the last
+ * tool output when the turn ended on it); Ctrl+G opens a file.
+ */
+function rescueHint(inc, cols) {
+    const s = `Ctrl+F fix it automatically · Ctrl+O full output${inc.files.length ? ' · Ctrl+G open a file' : ''} · /failures again later`;
+    return cols > 8 && s.length > cols ? s.slice(0, cols - 1) + '…' : s;
+}
+/**
+ * The message Ctrl+F sends. It is NOT a pretend user message: it names itself, states the
+ * command and its exit code, and includes the last lines of the real output — so the
+ * model's next step is grounded in the failure even after a compaction dropped the body.
+ */
+function rescuePrompt(inc, outputTail, maxChars = 3000) {
+    const exit = inc.exitCode !== null ? ` (exit ${inc.exitCode})` : '';
+    const edited = inc.files.length ? `\nFiles touched since it broke: ${inc.files.join(', ')}.` : '';
+    const tail = outputTail.trim();
+    let body = `[failure rescue] The command \`${inc.command}\` failed${exit}${edited}\n\nFix it, re-run the same command to confirm, and continue.`;
+    if (tail) {
+        // The budget covers the fences too — they are part of what the model receives, and
+        // forgetting them is how a "600 char" limit shipped 637. The TAIL is what survives:
+        // the last line of a failing test run is the one that states the failure.
+        const open = '\n\nLast lines of the failure:\n```\n';
+        const close = '\n```';
+        const budget = maxChars - body.length - open.length - close.length;
+        if (budget > 0) {
+            const clipped = tail.length > budget ? tail.slice(tail.length - budget) : tail;
+            body += open + clipped + close;
+        }
+    }
+    return body;
+}
+/** `/failures` listing: every incident, newest first, with the chain inline. */
+function formatIncidents(ledger, cols) {
+    if (!ledger.incidents.length)
+        return ['No failing commands this session.'];
+    const out = [];
+    for (const inc of [...ledger.incidents].reverse()) {
+        out.push(...formatTimeline(inc, cols));
+    }
+    return out;
+}
+//# sourceMappingURL=failureTimeline.js.map

package/dist/verify/verification.d.ts

@@ -0,0 +1,75 @@
+export type CheckKind = 'typecheck' | 'unit' | 'integration' | 'lint' | 'build';
+export type CriterionId = CheckKind | 'diff';
+/** Canonical order — the panel, the criteria list and the summary all use it. */
+export declare const CHECK_KINDS: CheckKind[];
+export declare const CRITERION_LABELS: Record<CriterionId, string>;
+/**
+ * The kind of verification a check command performs, or undefined when it is a check
+ * (`npm run verify`, a bare `make ci`) whose kind cannot honestly be told apart.
+ *
+ * Scanned segment by segment so `cd app && npm test` classifies as `unit`, and the first
+ * segment that classifies wins (`npm run build && npm test` is a build run that also
+ * tested — calling it `unit` would hide the build, which is what the user is waiting on).
+ */
+export declare function classifyCheck(command: string): CheckKind | undefined;
+export interface CheckRun {
+    kind: CheckKind;
+    ok: boolean;
+    /** The command as typed, clipped for display. */
+    command: string;
+    at: number;
+    /** Test count parsed from the output, when the runner stated one. */
+    testsPassed?: number;
+}
+export declare class VerificationLedger {
+    private runs;
+    private diff;
+    /** Record one check result. The LATEST run of a kind wins — the panel is "as of now". */
+    note(kind: CheckKind, ok: boolean, command: string, at: number, testsPassed?: number): void;
+    /** `/diff` printed the changeset: the "reviewed the diff" box is now honestly tickable. */
+    noteDiffReviewed(): void;
+    get(kind: CheckKind): CheckRun | undefined;
+    /** Runs recorded at or after `at` — "what this TURN verified", for the §84 block. */
+    runsSince(at: number): CheckRun[];
+    reviewedDiff(): boolean;
+    reset(): void;
+}
+/** The most recent `N passed` a test runner printed, e.g. "12 passed", "2,341 tests passed". */
+export declare function parseTestsPassed(output: string): number | undefined;
+export interface ParsedCriteria {
+    /** Present when the argument SET new criteria (may be empty if every word was valid but repeated). */
+    criteria?: CriterionId[];
+    clear?: boolean;
+    unknown: string[];
+}
+/**
+ * `/accept unittests typecheck` — the words a user would naturally type. Anything not
+ * understood is reported instead of silently dropped: a criterion the user thinks is
+ * armed but is not would make the panel lie by omission.
+ */
+export declare function parseCriteria(arg: string): ParsedCriteria;
+export declare function canonicalOrder(ids: CriterionId[]): CriterionId[];
+export type CriterionStatus = 'pass' | 'fail' | 'pending';
+export declare function criterionStatus(ledger: VerificationLedger, id: CriterionId): CriterionStatus;
+export declare function unmetCriteria(ledger: VerificationLedger, criteria: CriterionId[]): CriterionId[];
+/**
+ * §83. With criteria declared, every criterion gets a line — the point of declaring them is
+ * to see the ones that have NOT passed. Without criteria, only what actually ran is shown:
+ * a fixed list of five partly-empty rows would train the user to ignore it.
+ */
+export declare function formatVerificationPanel(ledger: VerificationLedger, criteria: CriterionId[], opts: {
+    cols: number;
+    filesChanged?: number;
+}): string[];
+/**
+ * §82, one line for the END OF A TURN: "the agent should not claim completion until the
+ * configured checks pass". The CLI cannot police the model's prose, but it can make the
+ * unmet criteria impossible to miss — and say nothing at all when everything passed.
+ *
+ * Returns undefined when there is nothing worth saying (no criteria, all met, or — for
+ * the met case — `announce` is false because the panel already showed it).
+ */
+export declare function criteriaLine(ledger: VerificationLedger, criteria: CriterionId[], cols: number, announceMet?: boolean): string | undefined;
+/** `/accept` with no argument: what is declared, and where each one stands. */
+export declare function formatCriteriaList(ledger: VerificationLedger, criteria: CriterionId[], cols: number): string[];
+//# sourceMappingURL=verification.d.ts.map

package/dist/verify/verification.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verification.d.ts","sourceRoot":"","sources":["../../src/verify/verification.ts"],"names":[],"mappings":"AAkBA,MAAM,MAAM,SAAS,GAAG,WAAW,GAAG,MAAM,GAAG,aAAa,GAAG,MAAM,GAAG,OAAO,CAAC;AAChF,MAAM,MAAM,WAAW,GAAG,SAAS,GAAG,MAAM,CAAC;AAE7C,iFAAiF;AACjF,eAAO,MAAM,WAAW,EAAE,SAAS,EAA0D,CAAC;AAE9F,eAAO,MAAM,gBAAgB,EAAE,MAAM,CAAC,WAAW,EAAE,MAAM,CAOxD,CAAC;AAuBF;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS,CAOpE;AAoDD,MAAM,WAAW,QAAQ;IACvB,IAAI,EAAE,SAAS,CAAC;IAChB,EAAE,EAAE,OAAO,CAAC;IACZ,iDAAiD;IACjD,OAAO,EAAE,MAAM,CAAC;IAChB,EAAE,EAAE,MAAM,CAAC;IACX,qEAAqE;IACrE,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,IAAI,CAAkC;IAC9C,OAAO,CAAC,IAAI,CAAS;IAErB,yFAAyF;IACzF,IAAI,CAAC,IAAI,EAAE,SAAS,EAAE,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI;IAO3F,2FAA2F;IAC3F,gBAAgB,IAAI,IAAI;IAIxB,GAAG,CAAC,IAAI,EAAE,SAAS,GAAG,QAAQ,GAAG,SAAS;IAI1C,qFAAqF;IACrF,SAAS,CAAC,EAAE,EAAE,MAAM,GAAG,QAAQ,EAAE;IAMjC,YAAY,IAAI,OAAO;IAIvB,KAAK,IAAI,IAAI;CAId;AAED,gGAAgG;AAChG,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAKnE;AAgCD,MAAM,WAAW,cAAc;IAC7B,sGAAsG;IACtG,QAAQ,CAAC,EAAE,WAAW,EAAE,CAAC;IACzB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,cAAc,CAazD;AAID,wBAAgB,cAAc,CAAC,GAAG,EAAE,WAAW,EAAE,GAAG,WAAW,EAAE,CAEhE;AAED,MAAM,MAAM,eAAe,GAAG,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;AAE1D,wBAAgB,eAAe,CAAC,MAAM,EAAE,kBAAkB,EAAE,EAAE,EAAE,WAAW,GAAG,eAAe,CAK5F;AAED,wBAAgB,aAAa,CAAC,MAAM,EAAE,kBAAkB,EAAE,QAAQ,EAAE,WAAW,EAAE,GAAG,WAAW,EAAE,CAEhG;AAMD;;;;GAIG;AACH,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,kBAAkB,EAC1B,QAAQ,EAAE,WAAW,EAAE,EACvB,IAAI,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,YAAY,CAAC,EAAE,MAAM,CAAA;CAAE,GAC5C,MAAM,EAAE,CA8CV;AAED;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAC1B,MAAM,EAAE,kBAAkB,EAC1B,QAAQ,EAAE,WAAW,EAAE,EACvB,IAAI,EAAE,MAAM,EACZ,WAAW,UAAQ,GAClB,MAAM,GAAG,SAAS,CAUpB;AAED,+EAA+E;AAC/E,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,kBAAkB,EAAE,QAAQ,EAAE,WAAW,EAAE,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAoB9G"}