@transitrix/diagrams 1.0.0

package/dist/compliance/html.js

@@ -0,0 +1,256 @@
+// HTML renderers for the compliance views (vkgeorgia/strategy#84 Phase 5,
+// PDF follow-on). Pure string builders — fed to WeasyPrint by the
+// `transitrix export-compliance --format pdf` path in src/export-compliance.ts.
+//
+// Each entry point returns a complete, self-contained HTML document (no
+// external assets) so WeasyPrint reads the whole brief on stdin. CSS is
+// inlined; the page rules target A4 portrait with branded header and footer.
+// Status colours mirror the Studio preview palette (see compliance-render.ts)
+// so the export and the in-editor view stay visually consistent.
+import { buildComplianceMatrix } from '../compliance-matrix/index.js';
+import { buildComplianceIndex } from './reverse-index.js';
+import { buildLawTree, buildProductView } from './views.js';
+import { buildGapReport } from './gap-report.js';
+const STATUS_LABELS = {
+    compliant: 'Compliant',
+    partial: 'Partial',
+    non_compliant: 'Non-compliant',
+    under_review: 'Under review',
+    n_a: 'N/A',
+};
+function escHtml(s) {
+    return s
+        .replace(/&/g, '&')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;');
+}
+function badge(status) {
+    return `<span class="cmp-badge cmp-${status}">${escHtml(STATUS_LABELS[status])}</span>`;
+}
+// A4 portrait with 18mm margins — matches the WeasyPrint one-pager template
+// the site uses. Brand colour `#004d67` mirrors `--ts-brand-primary` from
+// extension/src/compliance-render.ts so the PDF and the Studio preview agree.
+const CSS = `
+@page {
+  size: A4 portrait;
+  margin: 18mm 16mm 22mm;
+  @bottom-left { content: "Transitrix — compliance report"; font: 9pt "Helvetica", "Arial", sans-serif; color: #475569; }
+  @bottom-right { content: "Page " counter(page) " / " counter(pages); font: 9pt "Helvetica", "Arial", sans-serif; color: #475569; }
+}
+html, body { margin: 0; padding: 0; }
+body { font-family: "Helvetica", "Arial", sans-serif; font-size: 10pt; color: #0f172a; line-height: 1.4; }
+.cmp-header { border-bottom: 2px solid #004d67; padding-bottom: 6pt; margin-bottom: 14pt; }
+.cmp-header .cmp-eyebrow { font-size: 8.5pt; letter-spacing: 0.08em; text-transform: uppercase; color: #004d67; font-weight: 700; }
+.cmp-header h1 { font-size: 17pt; margin: 2pt 0 4pt; color: #0f172a; }
+.cmp-header .cmp-stamp { font-size: 9pt; color: #475569; }
+h2 { font-size: 12pt; margin: 16pt 0 6pt; color: #0f172a; page-break-after: avoid; }
+h2 .cmp-count { color: #64748b; font-weight: 400; font-size: 10pt; }
+p.cmp-empty { color: #64748b; font-style: italic; }
+table { border-collapse: collapse; width: 100%; font-size: 9.5pt; margin-bottom: 10pt; }
+th, td { border: 0.5pt solid #cbd5e1; padding: 4pt 6pt; text-align: left; vertical-align: top; }
+th { background: #f1f5f9; font-weight: 700; color: #0f172a; }
+table.cmp-matrix th:first-child, table.cmp-matrix td:first-child { background: #f8fafc; font-weight: 600; }
+code, .cmp-id { font-family: "Menlo", "Consolas", monospace; font-size: 9pt; color: #475569; }
+.cmp-badge { display: inline-block; padding: 1pt 6pt; border-radius: 8pt; font-size: 8.5pt; font-weight: 700; }
+.cmp-compliant { background: #d1fae5; color: #065f46; }
+.cmp-partial { background: #fef9c3; color: #854d0e; }
+.cmp-non_compliant { background: #fee2e2; color: #991b1b; }
+.cmp-under_review { background: #e0f2fe; color: #0c4a6e; }
+.cmp-n_a { background: #f1f5f9; color: #64748b; }
+.cmp-cell-gap { color: #94a3b8; text-align: center; }
+.cmp-req { border: 0.5pt solid #cbd5e1; border-radius: 3pt; margin-bottom: 8pt; page-break-inside: avoid; }
+.cmp-req-head { background: #f1f5f9; padding: 5pt 8pt; }
+.cmp-req-head .cmp-req-name { font-weight: 700; color: #0f172a; }
+.cmp-req-head .cmp-req-id { margin-left: 6pt; color: #475569; font-size: 9pt; font-family: "Menlo", "Consolas", monospace; }
+.cmp-sev { font-size: 8pt; text-transform: uppercase; letter-spacing: 0.06em; margin-left: 8pt; }
+.cmp-sev-high { color: #b91c1c; }
+.cmp-sev-medium { color: #b45309; }
+.cmp-sev-low { color: #2563eb; }
+.cmp-assertions { list-style: none; margin: 0; padding: 0; }
+.cmp-assertions li { padding: 4pt 8pt 4pt 16pt; border-top: 0.5pt solid #e2e8f0; }
+.cmp-assertions li .cmp-meta { color: #475569; font-size: 8.5pt; margin-left: 6pt; }
+.cmp-section { margin-bottom: 12pt; }
+.cmp-rows { list-style: none; margin: 0; padding: 0; }
+.cmp-rows li { padding: 3pt 0 3pt 14pt; border-bottom: 0.5pt solid #e2e8f0; text-indent: -10pt; }
+.cmp-rows li::before { content: "☐"; color: #94a3b8; margin-right: 6pt; }
+.cmp-ok { color: #065f46; font-weight: 600; }
+.cmp-summary { font-size: 9pt; color: #475569; }
+`;
+function htmlDoc(title, today, body) {
+    const stamp = today ? `Generated ${escHtml(today)}` : '';
+    return [
+        '<!doctype html>',
+        '<html lang="en">',
+        '<head>',
+        '<meta charset="utf-8"/>',
+        `<title>${escHtml(title)}</title>`,
+        `<style>${CSS}</style>`,
+        '</head>',
+        '<body>',
+        '<header class="cmp-header">',
+        '<div class="cmp-eyebrow">Transitrix · Compliance</div>',
+        `<h1>${escHtml(title)}</h1>`,
+        stamp ? `<div class="cmp-stamp">${stamp}</div>` : '',
+        '</header>',
+        body,
+        '</body>',
+        '</html>',
+        '',
+    ].join('\n');
+}
+/** Renders the requested compliance view from a scanned canon to a complete HTML document. */
+export function renderComplianceHtml(canon, scope, options = {}) {
+    switch (scope.mode) {
+        case 'matrix': {
+            const m = buildComplianceMatrix({ products: canon.products, requirements: canon.requirements, assertions: canon.assertions });
+            const title = options.title ?? 'Compliance Matrix';
+            const summary = `<p class="cmp-summary">${m.summary.products} products × ${m.summary.requirements} requirements · ${m.summary.gaps} gaps · ${m.summary.assertions} assertions</p>`;
+            if (m.products.length === 0 || m.requirements.length === 0) {
+                return htmlDoc(title, options.today, `${summary}<p class="cmp-empty">No products or requirements found in the scanned canon.</p>`);
+            }
+            const head = `<tr><th>Product \\ Requirement</th>${m.requirements.map(r => `<th>${escHtml(r.name)}</th>`).join('')}</tr>`;
+            const rows = m.products.map((p, ri) => {
+                const cells = m.requirements.map((_r, ci) => {
+                    const c = m.cells[ri][ci];
+                    return c.status ? `<td>${badge(c.status)}</td>` : '<td class="cmp-cell-gap">—</td>';
+                }).join('');
+                const name = escHtml(p.name) + (p.unresolved ? ' <span class="cmp-sev cmp-sev-high">unresolved</span>' : '');
+                return `<tr><td>${name}</td>${cells}</tr>`;
+            }).join('');
+            return htmlDoc(title, options.today, `${summary}<table class="cmp-matrix"><thead>${head}</thead><tbody>${rows}</tbody></table>`);
+        }
+        case 'law': {
+            const index = buildComplianceIndex({ requirements: canon.requirements, assertions: canon.assertions });
+            const tree = buildLawTree(scope.id, index);
+            const law = canon.codex.find(c => c.id === scope.id);
+            const title = options.title ?? `Compliance — ${law ? law.name : scope.id}`;
+            const summary = `<p class="cmp-summary"><code>${escHtml(scope.id)}</code> · ${tree.requirements.length} requirement(s)</p>`;
+            if (tree.requirements.length === 0) {
+                return htmlDoc(title, options.today, `${summary}<p class="cmp-empty">No requirements derive from <code>${escHtml(scope.id)}</code>.</p>`);
+            }
+            const blocks = tree.requirements.map(node => {
+                const sev = node.requirement.severity ? ` <span class="cmp-sev cmp-sev-${escHtml(node.requirement.severity)}">${escHtml(node.requirement.severity)}</span>` : '';
+                const head = `<div class="cmp-req-head"><span class="cmp-req-name">${escHtml(node.requirement.name)}</span><span class="cmp-req-id">${escHtml(node.requirement.id)}</span>${sev}</div>`;
+                if (node.assertions.length === 0) {
+                    return `<section class="cmp-req">${head}<ul class="cmp-assertions"><li><em>No assertion — compliance gap.</em></li></ul></section>`;
+                }
+                const items = node.assertions.map(a => {
+                    const metaParts = [];
+                    if (a.assessed_at)
+                        metaParts.push(`assessed ${escHtml(a.assessed_at)}`);
+                    if (a.next_review_at)
+                        metaParts.push(`review by ${escHtml(a.next_review_at)}`);
+                    const meta = metaParts.length > 0 ? `<span class="cmp-meta">${metaParts.join(' · ')}</span>` : '';
+                    return `<li>${badge(a.status)} <code>${escHtml(a.id)}</code> <span class="cmp-meta">subject <code>${escHtml(a.subject)}</code></span> ${meta}</li>`;
+                }).join('');
+                return `<section class="cmp-req">${head}<ul class="cmp-assertions">${items}</ul></section>`;
+            }).join('');
+            return htmlDoc(title, options.today, `${summary}${blocks}`);
+        }
+        case 'product': {
+            const index = buildComplianceIndex({ requirements: canon.requirements, assertions: canon.assertions });
+            const view = buildProductView(scope.id, index);
+            const product = canon.products.find(p => p.id === scope.id);
+            const title = options.title ?? `Compliance — ${product ? product.name : scope.id}`;
+            const summary = `<p class="cmp-summary"><code>${escHtml(scope.id)}</code> · ${view.requirements.length} requirement(s) asserted</p>`;
+            if (view.requirements.length === 0) {
+                return htmlDoc(title, options.today, `${summary}<p class="cmp-empty">No assertion names this product as its subject.</p>`);
+            }
+            const rows = view.requirements.map(({ requirement, assertion }) => (`<tr>` +
+                `<td>${escHtml(requirement.name)} <code>${escHtml(requirement.id)}</code></td>` +
+                `<td>${badge(assertion.status)}</td>` +
+                `<td><code>${escHtml(assertion.id)}</code></td>` +
+                `<td>${assertion.next_review_at ? escHtml(assertion.next_review_at) : '—'}</td>` +
+                `</tr>`)).join('');
+            const head = '<tr><th>Requirement</th><th>Status</th><th>Assertion</th><th>Next review</th></tr>';
+            return htmlDoc(title, options.today, `${summary}<table><thead>${head}</thead><tbody>${rows}</tbody></table>`);
+        }
+        case 'gap': {
+            const index = buildComplianceIndex({ requirements: canon.requirements, assertions: canon.assertions });
+            const report = buildGapReport(index, { today: options.today });
+            const title = options.title ?? 'Compliance Gap Dashboard';
+            const total = report.requirementsWithoutAssertions.length + report.assertionsWithoutEvidence.length + report.staleAssertions.length;
+            const summary = `<p class="cmp-summary">${total} gap(s)</p>`;
+            const section = (heading, count, items) => {
+                const body = items.length === 0
+                    ? '<p class="cmp-ok">✓ none</p>'
+                    : `<ul class="cmp-rows">${items.join('')}</ul>`;
+                return `<section class="cmp-section"><h2>${escHtml(heading)} <span class="cmp-count">(${count})</span></h2>${body}</section>`;
+            };
+            const reqs = report.requirementsWithoutAssertions.map(r => (`<li><code>${escHtml(r.id)}</code> ${escHtml(r.name)}${r.severity ? ` <span class="cmp-meta">severity ${escHtml(r.severity)}</span>` : ''}${r.deadline ? ` <span class="cmp-meta">deadline ${escHtml(r.deadline)}</span>` : ''}</li>`));
+            const noEvidence = report.assertionsWithoutEvidence.map(a => (`<li><code>${escHtml(a.id)}</code> <span class="cmp-meta">about <code>${escHtml(a.about)}</code>, subject <code>${escHtml(a.subject)}</code>, status ${escHtml(a.status)}</span></li>`));
+            const stale = report.staleAssertions.map(a => (`<li><code>${escHtml(a.id)}</code> <span class="cmp-meta">review due ${a.next_review_at ? escHtml(a.next_review_at) : '—'}, subject <code>${escHtml(a.subject)}</code></span></li>`));
+            const pastDl = report.pastDeadlineRequirements.map(r => (`<li><code>${escHtml(r.id)}</code> ${escHtml(r.name)} <span class="cmp-meta">deadline ${r.deadline ? escHtml(r.deadline) : '—'}${r.severity ? `, severity ${escHtml(r.severity)}` : ''}</span></li>`));
+            const total4 = report.requirementsWithoutAssertions.length + report.assertionsWithoutEvidence.length + report.staleAssertions.length + report.pastDeadlineRequirements.length;
+            const body = [
+                `<p class="cmp-summary">${total4} gap(s) across 4 checks</p>`,
+                section('Requirements without assertions', report.requirementsWithoutAssertions.length, reqs),
+                section('Assertions without evidence — ASSERT-007', report.assertionsWithoutEvidence.length, noEvidence),
+                section('Stale assertions — ASSERT-008', report.staleAssertions.length, stale),
+                section('Past-deadline requirements (CV-5)', report.pastDeadlineRequirements.length, pastDl),
+            ].join('');
+            return htmlDoc(title, options.today, body);
+        }
+    }
+}
+/**
+ * Renders an `ImpactMatrix` (from `buildImpactMatrix`) as a self-contained
+ * A4 HTML document suitable for WeasyPrint PDF output.
+ *
+ * Used by `cervin export-compliance --report <id> --format pdf`.
+ */
+export function renderImpactMatrixHtml(matrix, options = {}) {
+    const STATUS_GLYPH = {
+        compliant: 'OK', partial: 'PARTIAL', non_compliant: 'FAIL',
+        under_review: 'REVIEW', n_a: 'N/A',
+    };
+    const statusClass = (s) => s ?? 'gap';
+    const colHeaders = matrix.columns.map(c => `<th>${escHtml(c.label)}</th>`).join('');
+    const head = `<tr><th>Obligation</th>${colHeaders}</tr>`;
+    const rows = matrix.rows.map((req, ri) => {
+        const rowLabel = `${escHtml(req.id)}${req.name && req.name !== req.id ? ` — ${escHtml(req.name)}` : ''}`;
+        const cells = matrix.cells[ri].map(cell => {
+            if (cell.kind === 'gap')
+                return `<td class="cmp-gap">${escHtml(matrix.emptyLabels.no_obligation_label)}</td>`;
+            if (cell.kind === 'n_a_only')
+                return `<td class="cmp-na">${escHtml(matrix.emptyLabels.no_obligation_applies_label)}</td>`;
+            const glyph = STATUS_GLYPH[cell.status ?? ''] ?? String(cell.status);
+            return `<td class="cmp-${statusClass(cell.status)}">${escHtml(glyph)}</td>`;
+        }).join('');
+        const dlInfo = req.deadline ? ` <span class="cmp-dl">⚑ ${escHtml(req.deadline)}</span>` : '';
+        return `<tr><td class="cmp-row-label">${rowLabel}${dlInfo}</td>${cells}</tr>`;
+    }).join('');
+    const snapshotLine = matrix.snapshotAt ? `<span>Snapshot: ${escHtml(matrix.snapshotAt)}</span>` : '';
+    const desc = matrix.description ? `<p>${escHtml(matrix.description)}</p>` : '';
+    const extraCss = `
+table { border-collapse: collapse; width: 100%; font-size: 9pt; }
+th, td { border: 1px solid #cbd5e1; padding: 3pt 5pt; text-align: center; vertical-align: middle; }
+td.cmp-row-label { text-align: left; font-size: 8.5pt; max-width: 180pt; white-space: normal; }
+.cmp-compliant { background: #d1fae5; color: #065f46; font-weight: 700; }
+.cmp-partial { background: #fef9c3; color: #854d0e; font-weight: 700; }
+.cmp-non_compliant { background: #fee2e2; color: #991b1b; font-weight: 700; }
+.cmp-under_review { background: #e0f2fe; color: #0c4a6e; }
+.cmp-gap { background: #f8fafc; color: #94a3b8; font-size: 8pt; }
+.cmp-na { background: #f1f5f9; color: #94a3b8; font-size: 8pt; }
+.cmp-dl { color: #b45309; font-size: 8pt; }`;
+    return `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<style>
+${CSS}
+${extraCss}
+</style>
+</head>
+<body>
+<div class="cmp-header">
+  <div class="cmp-eyebrow">Compliance Impact Matrix</div>
+  <h1>${escHtml(matrix.viewName)}</h1>
+  <div class="cmp-stamp">View: <code>${escHtml(matrix.viewId)}</code> ${snapshotLine}${options.today ? ` · Generated: ${escHtml(options.today)}` : ''}</div>
+</div>
+${desc}
+<table><thead>${head}</thead><tbody>${rows}</tbody></table>
+</body>
+</html>`;
+}

