@workerstack/testing 0.0.0-stage → 0.31.0

package/dist/api/report/matrix/strips.d.ts

@@ -0,0 +1,5 @@
+/** The poster's strips: every cataloged check of the focus entity as a chip, grouped by strip. */
+import type { EntityMatrix } from "./types.ts";
+/** With several entities on the poster, only the chips that failed or stood down. */
+export declare function stripHtml(focus: EntityMatrix, multi: boolean): string;
+//# sourceMappingURL=strips.d.ts.map

package/dist/api/report/matrix/strips.js

@@ -0,0 +1,23 @@
+/** The poster's strips: every cataloged check of the focus entity as a chip, grouped by strip. */
+import { STRIPS } from "./catalog.js";
+import { nodeOf } from "./slice.js";
+import { esc } from "./text.js";
+/** With several entities on the poster, only the chips that failed or stood down. */
+export function stripHtml(focus, multi) {
+    return STRIPS.map((strip) => {
+        const chips = strip.ids
+            .map((id) => {
+            const node = nodeOf(focus, id);
+            if (multi && node.status !== "failed" && node.status !== "blocked")
+                return "";
+            const short = id.split(".").slice(1).join(".");
+            const title = node.because !== undefined ? `${id} — waiting on ${node.because}` : id;
+            return `<span class="chip ${node.status}" title="${esc(title)}">${esc(short)}</span>`;
+        })
+            .join("");
+        if (chips === "")
+            return "";
+        return `<div class="strip"><div class="strip-title">${esc(strip.title)}</div><div class="chips">${chips}</div></div>`;
+    }).join("");
+}
+//# sourceMappingURL=strips.js.map

package/dist/api/report/matrix/style.d.ts

@@ -0,0 +1,4 @@
+/** The poster's stylesheet: one dark sheet, the entity cards laid out in up to five columns. */
+/** The sheet for a poster of `entityCount` entities, one or more. */
+export declare function posterStyle(entityCount: number): string;
+//# sourceMappingURL=style.d.ts.map

package/dist/api/report/matrix/style.js

