@transitrix/diagrams 1.0.0

package/dist/compliance/reverse-index.js

@@ -0,0 +1,30 @@
+// Reverse-index builder (vkgeorgia/strategy#84 Phase 3).
+function push(map, key, value) {
+    const list = map.get(key);
+    if (list)
+        list.push(value);
+    else
+        map.set(key, [value]);
+}
+/**
+ * Builds the reverse indexes used by every compliance view. Pure; the input
+ * arrays are read, not mutated. Requirements with no `derived_from` simply do
+ * not appear under any law; assertions are indexed by both their requirement
+ * (`about`) and their subject.
+ */
+export function buildComplianceIndex(input) {
+    const requirementById = new Map();
+    const requirementsByLaw = new Map();
+    const assertionsByRequirement = new Map();
+    const assertionsBySubject = new Map();
+    for (const r of input.requirements) {
+        requirementById.set(r.id, r);
+        for (const law of r.derived_from ?? [])
+            push(requirementsByLaw, law, r);
+    }
+    for (const a of input.assertions) {
+        push(assertionsByRequirement, a.about, a);
+        push(assertionsBySubject, a.subject, a);
+    }
+    return { requirementById, requirementsByLaw, assertionsByRequirement, assertionsBySubject };
+}

package/dist/compliance/types.d.ts

@@ -0,0 +1,98 @@
+import type { AssertionStatus } from '../assertion/types.js';
+/** Projection of a REQUIREMENT the compliance views need. */
+export interface IndexRequirement {
+    id: string;
+    name: string;
+    severity?: string;
+    /** Typed IDs of the codex sources this requirement derives from. */
+    derived_from?: string[];
+    /** Admission date (CONTRACT §6) — feeds DQ-1 freshness decay. */
+    admitted_at?: string;
+    /**
+     * Compliance deadline (ISO 8601 date, YYYY-MM-DD).
+     * When a gap exists on a cell whose requirement carries a deadline that is
+     * past or imminent, CV-3 renders an urgent decoration on the cell.
+     */
+    deadline?: string;
+}
+/**
+ * Temporal status of a requirement deadline relative to today.
+ *
+ * - `past_due`  — deadline has already passed (`deadline < today`).
+ * - `in_force`  — deadline is within the next 30 days.
+ * - `upcoming`  — deadline is more than 30 days away.
+ * - `none`      — no deadline set.
+ */
+export type DeadlineStatus = 'past_due' | 'in_force' | 'upcoming' | 'none';
+/** Projection of an ASSERTION the compliance views need. */
+export interface IndexAssertion {
+    id: string;
+    about: string;
+    subject: string;
+    status: AssertionStatus;
+    assessed_at?: string;
+    next_review_at?: string;
+    /** Number of evidence entries — feeds the Phase 4 "no evidence" gap. */
+    evidenceCount?: number;
+    /** Admission date (CONTRACT §6) — feeds DQ-1 freshness decay. */
+    admitted_at?: string;
+    /**
+     * Typed IDs of the stages / tasks where the requirement is realised for
+     * the subject (16-assertion.md §2 `realised_via`). Populated when the
+     * assertion carries granular evidence; absent when the claim covers the
+     * entire subject without stage decomposition. CV-3a uses this to fill
+     * stage-grouped matrix cells.
+     */
+    realised_via?: string[];
+}
+/** One detail-level element of a business object, used as a matrix sub-column. */
+export interface ObjectDetailDef {
+    id: string;
+    name: string;
+}
+/**
+ * Maps a business object to its ordered detail elements.
+ * Passed into `buildImpactMatrix` when `grouping.columns` is
+ * `object-details`. The details can be process stages, product
+ * components, capability modules, etc. — whatever sub-structure the object
+ * exposes. Typically extracted from a process-blueprint via`extractObjectDetails`.
+ */
+export interface ObjectDetailInput {
+    objectId: string;
+    details: ObjectDetailDef[];
+}
+export interface ComplianceIndexInput {
+    requirements: IndexRequirement[];
+    assertions: IndexAssertion[];
+}
+/** The reverse-index — all maps are keyed by canonical id. */
+export interface ComplianceIndex {
+    requirementById: Map<string, IndexRequirement>;
+    /** Codex artefact id → requirements whose `derived_from` names it. */
+    requirementsByLaw: Map<string, IndexRequirement[]>;
+    /** Requirement id → assertions whose `about` names it. */
+    assertionsByRequirement: Map<string, IndexAssertion[]>;
+    /** Subject id (product / process / capability) → assertions about it. */
+    assertionsBySubject: Map<string, IndexAssertion[]>;
+}
+export interface LawTreeRequirement {
+    requirement: IndexRequirement;
+    /** Assertions targeting this requirement, id-sorted. */
+    assertions: IndexAssertion[];
+}
+export interface LawTree {
+    lawId: string;
+    /** Requirements derived from the law, id-sorted. */
+    requirements: LawTreeRequirement[];
+}
+export interface ProductRequirementStatus {
+    /** The requirement the assertion is about. `name` falls back to the id when
+     *  the requirement is not present in the scan (dangling `about`). */
+    requirement: IndexRequirement;
+    assertion: IndexAssertion;
+}
+export interface ProductView {
+    productId: string;
+    /** Requirements bound to the product via an assertion, requirement-id-sorted. */
+    requirements: ProductRequirementStatus[];
+}

