@transitrix/diagrams 1.8.6 → 1.8.8

package/dist/confidence/__tests__/score.test.js

@@ -1,188 +0,0 @@
-// Pins CONTRACT §11 — source-trust scale, freshness curve, element confidence,
-// view composite, unsourced handling, manifest decay resolution, A–D bands.
-import { describe, it, expect } from 'vitest';
-import { IMPLICIT_DECAY_DEFAULTS, composeView, confidenceBand, formatConfidenceHeader, freshness, resolveDecayParams, scoreElement, scoreView, sourceTrustWeight, } from '../score.js';
-const D = { fresh_days: 100, stale_days: 200, floor: 0.3 };
-describe('sourceTrustWeight (§11.2)', () => {
-    it('matches the closed scale', () => {
-        expect(sourceTrustWeight('authoritative')).toBe(1.0);
-        expect(sourceTrustWeight('corroborated')).toBe(0.8);
-        expect(sourceTrustWeight('single_source')).toBe(0.5);
-        expect(sourceTrustWeight('unverified')).toBe(0.25);
-    });
-});
-describe('freshness (§11.3)', () => {
-    const today = '2026-06-05';
-    it('returns 1.0 when age ≤ fresh_days', () => {
-        expect(freshness('2026-05-01', today, D)).toBe(1.0);
-        expect(freshness('2026-06-05', today, D)).toBe(1.0);
-    });
-    it('returns floor when age ≥ stale_days', () => {
-        expect(freshness('2025-01-01', today, D)).toBeCloseTo(0.3, 10);
-        const exactlyStale = '2025-11-17';
-        expect(freshness(exactlyStale, today, { fresh_days: 100, stale_days: 200, floor: 0.3 })).toBeCloseTo(0.3, 10);
-    });
-    it('interpolates linearly between fresh_days and stale_days', () => {
-        // midpoint: age 150 → 1.0 − (1.0 − 0.3) · (150 − 100) / (200 − 100) = 0.65
-        const midAge = new Date(Date.UTC(2026, 5, 5));
-        midAge.setUTCDate(midAge.getUTCDate() - 150);
-        const iso = midAge.toISOString().slice(0, 10);
-        expect(freshness(iso, today, D)).toBeCloseTo(0.65, 10);
-    });
-    it('clamps future-dated admitted_at to 1.0', () => {
-        expect(freshness('2030-01-01', today, D)).toBe(1.0);
-    });
-    it('treats absent admitted_at as fully stale (returns floor)', () => {
-        expect(freshness(undefined, today, D)).toBe(0.3);
-    });
-    it('treats unparseable admitted_at as fully stale', () => {
-        expect(freshness('not-a-date', today, D)).toBe(0.3);
-        expect(freshness('2026/06/05', today, D)).toBe(0.3);
-        expect(freshness('2026-13-01', today, D)).toBe(0.3);
-    });
-    it('returns floor when stale_days <= fresh_days (degenerate config) and age exceeds fresh', () => {
-        // age 365d for 2025-06-05; both branches collapse to floor.
-        expect(freshness('2025-06-05', today, { fresh_days: 100, stale_days: 100, floor: 0.4 })).toBe(0.4);
-        expect(freshness('2025-06-05', today, { fresh_days: 200, stale_days: 100, floor: 0.4 })).toBe(0.4);
-    });
-});
-describe('resolveDecayParams (§11.3 + MANIFEST §2)', () => {
-    const config = {
-        defaults: { fresh_days: 180, stale_days: 730, floor: 0.3 },
-        by_type: {
-            CAPABILITY: { fresh_days: 365, stale_days: 1825 },
-            APPLICATION: { fresh_days: 180, stale_days: 730 },
-        },
-    };
-    it('uses by_type overrides and inherits missing fields from defaults', () => {
-        // Pins the §11.3 example: CAPABILITY overrides fresh/stale but inherits floor=0.3.
-        expect(resolveDecayParams('CAPABILITY', config)).toEqual({ fresh_days: 365, stale_days: 1825, floor: 0.3 });
-    });
-    it('falls back to defaults for an unknown TYPE', () => {
-        expect(resolveDecayParams('PROCESS', config)).toEqual({ fresh_days: 180, stale_days: 730, floor: 0.3 });
-    });
-    it('falls back to §11.3 implicit defaults when the whole block is omitted', () => {
-        expect(resolveDecayParams('CAPABILITY', undefined)).toEqual(IMPLICIT_DECAY_DEFAULTS);
-        expect(resolveDecayParams('CAPABILITY', {})).toEqual(IMPLICIT_DECAY_DEFAULTS);
-    });
-    it('fills missing defaults fields from §11.3 implicit defaults', () => {
-        const partial = { defaults: { floor: 0.5 } };
-        expect(resolveDecayParams('PROCESS', partial)).toEqual({
-            fresh_days: IMPLICIT_DECAY_DEFAULTS.fresh_days,
-            stale_days: IMPLICIT_DECAY_DEFAULTS.stale_days,
-            floor: 0.5,
-        });
-    });
-});
-describe('scoreElement (§11.4–11.5)', () => {
-    const today = '2026-06-05';
-    it('takes the max source-trust weight (§11.4): extra weak sources never subtract', () => {
-        const score = scoreElement({ type: 'CAPABILITY', admitted_at: today, sources: ['unverified', 'authoritative', 'single_source'] }, today);
-        expect(score.source_trust).toBe(1.0);
-        expect(score.confidence).toBe(1.0);
-        expect(score.sourced).toBe(true);
-    });
-    it('multiplies source_trust by freshness', () => {
-        // §11.4 worked example: authoritative · floor.
-        const score = scoreElement({ type: 'X', admitted_at: '2024-01-01', sources: ['authoritative'] }, today, { defaults: D });
-        expect(score.source_trust).toBe(1.0);
-        expect(score.freshness).toBeCloseTo(0.3, 10);
-        expect(score.confidence).toBeCloseTo(0.3, 10);
-    });
-    it('marks unsourced elements at the unverified floor (§11.5) and sourced=false', () => {
-        const undef = scoreElement({ type: 'X', admitted_at: today }, today);
-        const empty = scoreElement({ type: 'X', admitted_at: today, sources: [] }, today);
-        for (const score of [undef, empty]) {
-            expect(score.source_trust).toBe(0.25);
-            expect(score.sourced).toBe(false);
-            expect(score.confidence).toBeCloseTo(0.25, 10);
-        }
-    });
-    it('distinguishes unsourced (counted separately) from sourced-but-unverified', () => {
-        const unsourced = scoreElement({ type: 'X', admitted_at: today }, today);
-        const sourcedUnverified = scoreElement({ type: 'X', admitted_at: today, sources: ['unverified'] }, today);
-        expect(unsourced.source_trust).toBe(sourcedUnverified.source_trust);
-        expect(unsourced.sourced).toBe(false);
-        expect(sourcedUnverified.sourced).toBe(true);
-    });
-});
-describe('confidenceBand (§11.6)', () => {
-    it('uses the documented thresholds', () => {
-        expect(confidenceBand(1.0)).toBe('A');
-        expect(confidenceBand(0.8)).toBe('A');
-        expect(confidenceBand(0.79)).toBe('B');
-        expect(confidenceBand(0.6)).toBe('B');
-        expect(confidenceBand(0.59)).toBe('C');
-        expect(confidenceBand(0.4)).toBe('C');
-        expect(confidenceBand(0.39)).toBe('D');
-        expect(confidenceBand(0)).toBe('D');
-    });
-});
-describe('composeView (§11.6)', () => {
-    it('headlines weakest link, reports mean and coverage', () => {
-        const composite = composeView([
-            { source_trust: 1.0, freshness: 1.0, confidence: 1.0, sourced: true },
-            { source_trust: 0.5, freshness: 0.8, confidence: 0.4, sourced: true },
-            { source_trust: 0.25, freshness: 1.0, confidence: 0.25, sourced: false },
-        ]);
-        expect(composite.weakest_link).toBeCloseTo(0.25, 10);
-        expect(composite.band).toBe('D');
-        expect(composite.mean).toBeCloseTo((1.0 + 0.4 + 0.25) / 3, 10);
-        expect(composite.coverage).toBeCloseTo(2 / 3, 10);
-        expect(composite.element_count).toBe(3);
-        expect(composite.unsourced_count).toBe(1);
-    });
-    it('returns a degenerate composite (band D, counts 0) for an empty set', () => {
-        const composite = composeView([]);
-        expect(composite.element_count).toBe(0);
-        expect(composite.weakest_link).toBe(0);
-        expect(composite.mean).toBe(0);
-        expect(composite.coverage).toBe(0);
-        expect(composite.band).toBe('D');
-    });
-});
-describe('scoreView end-to-end', () => {
-    const today = '2026-06-05';
-    it('composes weakest-link / mean / coverage / band from heterogenous elements', () => {
-        const view = scoreView([
-            // weakest link = 0.50 → band C
-            { type: 'X', admitted_at: today, sources: ['authoritative'] }, // 1.00
-            { type: 'X', admitted_at: today, sources: ['corroborated'] }, // 0.80
-            { type: 'X', admitted_at: today, sources: ['single_source'] }, // 0.50
-            { type: 'X', admitted_at: today, sources: ['corroborated'] }, // 0.80
-        ], today);
-        expect(view.composite.weakest_link).toBeCloseTo(0.5, 10);
-        expect(view.composite.band).toBe('C');
-        expect(view.composite.mean).toBeCloseTo((1.0 + 0.8 + 0.5 + 0.8) / 4, 10);
-        expect(view.composite.coverage).toBe(1);
-        expect(view.composite.unsourced_count).toBe(0);
-        expect(view.today).toBe(today);
-    });
-    it('accepts Date for today and converts to ISO', () => {
-        const view = scoreView([{ type: 'X', admitted_at: '2026-06-05', sources: ['authoritative'] }], new Date(Date.UTC(2026, 5, 5)));
-        expect(view.today).toBe('2026-06-05');
-        expect(view.composite.band).toBe('A');
-    });
-    it('reports band D and 0% coverage when every element is unsourced and fully stale', () => {
-        const view = scoreView([
-            { type: 'X' },
-            { type: 'X' },
-        ], '2026-06-05', { defaults: D });
-        // unsourced (0.25) · freshness floor (0.3) = 0.075 → band D.
-        expect(view.composite.coverage).toBe(0);
-        expect(view.composite.unsourced_count).toBe(2);
-        expect(view.composite.band).toBe('D');
-        expect(view.composite.weakest_link).toBeCloseTo(0.075, 10);
-    });
-});
-describe('formatConfidenceHeader (§11.6)', () => {
-    it('renders the documented header shape', () => {
-        const view = scoreView([{ type: 'X', admitted_at: '2026-06-05', sources: ['corroborated'] }], '2026-06-05');
-        // corroborated (0.8) · freshness 1.0 = 0.80 → band A (A is ≥ 0.8).
-        expect(formatConfidenceHeader(view)).toBe('Data confidence (as of 2026-06-05): A (weakest link) · 0.80 mean · 100% sourced');
-    });
-    it('returns an empty string for an empty composite', () => {
-        const view = scoreView([], '2026-06-05');
-        expect(formatConfidenceHeader(view)).toBe('');
-    });
-});