@@ -0,0 +1,103 @@
+/** The poster's stylesheet: one dark sheet, the entity cards laid out in up to five columns. */
+const BEFORE_CARDS = `  :root {
+    --bg: #243044;
+    --ink: #f2ead8;
+    --mute: #9aa3b2;
+    --line: #4a5870;
+    --passed: #7dcea0;
+    --fail: #ff6b3d;
+    --block: #6d7686;
+    --skip: #3d4758;
+    --pin: #f0c14b;
+    --card: #1b2332;
+  }
+  * { box-sizing: border-box; }
+  html, body { margin: 0; background: var(--bg); color: var(--ink); }
+  body { font-family: "IBM Plex Mono", ui-monospace, monospace; font-size: 13px; line-height: 1.45; }
+  .poster { width: 1440px; margin: 0 auto; padding: 32px 44px 36px; }
+  header {
+    display: grid;
+    grid-template-columns: 1fr auto;
+    gap: 24px;
+    align-items: end;
+    border-bottom: 1px solid var(--line);
+    padding-bottom: 16px;
+  }
+  .kicker { font-size: 11px; letter-spacing: 0.18em; text-transform: uppercase; color: var(--mute); }
+  h1 {
+    font-family: Syne, sans-serif;
+    font-weight: 800;
+    font-size: 38px;
+    line-height: 0.95;
+    letter-spacing: -0.03em;
+    margin: 8px 0 10px;
+  }
+  .thesis { color: var(--ink); max-width: 44em; }
+  .counts { display: grid; grid-template-columns: repeat(4, auto); gap: 18px 28px; text-align: right; }
+  .counts b { display: block; font-family: Syne, sans-serif; font-size: 28px; font-weight: 700; }
+  .counts span { color: var(--mute); font-size: 11px; letter-spacing: 0.08em; text-transform: uppercase; }
+  .counts .failed b { color: var(--fail); }
+  .counts .blocked b { color: var(--block); }
+  .counts .passed b { color: var(--passed); }
+  .band, .stage, .cards { margin-top: 18px; background: var(--card); border: 1px solid var(--line); }
+  .band-label, .stage-label {
+    color: var(--mute);
+    font-size: 11px;
+    letter-spacing: 0.14em;
+    text-transform: uppercase;
+    padding: 10px 16px 0;
+  }
+  svg { display: block; width: 100%; height: auto; }
+  .legend {
+    display: flex; gap: 22px; padding: 8px 16px 12px;
+    color: var(--mute); font-size: 11px; letter-spacing: 0.06em; text-transform: uppercase;
+  }
+  .swatch { display: inline-block; width: 10px; height: 10px; margin-right: 6px; vertical-align: -1px; }
+  .swatch.passed { background: var(--passed); }
+  .swatch.failed { background: var(--fail); }
+  .swatch.blocked { background: var(--block); box-shadow: inset 0 0 0 1px #9aa3b2; }
+  .swatch.skipped { background: var(--skip); }
+  .swatch.out-of-scope { background: transparent; box-shadow: inset 0 0 0 1px var(--skip); }
+  .forest { padding: 16px 20px 20px; }
+  .forest-lead { color: var(--mute); margin: 0 0 14px; }
+  .bar-row { display: grid; grid-template-columns: 80px 1fr 90px; gap: 12px; align-items: center; margin: 6px 0; }
+  .bar-name { color: var(--pin); }
+  .bar-track { height: 8px; background: #2c3546; }
+  .bar-fill { height: 8px; background: #ff6b3d; }
+  .bar-n { color: var(--mute); font-size: 11px; }
+  .bar-more { color: var(--mute); margin-top: 8px; }
+  .crowd-note { margin-top: 16px; color: var(--mute); }
+`;
+const AFTER_CARDS = `  .card { background: var(--card); padding: 14px 16px 16px; }
+  .card h2 { font-family: Syne, sans-serif; font-size: 18px; margin: 0 0 6px; }
+  .card .meta { color: var(--mute); font-size: 11px; margin-bottom: 10px; }
+  .dots { display: flex; gap: 5px; flex-wrap: wrap; }
+  .dot { width: 12px; height: 12px; border: 1px solid var(--line); }
+  .dot.passed { background: var(--passed); border-color: #3f6b55; }
+  .dot.failed { background: var(--fail); border-color: var(--fail); }
+  .dot.blocked { background: transparent; border-style: dashed; border-color: var(--block); }
+  .dot.skipped { background: var(--skip); }
+  .dot.out-of-scope { background: transparent; opacity: 0.4; }
+  .strips { margin-top: 18px; display: grid; gap: 10px; }
+  .strip { display: grid; grid-template-columns: 140px 1fr; gap: 12px; align-items: start; }
+  .strip-title { color: var(--mute); font-size: 11px; letter-spacing: 0.12em; text-transform: uppercase; padding-top: 6px; }
+  .chips { display: flex; flex-wrap: wrap; gap: 6px; }
+  .chip { border: 1px solid var(--line); padding: 3px 8px; color: var(--mute); }
+  .chip.passed { color: var(--passed); border-color: #3f6b55; }
+  .chip.failed { color: var(--fail); border-color: var(--fail); background: #3a221c; }
+  .chip.blocked { color: var(--block); border-style: dashed; }
+  .chip.skipped { opacity: 0.45; }
+  .chip.out-of-scope { opacity: 0.25; border-style: dotted; }
+  footer {
+    margin-top: 18px; color: var(--mute); font-size: 11px;
+    display: flex; justify-content: space-between; gap: 16px;
+    border-top: 1px solid var(--line); padding-top: 12px;
+  }
+  footer code { color: var(--ink); }
+`;
+/** The sheet for a poster of `entityCount` entities, one or more. */
+export function posterStyle(entityCount) {
+    const cards = `  .cards { display: grid; grid-template-columns: repeat(${Math.min(entityCount, 5)}, minmax(200px, 1fr)); gap: 1px; background: var(--line); border: 1px solid var(--line); }`;
+    return `${BEFORE_CARDS}${cards}\n${AFTER_CARDS}`;
+}
+//# sourceMappingURL=style.js.map

package/dist/api/report/matrix/summary.d.ts