package/dist/compliance/types.js

@@ -0,0 +1,5 @@
+// Shared compliance reverse-index + derived views (vkgeorgia/strategy#84
+// Phase 3). The reverse-index pass (Law → Requirements, Requirement →
+// Assertions, Subject → Assertions) backs the single-law tree and the
+// single-product view here, and the gap dashboard in Phase 4.
+export {};

package/dist/compliance/views.d.ts

@@ -0,0 +1,14 @@
+import type { ComplianceIndex, LawTree, ProductView } from './types.js';
+/**
+ * Law → Requirements → Assertions. Requirements are those whose `derived_from`
+ * names `lawId`; each carries the assertions targeting it. An unknown law (no
+ * requirement derives from it) yields an empty tree.
+ */
+export declare function buildLawTree(lawId: string, index: ComplianceIndex): LawTree;
+/**
+ * Product → the Requirements it has an assertion about, with each assertion's
+ * status. The requirement is resolved from the index; a dangling `about`
+ * (assertion references a requirement not in the scan) falls back to a stub
+ * carrying the id as its name, so the binding still shows.
+ */
+export declare function buildProductView(productId: string, index: ComplianceIndex): ProductView;

package/dist/compliance/views.js

@@ -0,0 +1,35 @@
+// Single-law tree + single-product view builders (vkgeorgia/strategy#84 Phase 3).
+function byId(a, b) {
+    return a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
+}
+/**
+ * Law → Requirements → Assertions. Requirements are those whose `derived_from`
+ * names `lawId`; each carries the assertions targeting it. An unknown law (no
+ * requirement derives from it) yields an empty tree.
+ */
+export function buildLawTree(lawId, index) {
+    const requirements = [...(index.requirementsByLaw.get(lawId) ?? [])].sort(byId);
+    return {
+        lawId,
+        requirements: requirements.map(requirement => ({
+            requirement,
+            assertions: [...(index.assertionsByRequirement.get(requirement.id) ?? [])].sort(byId),
+        })),
+    };
+}
+/**
+ * Product → the Requirements it has an assertion about, with each assertion's
+ * status. The requirement is resolved from the index; a dangling `about`
+ * (assertion references a requirement not in the scan) falls back to a stub
+ * carrying the id as its name, so the binding still shows.
+ */
+export function buildProductView(productId, index) {
+    const assertions = [...(index.assertionsBySubject.get(productId) ?? [])];
+    const requirements = assertions
+        .map(assertion => {
+        const requirement = index.requirementById.get(assertion.about) ?? { id: assertion.about, name: assertion.about };
+        return { requirement, assertion };
+    })
+        .sort((a, b) => byId(a.requirement, b.requirement));
+    return { productId, requirements };
+}