package/dist/compliance/impact.d.ts

@@ -0,0 +1,251 @@
+import type { AssertionStatus } from '../assertion/types.js';
+import type { ComplianceCanon } from './classify.js';
+import type { IndexAssertion, IndexRequirement, ObjectDetailInput, DeadlineStatus } from './types.js';
+/** Filter selecting REQUIREMENTs by codex source (jurisdiction / regime keys
+ *  are accepted for forward compatibility but not yet honoured — the canon
+ *  projection does not carry those fields). */
+export interface ImpactObligationFilter {
+    derived_from_codex?: string[];
+}
+export interface ImpactSubjects {
+    products?: string[];
+    processes?: string[];
+}
+export interface ImpactStatusDisplay {
+    show?: AssertionStatus[];
+}
+export interface ImpactEmptyCellLabels {
+    /** Label used when no admitted ASSERTION binds the cell (modelling gap). */
+    no_obligation_label?: string;
+    /** Label used when an admitted ASSERTION exists with status `n_a`
+     *  (modelled fact: the obligation does not apply). */
+    no_obligation_applies_label?: string;
+}
+/**
+ * A matrix column descriptor.
+ *
+ * At the coarsest grain (`grouping.columns: 'product'`) a column maps to a
+ * single subject: `{ subjectId, label: subjectId }`.
+ *
+ * At `grouping.columns: 'product-stage'` a column represents one (product,
+ * stage) pair: `{ subjectId: productId, stageId, label: productId + ':' + stageId }`.
+ * A cell is populated when an ASSERTION has `subject === subjectId` and
+ * `stageId ∈ assertion.realised_via` (or `realised_via` is absent, meaning
+ * the assertion covers the entire subject — it then contributes to every
+ * stage column for that subject).
+ */
+export interface ImpactColumn {
+    /** Subject (product / process / capability) the column belongs to. */
+    subjectId: string;
+    /** Stage ID — present only when grouping.columns is not 'product'. */
+    stageId?: string;
+    /** Human-readable column header. */
+    label: string;
+}
+/**
+ * Grouping options for matrix columns.
+ *
+ * `columns` controls the column grain:
+ *   - `'product'` (default) — one column per subject.
+ *   - `'product-stage'`     — one column per (subject, stage) pair derived
+ *     from `objectDetails` passed to `buildImpactMatrix`.
+ */
+export interface ImpactGrouping {
+    columns: 'object' | 'object-details';
+}
+/**
+ * Named, versioned view-config — the report *definition*.
+ *
+ * A saved view config is the source of truth for a deterministic report run:
+ * given the same config + canon, `buildImpactMatrix` always produces the
+ * same matrix. Configs are stored in YAML files (top-level `view:` key) and
+ * referenced by `id`.
+ *
+ * `snapshot_at` (ISO 8601 date) records when the report was last generated.
+ * CV-3 blueprint-lane rendering uses it to mark obligations that appeared in
+ * the canon *after* the snapshot as "new" (dashed-border cell decoration).
+ */
+export interface ImpactViewConfig {
+    id: string;
+    name: string;
+    description?: string;
+    /**
+     * ISO 8601 date of the last report snapshot (YYYY-MM-DD).
+     * Populated automatically by the CLI on each run and stored back to the
+     * view-config file, giving CV-3 its "new since last run" signal.
+     */
+    snapshot_at?: string;
+    subjects: ImpactSubjects;
+    obligations: {
+        include?: string[];
+        filter?: ImpactObligationFilter;
+    };
+    status_display?: ImpactStatusDisplay;
+    empty_cells?: ImpactEmptyCellLabels;
+    order_rows_by?: 'id' | 'name';
+    /**
+     * Column grouping options.  Omit (or set `columns: 'product'`) for the
+     * default single-column-per-subject behaviour.  Set `columns: 'product-stage'`
+     * and pass `objectDetails` into `buildImpactMatrix` to expand each subject
+     * into per-stage sub-columns.
+     */
+    grouping?: ImpactGrouping;
+}
+/**
+ * Explicit defaults for every optional field in ImpactViewConfig.
+ *
+ * When a view config omits a field, COMPLIANCE_IMPACT_DEFAULTS defines the
+ * assumed behaviour. The CLI prints these so re-runs without a full config
+ * are auditable ("what I assumed").
+ */
+export declare const COMPLIANCE_IMPACT_DEFAULTS: {
+    /** Accept all four active statuses + n_a in cell aggregation. */
+    readonly status_display: {
+        readonly show: AssertionStatus[];
+    };
+    /** Order rows by canonical REQUIREMENT ID (lexicographic). */
+    readonly order_rows_by: "id";
+    /** §5.3 empty-cell labels. */
+    readonly empty_cells: {
+        readonly no_obligation_label: "No mapped obligation (current model)";
+        readonly no_obligation_applies_label: "No obligation applies";
+    };
+    /** Obligation scope: all known REQUIREMENTs in the canon (no filter). */
+    readonly obligations: {
+        readonly include: string[] | undefined;
+        readonly filter: undefined;
+    };
+    /** Subjects: empty — must be supplied explicitly in the view config. */
+    readonly subjects: {
+        readonly products: string[];
+        readonly processes: string[];
+    };
+    /** Column grain: one column per business object (no stage decomposition). */
+    readonly grouping: {
+        readonly columns: "object";
+    };
+};
+export type ParseImpactViewConfigResult = {
+    ok: true;
+    config: ImpactViewConfig;
+} | {
+    ok: false;
+    errors: string[];
+};
+/**
+ * Validate and normalise a raw (YAML-parsed) value into an ImpactViewConfig.
+ *
+ * Accepts both the bare config object and the view-config file shape
+ * (`{ view: { id, name, … } }`) — the top-level `view:` wrapper is unwrapped
+ * automatically.
+ *
+ * Every optional field is filled from COMPLIANCE_IMPACT_DEFAULTS, so callers
+ * can rely on the returned config being complete without any `??` chains.
+ *
+ * Returns `{ ok: false, errors }` on schema violations rather than throwing,
+ * so the CLI can surface a clean error message without a stack trace.
+ */
+export declare function parseImpactViewConfig(raw: unknown): ParseImpactViewConfigResult;
+/** A single cell of the rendered matrix. */
+export interface ImpactCell {
+    /** Resolved status when an ASSERTION binds the cell, else null. */
+    status: AssertionStatus | null;
+    /** Empty-cell condition per §5.3 — one of:
+     *  - `bound`   : at least one admitted ASSERTION binds the cell; `status` is set.
+     *  - `n_a_only`: every binding ASSERTION has status `n_a` (modelled fact).
+     *  - `gap`     : no admitted ASSERTION binds the cell (modelling gap). */
+    kind: 'bound' | 'n_a_only' | 'gap';
+    /** The assertions that contributed to this cell, id-sorted. */
+    assertions: IndexAssertion[];
+    /**
+     * CV-3 blueprint-lane decorations.
+     *
+     * `isNew`    — the row's REQUIREMENT was admitted after the report
+     *              `snapshot_at` date (dashed-border decoration).
+     * `isUrgent` — the cell is a gap AND the requirement has a deadline
+     *              whose temporal status is `past_due` or `in_force`.
+     * `deadlineStatus` — temporal distance to the deadline (or `'none'`).
+     */
+    decoration: {
+        isNew: boolean;
+        isUrgent: boolean;
+        deadlineStatus: DeadlineStatus;
+    };
+}
+export interface ImpactMatrix {
+    viewId: string;
+    viewName: string;
+    description?: string;
+    /**
+     * ISO 8601 date of the last report snapshot, copied from the view config.
+     * CV-3 blueprint-lane rendering uses this to flag obligations that appeared
+     * after the snapshot as "new" (dashed-border cell decoration).
+     */
+    snapshotAt?: string;
+    /** Row dimension — REQUIREMENT projections, in the configured order. */
+    rows: IndexRequirement[];
+    /**
+     * Column dimension.
+     *
+     * At `grouping.columns: 'product'` (default) each entry has only `subjectId`
+     * and `label`.  At `'product-stage'` entries additionally carry `stageId`.
+     */
+    columns: ImpactColumn[];
+    /** Cells, indexed as `cell[rowIdx][colIdx]`. */
+    cells: ImpactCell[][];
+    /** Canonical empty-cell labels actually used (after defaults applied). */
+    emptyLabels: Required<ImpactEmptyCellLabels>;
+    /**
+     * CV-3 derived obligations lane.
+     *
+     * For each column, the set of codex source IDs (`REQUIREMENT.derived_from`)
+     * that appear in at least one non-gap cell in that column.  Renderers use
+     * this to display a "laws lane" header above or below the matrix columns.
+     * Empty array when no requirement in the column has a `derived_from`.
+     */
+    obligationsLane: string[][];
+}
+/**
+ * Classify a REQUIREMENT deadline relative to a reference date.
+ *
+ * @param deadline  ISO 8601 date string (YYYY-MM-DD), or undefined.
+ * @param today     Reference date string (YYYY-MM-DD); defaults to today.
+ */
+export declare function computeDeadlineStatus(deadline: string | undefined, today?: string): DeadlineStatus;
+/**
+ * Build the matrix per §5.2.
+ *
+ * At the default `grouping.columns: 'product'` grain, one column per subject.
+ * At `grouping.columns: 'product-stage'`, pass `objectDetails` to expand each
+ * subject into per-stage sub-columns (typically extracted from a
+ * process-blueprint document via `extractObjectDetails`).  Subjects with no
+ * stage mapping fall back to a single product-grain column automatically.
+ *
+ * Subjects are taken from `config.subjects.products` and
+ * `config.subjects.processes` (in that order).  Subjects with no binding
+ * obligation still appear as columns so the gap is visible.
+ */
+export declare function buildImpactMatrix(canon: ComplianceCanon, config: ImpactViewConfig, objectDetails?: ObjectDetailInput[]): ImpactMatrix;
+/**
+ * Extract `ObjectDetailInput` from a raw (YAML-parsed) process-blueprint document.
+ *
+ * Accepts both the bare document object and the wrapped form
+ * (`{ process_blueprint: { id, stages: […] } }`).
+ * Returns `null` when the document is not a recognisable process-blueprint or
+ * has no `id` / `stages` array so callers can skip unrecognised files safely.
+ *
+ * Pass the returned value into `buildImpactMatrix` as part of the
+ * `objectDetails` array when `grouping.columns: 'product-stage'` is configured.
+ */
+export declare function extractObjectDetails(doc: unknown): ObjectDetailInput | null;
+/**
+ * Render the matrix as a GitHub-flavoured markdown table.
+ *
+ * Cell display:
+ *   - `bound`    → the §5.2 deterministic status label.
+ *   - `n_a_only` → the "No obligation applies" label (or `view.empty_cells`
+ *                  override).
+ *   - `gap`      → the "No mapped obligation (current model)" label (or
+ *                  override).
+ */
+export declare function renderImpactMarkdown(matrix: ImpactMatrix): string;