@@ -0,0 +1,8 @@
+/** What the whole matrix says: totals across entities, a one-line summary, and the thesis. */
+import type { CellStatus, EntityMatrix, InvalidateLink } from "./types.ts";
+export declare function totalCounts(entities: readonly EntityMatrix[]): Record<CellStatus, number>;
+/** The summary line. `cross` is the cross-entity links only. */
+export declare function summaryLine(entities: readonly EntityMatrix[], counts: Record<CellStatus, number>, cross: readonly InvalidateLink[]): string;
+/** The poster's thesis. `cross` is the cross-entity links only. */
+export declare function thesisFor(entities: readonly EntityMatrix[], cross: readonly InvalidateLink[]): string;
+//# sourceMappingURL=summary.d.ts.map

package/dist/api/report/matrix/summary.js

@@ -0,0 +1,49 @@
+/** What the whole matrix says: totals across entities, a one-line summary, and the thesis. */
+import { unique } from "./text.js";
+export function totalCounts(entities) {
+    const counts = { blocked: 0, failed: 0, passed: 0, "out-of-scope": 0, skipped: 0 };
+    for (const entity of entities) {
+        for (const status of Object.keys(counts))
+            counts[status] += entity.counts[status];
+    }
+    return counts;
+}
+/** The summary line. `cross` is the cross-entity links only. */
+export function summaryLine(entities, counts, cross) {
+    const names = entities.map((e) => e.name);
+    const rootList = entities.flatMap((e) => e.roots.map((id) => `${e.name}:${id}`));
+    const who = names.length > 12 ? `${names.length} entities` : names.join(", ");
+    return (`${who}: ${counts.failed} failed, ${counts.blocked} blocked, ${counts.passed} passed, ${counts.skipped} skipped` +
+        (counts["out-of-scope"] > 0 ? `, ${counts["out-of-scope"]} out of scope.` : ".") +
+        crossSentence(cross) +
+        (rootList.length > 0 && rootList.length <= 8 ? ` Roots: ${rootList.join(", ")}.` : ""));
+}
+function crossSentence(cross) {
+    if (cross.length > 8) {
+        return ` ${unique(cross.map((l) => l.toEntity)).length} parents receive ${cross.length} cross-entity claims.`;
+    }
+    if (cross.length > 0) {
+        return ` Cross-entity invalidate: ${unique(cross.map((l) => `${l.fromEntity} → ${l.toEntity}`)).join(", ")}.`;
+    }
+    return " No cross-entity invalidate.";
+}
+/** The poster's thesis. `cross` is the cross-entity links only. */
+export function thesisFor(entities, cross) {
+    const failed = entities.find((e) => e.counts.failed > 0);
+    if (failed !== undefined) {
+        return `${failed.name} had a check that disagreed. Composition checks that depend on it stood down — not extra defects.`;
+    }
+    if (entities.length === 1 && cross.length === 0) {
+        return "One entity. Invalidate stays on its own read surface, so the cross-entity check did not apply.";
+    }
+    if (cross.length > 0) {
+        const parents = unique(cross.map((l) => l.toEntity));
+        if (cross.length > 8) {
+            return `${entities.length} entities. ${parents.length} parents receive child writes (${cross.length} claims) — tested, not believed.`;
+        }
+        const pairs = unique(cross.map((l) => `${l.fromEntity} writes must change ${l.toEntity}`));
+        return `${entities.length} entities. ${pairs.join("; ")} — that claim was tested, not believed.`;
+    }
+    return `${entities.length} entities. Every check that applied agreed.`;
+}
+//# sourceMappingURL=summary.js.map

package/dist/api/report/matrix/text.d.ts

@@ -0,0 +1,6 @@
+/** Text helpers the matrix's renderers share. */
+/** `value` safe inside HTML text and a double-quoted attribute. */
+export declare function esc(value: string): string;
+/** `values` without repeats, in first-seen order. */
+export declare function unique(values: string[]): string[];
+//# sourceMappingURL=text.d.ts.map

package/dist/api/report/matrix/text.js