package/dist/constraint/__tests__/example.test.d.ts

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

package/dist/constraint/__tests__/example.test.js

@@ -1,14 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { readFileSync } from 'node:fs';
-import { fileURLToPath } from 'node:url';
-import path from 'node:path';
-import yaml from 'js-yaml';
-import { validateConstraint } from '../validate.js';
-const dir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../../../../tests/fixtures/notation-corpus/constraint');
-describe('constraint worked example (notation-corpus)', () => {
-    it('validates CONSTRAINT-GDPR-RESIDENCY-1.yaml without error', () => {
-        const data = yaml.load(readFileSync(path.join(dir, 'CONSTRAINT-GDPR-RESIDENCY-1.yaml'), 'utf-8'));
-        const v = validateConstraint(data);
-        expect(v.valid, JSON.stringify(v.errors)).toBe(true);
-    });
-});

package/dist/constraint/__tests__/validate.test.d.ts

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

package/dist/constraint/__tests__/validate.test.js

@@ -1,58 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { validateConstraint } from '../validate.js';
-function valid() {
-    return {
-        notation: 'constraint',
-        id: 'CONSTRAINT-GDPR-RESIDENCY-1',
-        name: 'EU customer personal data must be stored within EU/EEA jurisdictions',
-        statement: 'Personal data of EU customers MUST NOT be persisted outside EU / EEA jurisdictions.',
-        status: 'active',
-        zone: 'canon',
-        admitted_at: '2026-05-29',
-        admitted_by: 'v.korobeinikov',
-        gate_checks: { uniqueness: 'pass', consistency: 'pass', completeness: 'pass' },
-        valid_from: '2018-05-25',
-        valid_to: null,
-        severity: 'mandatory',
-        owner_role: 'ROLE-DPO-1',
-        applies_to: ['APPLICATION-CRM-1'],
-    };
-}
-const codes = (input, opts) => validateConstraint(input, opts).errors.map((e) => e.code);
-describe('validateConstraint — positive', () => {
-    it('accepts a well-formed constraint', () => {
-        const r = validateConstraint(valid());
-        expect(r.valid, JSON.stringify(r.errors)).toBe(true);
-    });
-});
-describe('validateConstraint — CONST-001', () => {
-    it('flags missing required fields and wrong notation', () => {
-        const r = valid();
-        delete r.statement;
-        expect(codes(r)).toContain('CONST-001');
-        expect(codes({ ...valid(), notation: 'requirement' })).toContain('CONST-001');
-        expect(codes({ ...valid(), id: 'CONSTRAINT-001' })).toContain('CONST-001');
-    });
-});
-describe('validateConstraint — CONST-002/003', () => {
-    it('flags invalid status and severity', () => {
-        expect(codes({ ...valid(), status: 'enabled' })).toContain('CONST-002');
-        expect(codes({ ...valid(), severity: 'critical' })).toContain('CONST-003');
-    });
-});
-describe('validateConstraint — CONST-004/005 (catalog)', () => {
-    it('flags unresolved applies_to and owner_role with catalog', () => {
-        const catalog = { typeOf: () => undefined };
-        expect(codes(valid(), { catalog })).toContain('CONST-004');
-        expect(codes(valid(), { catalog })).toContain('CONST-005');
-    });
-    it('does not flag CONST-004 without catalog for well-formed applies_to', () => {
-        expect(codes(valid())).not.toContain('CONST-004');
-    });
-    it('resolves applies_to when catalogue admits the target', () => {
-        const catalog = {
-            typeOf: (id) => (id === 'APPLICATION-CRM-1' ? 'APPLICATION' : id === 'ROLE-DPO-1' ? 'ROLE' : undefined),
-        };
-        expect(validateConstraint(valid(), { catalog }).valid).toBe(true);
-    });
-});