package/dist/compliance-matrix/__tests__/build.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/compliance-matrix/__tests__/build.test.js

@@ -0,0 +1,183 @@
+import { describe, it, expect } from 'vitest';
+import { buildComplianceMatrix, filterComplianceMatrix } from '../build.js';
+function input(over = {}) {
+    return {
+        products: [
+            { id: 'PRODUCT-ECOMM-1', name: 'E-Commerce' },
+            { id: 'PRODUCT-SUPPORT-1', name: 'Support' },
+        ],
+        requirements: [
+            { id: 'REQUIREMENT-DATA-ERASURE-1', name: 'Erasure', severity: 'high' },
+            { id: 'REQUIREMENT-AUDIT-LOG-RETENTION-1', name: 'Audit logs', severity: 'medium' },
+        ],
+        assertions: [
+            { id: 'ASSERTION-1', about: 'REQUIREMENT-DATA-ERASURE-1', subject: 'PRODUCT-ECOMM-1', status: 'compliant' },
+        ],
+        ...over,
+    };
+}
+describe('buildComplianceMatrix', () => {
+    it('sorts products as rows and requirements as columns by id', () => {
+        const m = buildComplianceMatrix(input());
+        expect(m.products.map(p => p.id)).toEqual(['PRODUCT-ECOMM-1', 'PRODUCT-SUPPORT-1']);
+        expect(m.requirements.map(r => r.id)).toEqual([
+            'REQUIREMENT-AUDIT-LOG-RETENTION-1',
+            'REQUIREMENT-DATA-ERASURE-1',
+        ]);
+    });
+    it('places an assertion status in the (product, requirement) cell and gaps elsewhere', () => {
+        const m = buildComplianceMatrix(input());
+        // row 0 = ECOMM; col 1 = DATA-ERASURE (after the sort)
+        expect(m.cells[0][1]).toMatchObject({ status: 'compliant', assertionId: 'ASSERTION-1' });
+        expect(m.cells[0][0].status).toBeUndefined(); // ECOMM × AUDIT-LOG → gap
+        expect(m.cells[1][1].status).toBeUndefined(); // SUPPORT × DATA-ERASURE → gap
+        expect(m.summary).toMatchObject({ products: 2, requirements: 2, assertions: 1, gaps: 3 });
+    });
+    it('adds a product-typed assertion subject with no product file as an unresolved row', () => {
+        const m = buildComplianceMatrix(input({
+            assertions: [
+                { id: 'A1', about: 'REQUIREMENT-DATA-ERASURE-1', subject: 'PRODUCT-MOBILE-1', status: 'partial' },
+            ],
+        }));
+        const mobile = m.products.find(p => p.id === 'PRODUCT-MOBILE-1');
+        expect(mobile).toMatchObject({ unresolved: true });
+        const col = m.requirements.findIndex(r => r.id === 'REQUIREMENT-DATA-ERASURE-1');
+        const row = m.products.findIndex(p => p.id === 'PRODUCT-MOBILE-1');
+        expect(m.cells[row][col].status).toBe('partial');
+    });
+    it('ignores assertions whose subject is not a PRODUCT', () => {
+        const m = buildComplianceMatrix(input({
+            assertions: [
+                { id: 'A1', about: 'REQUIREMENT-DATA-ERASURE-1', subject: 'CAPABILITY-V2', status: 'compliant' },
+                { id: 'A2', about: 'REQUIREMENT-DATA-ERASURE-1', subject: 'PROCESS-X-1', status: 'partial' },
+            ],
+        }));
+        expect(m.summary.assertions).toBe(0);
+        expect(m.products.map(p => p.id)).toEqual(['PRODUCT-ECOMM-1', 'PRODUCT-SUPPORT-1']);
+    });
+});
+describe('buildComplianceMatrix — jurisdiction resolution (F16)', () => {
+    it('resolves Requirement.jurisdictions from derived_from → codex', () => {
+        const m = buildComplianceMatrix(input({
+            requirements: [
+                { id: 'REQUIREMENT-DATA-ERASURE-1', name: 'Erasure', severity: 'high',
+                    derived_from: ['LAW-PERSONAL-DATA-2017-1'] },
+                { id: 'REQUIREMENT-AUDIT-LOG-RETENTION-1', name: 'Audit logs', severity: 'medium',
+                    derived_from: ['LAW-AUDIT-2020-1', 'LAW-PERSONAL-DATA-2017-1'] },
+            ],
+            codex: [
+                { id: 'LAW-PERSONAL-DATA-2017-1', jurisdiction: 'ge' },
+                { id: 'LAW-AUDIT-2020-1', jurisdiction: 'eu' },
+            ],
+        }));
+        const erasure = m.requirements.find(r => r.id === 'REQUIREMENT-DATA-ERASURE-1');
+        const audit = m.requirements.find(r => r.id === 'REQUIREMENT-AUDIT-LOG-RETENTION-1');
+        expect(erasure.jurisdictions).toEqual(['ge']);
+        // Sorted, deduplicated union.
+        expect(audit.jurisdictions).toEqual(['eu', 'ge']);
+    });
+    it('leaves jurisdictions undefined when no codex source resolves', () => {
+        const m = buildComplianceMatrix(input({
+            requirements: [
+                { id: 'REQUIREMENT-INTERNAL-1', name: 'Internal', severity: 'low' },
+                { id: 'REQUIREMENT-DANGLING-1', name: 'Dangling', severity: 'low',
+                    derived_from: ['LAW-MISSING-1'] },
+            ],
+            codex: [{ id: 'LAW-OTHER-1', jurisdiction: 'us' }],
+        }));
+        expect(m.requirements.find(r => r.id === 'REQUIREMENT-INTERNAL-1').jurisdictions).toBeUndefined();
+        expect(m.requirements.find(r => r.id === 'REQUIREMENT-DANGLING-1').jurisdictions).toBeUndefined();
+    });
+    it('ignores codex entries with no jurisdiction (e.g. internal POLICY)', () => {
+        const m = buildComplianceMatrix(input({
+            requirements: [
+                { id: 'REQUIREMENT-DATA-ERASURE-1', name: 'Erasure', severity: 'high',
+                    derived_from: ['POLICY-INTERNAL-1'] },
+            ],
+            codex: [{ id: 'POLICY-INTERNAL-1' }],
+        }));
+        expect(m.requirements[0].jurisdictions).toBeUndefined();
+    });
+    it('works with no codex input (backwards-compatible)', () => {
+        const m = buildComplianceMatrix(input({
+            requirements: [
+                { id: 'REQUIREMENT-DATA-ERASURE-1', name: 'Erasure', severity: 'high',
+                    derived_from: ['LAW-PERSONAL-DATA-2017-1'] },
+            ],
+        }));
+        expect(m.requirements[0].jurisdictions).toBeUndefined();
+    });
+});
+describe('filterComplianceMatrix', () => {
+    it('trims requirement columns by severity', () => {
+        const m = buildComplianceMatrix(input());
+        const f = filterComplianceMatrix(m, { severities: ['high'] });
+        expect(f.requirements.map(r => r.id)).toEqual(['REQUIREMENT-DATA-ERASURE-1']);
+        expect(f.cells[0]).toHaveLength(1);
+        expect(f.cells[0][0]).toMatchObject({ status: 'compliant' });
+    });
+    it('blanks cells whose status is filtered out, preserving the grid shape', () => {
+        const m = buildComplianceMatrix(input());
+        const f = filterComplianceMatrix(m, { statuses: ['non_compliant'] });
+        // The compliant cell is now hidden (treated as a gap); columns unchanged.
+        expect(f.requirements).toHaveLength(2);
+        expect(f.cells[0][1].status).toBeUndefined();
+        expect(f.summary.assertions).toBe(0);
+    });
+    it('is a no-op when no filter dimension is set', () => {
+        const m = buildComplianceMatrix(input());
+        const f = filterComplianceMatrix(m, {});
+        expect(f.summary).toEqual(m.summary);
+    });
+    it('keeps only columns whose resolved jurisdiction is in the filter (F16)', () => {
+        const m = buildComplianceMatrix(input({
+            requirements: [
+                { id: 'REQUIREMENT-DATA-ERASURE-1', name: 'Erasure', severity: 'high',
+                    derived_from: ['LAW-PERSONAL-DATA-2017-1'] },
+                { id: 'REQUIREMENT-AUDIT-LOG-RETENTION-1', name: 'Audit logs', severity: 'medium',
+                    derived_from: ['LAW-AUDIT-2020-1'] },
+            ],
+            codex: [
+                { id: 'LAW-PERSONAL-DATA-2017-1', jurisdiction: 'ge' },
+                { id: 'LAW-AUDIT-2020-1', jurisdiction: 'eu' },
+            ],
+        }));
+        const f = filterComplianceMatrix(m, { jurisdictions: ['ge'] });
+        expect(f.requirements.map(r => r.id)).toEqual(['REQUIREMENT-DATA-ERASURE-1']);
+        expect(f.cells[0]).toHaveLength(1);
+    });
+    it('drops requirements with no resolved jurisdiction when the filter is active', () => {
+        const m = buildComplianceMatrix(input({
+            requirements: [
+                { id: 'REQUIREMENT-DATA-ERASURE-1', name: 'Erasure', severity: 'high',
+                    derived_from: ['LAW-PERSONAL-DATA-2017-1'] },
+                { id: 'REQUIREMENT-INTERNAL-1', name: 'Internal', severity: 'low' },
+            ],
+            codex: [{ id: 'LAW-PERSONAL-DATA-2017-1', jurisdiction: 'ge' }],
+        }));
+        const f = filterComplianceMatrix(m, { jurisdictions: ['ge'] });
+        expect(f.requirements.map(r => r.id)).toEqual(['REQUIREMENT-DATA-ERASURE-1']);
+    });
+    it('combines jurisdiction filter with severity (intersection)', () => {
+        const m = buildComplianceMatrix(input({
+            requirements: [
+                { id: 'REQUIREMENT-DATA-ERASURE-1', name: 'Erasure', severity: 'high',
+                    derived_from: ['LAW-PERSONAL-DATA-2017-1'] },
+                { id: 'REQUIREMENT-DATA-PORTABILITY-1', name: 'Portability', severity: 'medium',
+                    derived_from: ['LAW-PERSONAL-DATA-2017-1'] },
+            ],
+            codex: [{ id: 'LAW-PERSONAL-DATA-2017-1', jurisdiction: 'ge' }],
+        }));
+        const f = filterComplianceMatrix(m, { jurisdictions: ['ge'], severities: ['high'] });
+        expect(f.requirements.map(r => r.id)).toEqual(['REQUIREMENT-DATA-ERASURE-1']);
+    });
+    it('empty jurisdiction array is treated as no-filter on that dimension', () => {
+        const m = buildComplianceMatrix(input({
+            requirements: [
+                { id: 'REQUIREMENT-INTERNAL-1', name: 'Internal', severity: 'low' },
+            ],
+        }));
+        const f = filterComplianceMatrix(m, { jurisdictions: [] });
+        expect(f.requirements).toHaveLength(1);
+    });
+});