@@ -0,0 +1,10 @@
+/** Text helpers the matrix's renderers share. */
+/** `value` safe inside HTML text and a double-quoted attribute. */
+export function esc(value) {
+    return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
+}
+/** `values` without repeats, in first-seen order. */
+export function unique(values) {
+    return [...new Set(values)];
+}
+//# sourceMappingURL=text.js.map

package/dist/api/report/matrix/types.d.ts

@@ -0,0 +1,149 @@
+/**
+ * The shapes of the run's matrix: the poster's per-entity view, the machine graph, and what the
+ * matrix reads of a report.
+ */
+import type { REPORT_SCHEMA_VERSION } from "../render/json.ts";
+/** `out-of-scope`: a targeted run (`--ops`) did not ask for it — it could apply, it was not graded. */
+export type CellStatus = "passed" | "failed" | "blocked" | "skipped" | "out-of-scope";
+export type MatrixLayer = "axis" | "composition" | "surface" | "auth" | "schema" | "spec";
+export interface MatrixView {
+    entity: string;
+    baseUrl: string;
+    generatedAt: string;
+    readSurface: string[];
+    failed: number;
+    blocked: number;
+    passed: number;
+    skipped: number;
+    nodes: MatrixNode[];
+}
+export interface MatrixNode {
+    id: string;
+    label: string;
+    hint: string;
+    status: CellStatus;
+    because?: string;
+}
+export interface MatrixGraphNode {
+    id: string;
+    group: string;
+    layer: MatrixLayer;
+    status: CellStatus;
+    needs?: string;
+    because?: string;
+    summary?: string;
+    verdict?: string;
+}
+export interface MatrixGraphEdge {
+    from: string;
+    to: string;
+    /** `dependsOn`: if `from` failed, `to` is blocked. `uses`: a composition check built from `from`. */
+    kind: "dependsOn" | "uses";
+}
+export interface InvalidateLink {
+    fromEntity: string;
+    fromOp: string;
+    toEntity: string;
+    toRoute: string;
+    /** True when the declared route belongs to a *different* entity — the case the check probes. */
+    cross: boolean;
+}
+export interface EntityMatrix {
+    name: string;
+    identity: string | null;
+    readSurface: string[];
+    counts: Record<CellStatus, number>;
+    roots: string[];
+    nodes: MatrixGraphNode[];
+}
+export interface MatrixGraph {
+    kind: "testing.api.matrix";
+    /** The same version `report.json` states. */
+    schemaVersion: typeof REPORT_SCHEMA_VERSION;
+    read: {
+        purpose: string;
+        status: Record<CellStatus, string>;
+        edges: Record<MatrixGraphEdge["kind"] | "invalidate", string>;
+    };
+    baseUrl: string;
+    generatedAt: string;
+    thesis: string;
+    summary: string;
+    index: {
+        entityCount: number;
+        failed: string[];
+        parents: string[];
+        crossClaims: number;
+        inbound: Record<string, number>;
+    };
+    counts: Record<CellStatus, number>;
+    entities: EntityMatrix[];
+    invalidate: InvalidateLink[];
+    edges: MatrixGraphEdge[];
+    mermaid: string;
+}
+/** A report row about one check, on one entity or (naming none) on every entity. */
+export interface CheckRow {
+    check: string;
+    entity?: string;
+}
+export interface MatrixFinding extends CheckRow {
+    verdict: string;
+    summary: string;
+    detail?: string;
+    /** Set on a finding from a secondary origin. */
+    origin?: string;
+}
+/** The report lists the matrix reads: what ran, what stood down, what was found. */
+export interface MatrixRows {
+    checksRun: readonly string[];
+    checksSkipped: ReadonlyArray<CheckRow & {
+        needs: string;
+    }>;
+    checksSuppressed: ReadonlyArray<CheckRow & {
+        because: string;
+    }>;
+    checksOutOfScope?: readonly CheckRow[];
+    findings: readonly MatrixFinding[];
+}
+/** One entity's matrix, given piece by piece. */
+export interface MatrixParts extends MatrixRows {
+    entity: string;
+    baseUrl: string;
+    generatedAt: string;
+    readSurface: string[];
+}
+/** What the matrix reads of the document's model: `SpecModel` satisfies it. */
+export interface MatrixModel {
+    entities: ReadonlyMap<string, {
+        name: string;
+        identity: string | null;
+        readSurface: string[];
+    }>;
+    operations: ReadonlyArray<{
+        operationId: string;
+        entity: string | null;
+        invalidates: readonly string[];
+    }>;
+    byRoute: ReadonlyMap<string, {
+        entity: string | null;
+    }>;
+}
+/** What the matrix reads of a run's report: `ReportInput` satisfies it. */
+export interface MatrixReport {
+    baseUrl: string;
+    startedAt: Date;
+    entitiesTested: readonly string[];
+    checksRun: readonly string[];
+    checksSkipped?: MatrixRows["checksSkipped"];
+    checksSuppressed?: MatrixRows["checksSuppressed"];
+    checksOutOfScope?: readonly CheckRow[];
+    findings: readonly MatrixFinding[];
+    model: MatrixModel;
+}
+/** A point on a poster drawing. */
+export interface Point {
+    x: number;
+    y: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/api/report/matrix/types.js

@@ -0,0 +1,6 @@
+/**
+ * The shapes of the run's matrix: the poster's per-entity view, the machine graph, and what the
+ * matrix reads of a report.
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/api/report/matrix/view.d.ts

@@ -0,0 +1,6 @@
+/** One entity's matrix as the poster's cells: the read, item, axis and composition checks, in order. */
+import type { MatrixParts, MatrixReport, MatrixView } from "./types.ts";
+/** The first entity the run tested; a report that tested none draws a placeholder `entity`. */
+export declare function matrixViewFromReport(input: MatrixReport): MatrixView;
+export declare function matrixViewFromParts(parts: MatrixParts): MatrixView;
+//# sourceMappingURL=view.d.ts.map

package/dist/api/report/matrix/view.js

@@ -0,0 +1,41 @@
+/** One entity's matrix as the poster's cells: the read, item, axis and composition checks, in order. */
+import { checkCatalog, NODE_ORDER } from "./catalog.js";
+import { reportRows, rowsOfReport } from "./rows.js";
+import { entitySlice, nodeOf } from "./slice.js";
+/** The first entity the run tested; a report that tested none draws a placeholder `entity`. */
+export function matrixViewFromReport(input) {
+    const entity = input.entitiesTested[0] ?? "entity";
+    return matrixViewFromParts({
+        ...rowsOfReport(input),
+        baseUrl: input.baseUrl,
+        entity,
+        generatedAt: input.startedAt.toISOString(),
+        readSurface: input.model.entities.get(entity)?.readSurface ?? [],
+    });
+}
+export function matrixViewFromParts(parts) {
+    const entity = { identity: null, name: parts.entity, readSurface: parts.readSurface };
+    const slice = entitySlice(entity, checkCatalog(), reportRows(parts));
+    const nodes = NODE_ORDER.map((spec) => {
+        const { because, status } = nodeOf(slice, spec.id);
+        const node = { hint: spec.hint, id: spec.id, label: spec.label, status };
+        /* A blocked cell stood down for a suppressed row, and the slice carries that row's cause. */
+        if (status === "blocked")
+            node.because = because;
+        if (status === "failed")
+            node.hint = "disagreed";
+        return node;
+    });
+    return {
+        baseUrl: parts.baseUrl,
+        blocked: slice.counts.blocked,
+        entity: parts.entity,
+        failed: slice.counts.failed,
+        generatedAt: parts.generatedAt,
+        passed: slice.counts.passed,
+        nodes,
+        readSurface: parts.readSurface,
+        skipped: slice.counts.skipped,
+    };
+}
+//# sourceMappingURL=view.js.map

package/dist/api/report/render/coverage.d.ts

@@ -0,0 +1,29 @@
+import type { ReportInput } from "./input.ts";
+/** How far one check got across the tested entities. */
+export interface CheckCoverage {
+    check: string;
+    needs: string;
+    ran: number;
+    skipped: number;
+    blocked: number;
+    skippedEntities: string[];
+    blockedEntities: string[];
+}
+/** Per check, how far it got: the three ways a check falls short of running everywhere. */
+export interface Coverage {
+    never: CheckCoverage[];
+    partialSkip: CheckCoverage[];
+    blocked: CheckCoverage[];
+}
+/**
+ * The checks that did not run everywhere: never applicable, applicable only on some entities, or
+ * blocked by an earlier failure. Sorted by check id.
+ */
+export declare function coverageByCheck(input: ReportInput): Coverage;
+/**
+ * One line naming what `--profile` narrowed and why — silently shrinking coverage is the failure
+ * mode to avoid, so a gated run says exactly what it skipped, the same way a coverage gap does.
+ * `null` on the default `"full"` profile with nothing excluded: nothing to say.
+ */
+export declare function profileExclusionSummary(input: ReportInput): string | null;
+//# sourceMappingURL=coverage.d.ts.map

package/dist/api/report/render/coverage.js

@@ -0,0 +1,78 @@
+/**
+ * The checks that did not run everywhere: never applicable, applicable only on some entities, or
+ * blocked by an earlier failure. Sorted by check id.
+ */
+export function coverageByCheck(input) {
+    const tested = input.entitiesTested.length;
+    const rows = new Map();
+    const row = (check, needs) => {
+        const existing = rows.get(check);
+        if (existing !== undefined)
+            return existing;
+        const created = {
+            blocked: 0,
+            blockedEntities: [],
+            check,
+            needs,
+            ran: 0,
+            skipped: 0,
+            skippedEntities: [],
+        };
+        rows.set(check, created);
+        return created;
+    };
+    for (const entry of input.checksSkipped ?? []) {
+        const current = row(entry.check, entry.needs);
+        current.skipped += 1;
+        current.skippedEntities.push(entry.entity);
+    }
+    for (const entry of input.checksSuppressed ?? []) {
+        const current = row(entry.check, "a check it depends on already failed");
+        current.blocked += 1;
+        current.blockedEntities.push(entry.entity);
+    }
+    const outOfScope = new Map();
+    for (const entry of input.checksOutOfScope ?? [])
+        outOfScope.set(entry.check, (outOfScope.get(entry.check) ?? 0) + 1);
+    for (const current of rows.values()) {
+        current.ran = Math.max(0, tested - current.skipped - current.blocked - (outOfScope.get(current.check) ?? 0));
+    }
+    const all = [...rows.values()].sort((a, b) => a.check.localeCompare(b.check));
+    /*
+     * A check that reached a verdict anywhere applied there, even one judged per operation rather than
+     * per entity: it graded an operation, reported a finding, or could not conclude. Being planned is
+     * not enough: a check is run even where it stands down everywhere.
+     */
+    const ranAnywhere = new Set([
+        ...input.findings.map((finding) => finding.check),
+        ...(input.inconclusive ?? []).map((entry) => entry.check),
+        ...(input.scope?.operations ?? []).flatMap((op) => [...op.checks.passed, ...op.checks.failed]),
+    ]);
+    const applied = (item) => item.ran > 0 || ranAnywhere.has(item.check);
+    return {
+        blocked: all.filter((item) => item.blocked > 0),
+        never: all.filter((item) => !applied(item) && item.blocked === 0 && item.skipped > 0),
+        partialSkip: all.filter((item) => applied(item) && item.skipped > 0),
+    };
+}
+/**
+ * One line naming what `--profile` narrowed and why — silently shrinking coverage is the failure
+ * mode to avoid, so a gated run says exactly what it skipped, the same way a coverage gap does.
+ * `null` on the default `"full"` profile with nothing excluded: nothing to say.
+ */
+export function profileExclusionSummary(input) {
+    const exclusions = input.profileExclusions ?? [];
+    if (exclusions.length === 0)
+        return null;
+    const highCost = exclusions.filter((e) => e.reason.startsWith("x-cost")).length;
+    const destructive = exclusions.filter((e) => e.reason === "x-destructive").length;
+    const byName = exclusions.length - highCost - destructive;
+    const parts = [
+        highCost > 0 ? `${highCost} high-cost` : null,
+        destructive > 0 ? `${destructive} destructive` : null,
+        byName > 0 ? `${byName} excluded by name` : null,
+    ].filter((part) => part !== null);
+    /* The three counts sum to the exclusions, so at least one part is there. */
+    return `skipped ${exclusions.length} operation(s) under --profile ${input.profile ?? "?"} (${parts.join(", ")})`;
+}
+//# sourceMappingURL=coverage.js.map

package/dist/api/report/render/input.d.ts

@@ -0,0 +1,88 @@
+import type { Client } from "../../client/client.ts";
+import type { BaselineEntry } from "../../runtime/baseline.ts";
+import type { FencedRequest } from "../../runtime/fence.ts";
+import type { Finding } from "../../runtime/finding.ts";
+import type { CheckTiming } from "../../runtime/run/index.ts";
+import type { ScopeReport } from "../../runtime/scope/types.ts";
+import type { TargetVersion } from "../../runtime/target-version.ts";
+import type { TeardownReport } from "../../runtime/teardown/types.ts";
+import type { SpecModel } from "../../spec/graph/types.ts";
+/** A finished run as every report renderer reads it. */
+export interface ReportInput {
+    findings: Finding[];
+    /** What the unwind removed and left, record by record. Absent when nothing was torn down. */
+    teardown?: TeardownReport | null;
+    model: SpecModel;
+    client: Client;
+    baseUrl: string;
+    entitiesTested: string[];
+    checksRun: string[];
+    checksSkipped?: Array<{
+        check: string;
+        entity: string;
+        needs: string;
+    }>;
+    /** Checks not run because a check they depend on was already reported broken. */
+    checksSuppressed?: Array<{
+        check: string;
+        entity: string;
+        because: string;
+    }>;
+    /** Checks a targeted run did not run on an entity because none of their subjects is a target. */
+    checksOutOfScope?: Array<{
+        check: string;
+        entity: string;
+    }>;
+    /** What the run graded, per operation. */
+    scope?: ScopeReport;
+    /** Checks that ran but could not reach a verdict, with the reason they stopped. */
+    inconclusive?: Array<{
+        check: string;
+        entity: string;
+        reason: string;
+        operations?: string[];
+    }>;
+    /** Active profile's name — `"full"` unless `--profile` / `config.profile` said otherwise. */
+    profile?: string;
+    /** Operations a profile excluded, and why. Silently narrowing coverage is the failure to avoid. */
+    profileExclusions?: Array<{
+        entity: string;
+        operationId: string;
+        reason: string;
+    }>;
+    startedAt: Date;
+    durationMs: number;
+    /** Journal size when exchanges were persisted next to this report. */
+    exchanges?: {
+        count: number;
+    };
+    /** How long each check took on each entity. */
+    checkTimings?: CheckTiming[];
+    /** What passing checks observed about policies the document leaves open. */
+    checkNotes?: Array<{
+        check: string;
+        entity: string;
+        note: string;
+    }>;
+    network?: {
+        kind: string;
+        attempts: number;
+        waitedMs: number;
+        incomplete: boolean;
+        url: string;
+    };
+    /** Requests `hooks.beforeRequest` refused, and whether that alone fails the run. */
+    fenced?: {
+        requests: FencedRequest[];
+        failRun: boolean;
+    };
+    /** A signal stopped the run before it finished; what it did test is still reported. */
+    interrupted?: boolean;
+    /** Baseline entries no finding matched any more. Absent with no baseline. */
+    baseline?: {
+        fixed: BaselineEntry[];
+    };
+    /** The build this run tested, or why it could not be read. */
+    targetVersion?: TargetVersion;
+}
+//# sourceMappingURL=input.d.ts.map

package/dist/api/report/render/input.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=input.js.map

package/dist/api/report/render/json.d.ts

@@ -0,0 +1,9 @@
+import type { ReportInput } from "./input.ts";
+/**
+ * The shape version of `report.json` and `matrix.json`. It rises only on a breaking change to a
+ * file's shape; an added field is not one.
+ */
+export declare const REPORT_SCHEMA_VERSION = 1;
+/** Machine-readable output for CI gating and diffing between runs. */
+export declare function renderJson(input: ReportInput): string;
+//# sourceMappingURL=json.d.ts.map