package/dist/factor/__tests__/validate.test.d.ts

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

package/dist/factor/__tests__/validate.test.js

@@ -1,112 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { validateFactor } from '../validate.js';
-function validExternal() {
-    return {
-        notation: 'driver',
-        id: 'FACTOR-EU-REG-1',
-        name: 'EU regulatory window',
-        type: 'external',
-        category: 'legal',
-        description: 'Standing external driver — the EU regulatory regime.',
-        references_constraint: ['CONSTRAINT-GDPR-RESIDENCY-1'],
-        zone: 'canon',
-        admitted_at: '2026-05-29',
-        admitted_by: 'v.korobeinikov',
-        gate_checks: { uniqueness: 'pass', consistency: 'pass', completeness: 'pass' },
-        valid_from: '2026-05-26',
-        valid_to: null,
-    };
-}
-function validInternal() {
-    return {
-        notation: 'driver',
-        id: 'FACTOR-COMP-1',
-        name: 'Support response time',
-        type: 'internal',
-        description: 'Standing internal driver.',
-        zone: 'canon',
-        admitted_at: '2026-05-29',
-        admitted_by: 'v.korobeinikov',
-        gate_checks: { uniqueness: 'pass', consistency: 'pass', completeness: 'pass' },
-        valid_from: '2026-05-26',
-        valid_to: null,
-    };
-}
-const codes = (input, opts) => validateFactor(input, opts).errors.map(e => e.code);
-describe('validateFactor — positive', () => {
-    it('accepts a well-formed external PESTLE factor', () => {
-        const r = validateFactor(validExternal());
-        expect(r.valid, JSON.stringify(r.errors)).toBe(true);
-    });
-    it('accepts a well-formed internal factor (no PESTLE category)', () => {
-        expect(validateFactor(validInternal()).valid).toBe(true);
-    });
-    it('accepts a minimal factor with no optional fields', () => {
-        const f = validInternal();
-        delete f.type;
-        delete f.description;
-        expect(validateFactor(f).valid).toBe(true);
-    });
-});
-describe('validateFactor — FACTOR-001 (shape / id grammar)', () => {
-    it('flags a missing required envelope field', () => {
-        const f = validExternal();
-        delete f.admitted_by;
-        expect(codes(f)).toContain('FACTOR-001');
-    });
-    it('flags an id that violates the grammar', () => {
-        expect(codes({ ...validExternal(), id: 'FACTOR-EU-REG-001' })).toContain('FACTOR-001');
-        expect(codes({ ...validExternal(), id: 'FAC-1' })).toContain('FACTOR-001');
-        expect(codes({ ...validExternal(), id: 'factor-1' })).toContain('FACTOR-001');
-    });
-    it('flags a wrong notation tag and a non-canon zone', () => {
-        expect(codes({ ...validExternal(), notation: 'factor' })).toContain('FACTOR-001');
-        expect(codes({ ...validExternal(), zone: 'sandbox' })).toContain('FACTOR-001');
-    });
-    it('flags a missing valid_to key (distinct from a null value)', () => {
-        const f = validExternal();
-        delete f.valid_to;
-        expect(codes(f)).toContain('FACTOR-001');
-    });
-    it('rejects a non-object', () => {
-        expect(codes(null)).toEqual(['FACTOR-001']);
-        expect(codes(['a'])).toEqual(['FACTOR-001']);
-    });
-});
-describe('validateFactor — FACTOR-002 (type enum)', () => {
-    it('flags a type value outside {external, internal}', () => {
-        expect(codes({ ...validExternal(), type: 'driver' })).toContain('FACTOR-002');
-    });
-});
-describe('validateFactor — FACTOR-003 (PESTLE category)', () => {
-    it('flags a category outside PESTLE', () => {
-        expect(codes({ ...validExternal(), category: 'cosmic' })).toContain('FACTOR-003');
-    });
-    it('flags PESTLE category on an internal factor', () => {
-        const f = validInternal();
-        f.category = 'legal';
-        expect(codes(f)).toContain('FACTOR-003');
-    });
-    it('accepts each permitted PESTLE category on an external factor', () => {
-        for (const cat of ['political', 'economic', 'social', 'technological', 'legal', 'environmental']) {
-            const f = validExternal();
-            f.category = cat;
-            expect(codes(f)).not.toContain('FACTOR-003');
-        }
-    });
-});
-describe('validateFactor — FACTOR-004 (references_constraint)', () => {
-    it('flags a malformed references_constraint entry', () => {
-        expect(codes({ ...validExternal(), references_constraint: ['not an id'] })).toContain('FACTOR-004');
-    });
-    it('flags a references_constraint entry of the wrong TYPE', () => {
-        expect(codes({ ...validExternal(), references_constraint: ['GOAL-X-1'] })).toContain('FACTOR-004');
-    });
-    it('flags an unresolved id when a catalog is supplied', () => {
-        const catalog = { typeOf: () => undefined };
-        expect(codes(validExternal(), { catalog })).toContain('FACTOR-004');
-    });
-    it('does not flag without a catalog for a well-formed CONSTRAINT id', () => {
-        expect(codes(validExternal())).not.toContain('FACTOR-004');
-    });
-});