package/dist/compliance-matrix/__tests__/example.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/compliance-matrix/__tests__/example.test.js

@@ -0,0 +1,49 @@
+// Conformance test — the compliance matrix on the acme_corp worked examples
+// (mirrored under tests/fixtures/notation-corpus/product, tests/fixtures/notation-corpus/requirement, tests/fixtures/notation-corpus/assertion).
+// Pins the #84 Phase 2 acceptance: the matrix renders correctly and gaps are
+// obvious.
+import { describe, it, expect } from 'vitest';
+import { readdirSync, readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import path from 'node:path';
+import yaml from 'js-yaml';
+import { buildComplianceMatrix } from '../build.js';
+const examples = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../../../../tests/fixtures/notation-corpus');
+function loadAll(dir) {
+    const full = path.join(examples, dir);
+    return readdirSync(full)
+        .filter(f => f.endsWith('.yaml'))
+        .map(f => yaml.load(readFileSync(path.join(full, f), 'utf-8')));
+}
+describe('compliance matrix — acme_corp worked examples', () => {
+    const products = loadAll('product').map(p => ({ id: String(p.id), name: String(p.name) }));
+    const requirements = loadAll('requirement').map(r => ({
+        id: String(r.id), name: String(r.name), severity: r.severity,
+    }));
+    const assertions = loadAll('assertion').map(a => ({
+        id: String(a.id), about: String(a.about), subject: String(a.subject),
+        status: a.status,
+        assessed_at: a.assessed_at,
+        next_review_at: a.next_review_at,
+    }));
+    const m = buildComplianceMatrix({ products, requirements, assertions });
+    it('rows = the two product files plus the dangling PRODUCT-MOBILE-1 subject', () => {
+        expect(m.products.map(p => p.id)).toEqual([
+            'PRODUCT-ECOMM-1', 'PRODUCT-MOBILE-1', 'PRODUCT-SUPPORT-1',
+        ]);
+        expect(m.products.find(p => p.id === 'PRODUCT-MOBILE-1')?.unresolved).toBe(true);
+    });
+    it('columns = the two requirements', () => {
+        expect(m.requirements.map(r => r.id)).toEqual([
+            'REQUIREMENT-AUDIT-LOG-RETENTION-1', 'REQUIREMENT-DATA-ERASURE-1',
+        ]);
+    });
+    it('the only product-subject assertion (mobile → data-erasure) is compliant; everything else is a gap', () => {
+        const row = m.products.findIndex(p => p.id === 'PRODUCT-MOBILE-1');
+        const col = m.requirements.findIndex(r => r.id === 'REQUIREMENT-DATA-ERASURE-1');
+        expect(m.cells[row][col]).toMatchObject({ status: 'compliant', assertionId: 'ASSERTION-MOBILE-DATA-ERASURE-1' });
+        // 3 products × 2 requirements = 6 cells; 1 filled → 5 gaps. The CRM
+        // (capability) and onboarding (process) assertions are not in the matrix.
+        expect(m.summary).toMatchObject({ products: 3, requirements: 2, assertions: 1, gaps: 5 });
+    });
+});

package/dist/compliance-matrix/build.d.ts

@@ -0,0 +1,18 @@
+import type { ComplianceMatrix, ComplianceMatrixInput, MatrixFilter } from './types.js';
+/**
+ * Builds the Products × Requirements matrix.
+ *
+ * Rows are the discovered PRODUCT elements, unioned with any product-typed
+ * assertion subject that has no product element (flagged `unresolved`) so a
+ * compliance claim is never silently dropped. Columns are the requirements.
+ * A cell carries the status of the product-subject assertion whose `about`
+ * matches the column, or is a gap.
+ */
+export declare function buildComplianceMatrix(input: ComplianceMatrixInput): ComplianceMatrix;
+/**
+ * Applies a toolbar filter. Severity trims requirement *columns*; status blanks
+ * the *cells* whose status is filtered out (rendered as a non-matching gap),
+ * leaving the grid shape intact so the remaining claims stay aligned. Returns a
+ * new matrix; the input is not mutated.
+ */
+export declare function filterComplianceMatrix(matrix: ComplianceMatrix, filter: MatrixFilter): ComplianceMatrix;

package/dist/compliance-matrix/index.d.ts

@@ -0,0 +1,2 @@
+export { buildComplianceMatrix, filterComplianceMatrix } from './build.js';
+export type { ComplianceMatrix, ComplianceMatrixInput, MatrixProduct, MatrixRequirement, MatrixAssertionRef, MatrixCell, MatrixCodexDoc, MatrixFilter, } from './types.js';

package/dist/compliance-matrix/index.js

@@ -0,0 +1 @@
+export { buildComplianceMatrix, filterComplianceMatrix } from './build.js';

package/dist/compliance-matrix/types.d.ts

@@ -0,0 +1,86 @@
+import type { AssertionStatus } from '../assertion/types.js';
+/** A row of the matrix — a discovered PRODUCT element. */
+export interface MatrixProduct {
+    id: string;
+    name: string;
+    /** True when the product was discovered only as an assertion subject (no
+     *  product element file resolves it) — a dangling subject reference. */
+    unresolved?: boolean;
+}
+/** A column of the matrix — a discovered REQUIREMENT. */
+export interface MatrixRequirement {
+    id: string;
+    name: string;
+    /** Organisation-defined priority (high | medium | low), used by the filter. */
+    severity?: string;
+    /** Typed IDs of the codex sources this requirement derives from (verbatim
+     *  from `derived_from`). Carried so the renderer can surface provenance and
+     *  resolve jurisdictions without re-scanning. */
+    derived_from?: string[];
+    /** Jurisdictions resolved by walking `derived_from` → codex artefacts and
+     *  collecting their `jurisdiction` (Codex §1.1). Unique, sorted. Empty when
+     *  no codex source resolves with a jurisdiction (internal-only requirements,
+     *  or codex artefacts the scan did not find / has no jurisdiction). The
+     *  toolbar jurisdiction filter (F16) keys on this set. */
+    jurisdictions?: string[];
+}
+/** A codex source document the matrix uses to resolve `Requirement.jurisdictions`. */
+export interface MatrixCodexDoc {
+    id: string;
+    jurisdiction?: string;
+}
+/** The assertion fields the matrix needs (a projection of the full Assertion). */
+export interface MatrixAssertionRef {
+    id: string;
+    about: string;
+    subject: string;
+    status: AssertionStatus;
+    assessed_at?: string;
+    next_review_at?: string;
+}
+/** One grid cell. `status === undefined` is a gap (no assertion for the pair). */
+export interface MatrixCell {
+    productId: string;
+    requirementId: string;
+    /** The assertion filling this cell, when one exists. */
+    assertionId?: string;
+    status?: AssertionStatus;
+    assessed_at?: string;
+    next_review_at?: string;
+}
+export interface ComplianceMatrix {
+    /** Rows, sorted by id. */
+    products: MatrixProduct[];
+    /** Columns, sorted by id. */
+    requirements: MatrixRequirement[];
+    /** `cells[rowIndex][colIndex]`, aligned to `products` × `requirements`. */
+    cells: MatrixCell[][];
+    /** Counts for the summary strip. */
+    summary: {
+        products: number;
+        requirements: number;
+        assertions: number;
+        /** Cells with no assertion (compliance gaps). */
+        gaps: number;
+    };
+}
+export interface ComplianceMatrixInput {
+    products: MatrixProduct[];
+    requirements: MatrixRequirement[];
+    assertions: MatrixAssertionRef[];
+    /** Codex source documents — used to resolve each Requirement's jurisdictions
+     *  by walking `derived_from`. Optional: when omitted the builder still works
+     *  and every requirement's `jurisdictions` is left empty. */
+    codex?: MatrixCodexDoc[];
+}
+/** Toolbar filter — empty/omitted fields mean "no filter on that dimension". */
+export interface MatrixFilter {
+    /** Keep only requirement columns whose severity is in this set. */
+    severities?: string[];
+    /** Keep only the cell status badges in this set; others render as filtered. */
+    statuses?: AssertionStatus[];
+    /** Keep only requirement columns whose resolved jurisdictions intersect this
+     *  set. Requirements with no resolved jurisdiction are filtered out when this
+     *  is non-empty (F16, epic #84). */
+    jurisdictions?: string[];
+}

package/dist/compliance-matrix/types.js

@@ -0,0 +1,8 @@
+// Compliance matrix model (vkgeorgia/strategy#84 Phase 2).
+//
+// The matrix is Products × Requirements. Each cell is the status of the
+// (Product, Requirement) ASSERTION when one exists, or a gap when none does.
+// Pure data — the layout is computed by `build.ts`; the Studio preview renders
+// it. Non-product-subject assertions (CAPABILITY / PROCESS) belong to the
+// single-product / single-law views (Phase 3) and are ignored here.
+export {};

package/dist/confidence/__tests__/score.test.d.ts

@@ -0,0 +1 @@
+export {};