package/dist/fgca/__tests__/chain-table.test.d.ts

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

package/dist/fgca/__tests__/chain-table.test.js

@@ -1,158 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { buildChainTable } from '../chain-table.js';
-// Renders a ChainTable to a compact text grid for readable assertions. Each
-// cell shows "label×rowSpan" (×1 omitted); a position covered by a span above
-// shows "·".
-function asGrid(t) {
-    return t.rows.map(row => row.map(c => {
-        if (c === null)
-            return '·';
-        const label = c.cell ? c.cell.label : '∅';
-        return c.rowSpan > 1 ? `${label}×${c.rowSpan}` : label;
-    }));
-}
-describe('buildChainTable — worked example (FGCA)', () => {
-    // F1 → G1, G2 ; G1 → C1 → A1 ; G2 → C2 → A2, A3
-    const doc = {
-        factors: [{ id: 1, name: 'F1' }],
-        goals: [
-            { id: 10, name: 'G1', factor: [{ id: 1 }] },
-            { id: 11, name: 'G2', factor: [{ id: 1 }] },
-        ],
-        changes: [
-            { id: 20, name: 'C1', goal_id: 10, activity_ids: [30] },
-            { id: 21, name: 'C2', goal_id: 11, activity_ids: [31, 32] },
-        ],
-        activities: [
-            { id: 30, name: 'A1', goal_id: 10 },
-            { id: 31, name: 'A2', goal_id: 11 },
-            { id: 32, name: 'A3', goal_id: 11 },
-        ],
-    };
-    it('produces the spec grid with F1 spanning 3 and G2/C2 spanning 2', () => {
-        const t = buildChainTable(doc);
-        expect(t.columns).toEqual(['driver', 'goal', 'change', 'activity']);
-        expect(asGrid(t)).toEqual([
-            ['F1×3', 'G1', 'C1', 'A1'],
-            ['·', 'G2×2', 'C2×2', 'A2'],
-            ['·', '·', '·', 'A3'],
-        ]);
-    });
-    it('orders the merged cells with correct rowSpans on the model', () => {
-        const t = buildChainTable(doc);
-        // Factor cell spans all three rows.
-        expect(t.rows[0][0]).toMatchObject({ rowSpan: 3, cell: { label: 'F1' } });
-        // Covered positions are null (no <td> emitted).
-        expect(t.rows[1][0]).toBeNull();
-        expect(t.rows[2][1]).toBeNull();
-    });
-});
-describe('buildChainTable — FGA (no Change column)', () => {
-    // FGA links Goal → Activity directly via activity.goal_id; no changes.
-    const doc = {
-        factors: [{ id: 1, name: 'F1' }],
-        goals: [{ id: 10, name: 'G1', factor: [{ id: 1 }] }],
-        activities: [
-            { id: 30, name: 'A1', goal_id: 10 },
-            { id: 31, name: 'A2', goal_id: 10 },
-        ],
-    };
-    it('emits three columns and merges Factor/Goal across the two activities', () => {
-        const t = buildChainTable(doc, { hideChanges: true });
-        expect(t.columns).toEqual(['driver', 'goal', 'activity']);
-        expect(asGrid(t)).toEqual([
-            ['F1×2', 'G1×2', 'A1'],
-            ['·', '·', 'A2'],
-        ]);
-    });
-});
-describe('buildChainTable — missing downstream links (gaps stay visible)', () => {
-    it('shows a factor with no goal, a goal with no change, and a change with no activity', () => {
-        const doc = {
-            factors: [
-                { id: 1, name: 'F1' },
-                { id: 2, name: 'F2' }, // no goals
-            ],
-            goals: [
-                { id: 10, name: 'G1', factor: [{ id: 1 }] }, // no change, no activity
-                { id: 11, name: 'G2', factor: [{ id: 1 }] }, // has a change with no activity
-            ],
-            changes: [{ id: 20, name: 'C1', goal_id: 11, activity_ids: [] }],
-            activities: [],
-        };
-        const t = buildChainTable(doc);
-        expect(asGrid(t)).toEqual([
-            ['F1×2', 'G1', '∅', '∅'],
-            ['·', 'G2', 'C1', '∅'],
-            ['F2', '∅', '∅', '∅'],
-        ]);
-    });
-    it('renders a change-less direct goal→activity path with an empty Change cell', () => {
-        const doc = {
-            factors: [{ id: 1, name: 'F1' }],
-            goals: [{ id: 10, name: 'G1', factor: [{ id: 1 }] }],
-            // activity bound straight to the goal, not covered by any change
-            changes: [],
-            activities: [{ id: 30, name: 'A1', goal_id: 10 }],
-        };
-        const t = buildChainTable(doc);
-        expect(asGrid(t)).toEqual([['F1', 'G1', '∅', 'A1']]);
-    });
-});
-describe('buildChainTable — orphans (broken refs are warnings, not errors)', () => {
-    it('places a goal with a missing factor in a trailing empty-Factor row', () => {
-        const doc = {
-            factors: [{ id: 1, name: 'F1' }],
-            goals: [
-                { id: 10, name: 'G1', factor: [{ id: 1 }] },
-                { id: 11, name: 'Gx', factor: [{ id: 99 }] }, // factor 99 does not exist
-                { id: 12, name: 'Gy' }, // no factor at all
-            ],
-            changes: [{ id: 20, name: 'C1', goal_id: 10, activity_ids: [30] }],
-            activities: [{ id: 30, name: 'A1', goal_id: 10 }],
-        };
-        const t = buildChainTable(doc);
-        expect(asGrid(t)).toEqual([
-            ['F1', 'G1', 'C1', 'A1'],
-            ['∅×2', 'Gx', '∅', '∅'],
-            ['·', 'Gy', '∅', '∅'],
-        ]);
-    });
-    it('surfaces an unlinked activity as a trailing row with empty cells to its left', () => {
-        const doc = {
-            factors: [{ id: 1, name: 'F1' }],
-            goals: [{ id: 10, name: 'G1', factor: [{ id: 1 }] }],
-            changes: [{ id: 20, name: 'C1', goal_id: 10, activity_ids: [30] }],
-            activities: [
-                { id: 30, name: 'A1', goal_id: 10 },
-                { id: 99, name: 'Aorphan' }, // no goal, no change
-            ],
-        };
-        const t = buildChainTable(doc);
-        expect(asGrid(t)).toEqual([
-            ['F1', 'G1', 'C1', 'A1'],
-            ['∅', '∅', '∅', 'Aorphan'],
-        ]);
-    });
-    it('surfaces a change whose goal is missing as an empty Factor+Goal row', () => {
-        const doc = {
-            factors: [],
-            goals: [],
-            changes: [{ id: 20, name: 'Cx', goal_id: 999, activity_ids: [30] }],
-            activities: [{ id: 30, name: 'A1' }],
-        };
-        const t = buildChainTable(doc);
-        expect(asGrid(t)).toEqual([['∅', '∅', 'Cx', 'A1']]);
-    });
-});
-describe('buildChainTable — name fallback', () => {
-    it('falls back to the id when an element has an empty name', () => {
-        const doc = {
-            factors: [{ id: 7, name: '' }],
-            goals: [],
-            activities: [],
-        };
-        const t = buildChainTable(doc);
-        expect(t.rows[0][0]?.cell?.label).toBe('7');
-    });
-});

package/dist/fgca/__tests__/layout.test.d.ts

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