@transitrix/diagrams 1.8.6 → 1.8.7

package/src/confidence/__tests__/score.test.ts

@@ -1,254 +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';
-import type { ConfidenceDecayConfig, DecayParams } from '../types.js';
-
-const D: DecayParams = { 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: ConfidenceDecayConfig = {
-    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: ConfidenceDecayConfig = { 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/src/constraint/__tests__/example.test.ts

@@ -1,19 +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/src/constraint/__tests__/validate.test.ts

@@ -1,68 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { validateConstraint } from '../validate.js';
-import type { CanonCatalog } from '../../typed-id.js';
-
-function valid(): Record<string, unknown> {
-  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: unknown, opts?: Parameters<typeof validateConstraint>[1]): string[] =>
-  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: CanonCatalog = { 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: CanonCatalog = {
-      typeOf: (id) => (id === 'APPLICATION-CRM-1' ? 'APPLICATION' : id === 'ROLE-DPO-1' ? 'ROLE' : undefined),
-    };
-    expect(validateConstraint(valid(), { catalog }).valid).toBe(true);
-  });
-});

package/src/factor/__tests__/validate.test.ts

@@ -1,133 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { validateFactor } from '../validate.js';
-import type { CanonCatalog } from '../../typed-id.js';
-
-function validExternal(): Record<string, unknown> {
-  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(): Record<string, unknown> {
-  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: unknown, opts?: Parameters<typeof validateFactor>[1]): string[] =>
-  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: CanonCatalog = { 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/src/fgca/__tests__/chain-table.test.ts

@@ -1,172 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { buildChainTable, type ChainTable, type ChainColumn } from '../chain-table.js';
-import type { FGCAPreviewDoc } from '../preview-layout.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: ChainTable): string[][] {
-  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: FGCAPreviewDoc = {
-    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<ChainColumn[]>(['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: FGCAPreviewDoc = {
-    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<ChainColumn[]>(['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: FGCAPreviewDoc = {
-      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: FGCAPreviewDoc = {
-      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: FGCAPreviewDoc = {
-      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: FGCAPreviewDoc = {
-      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: FGCAPreviewDoc = {
-      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: FGCAPreviewDoc = {
-      factors: [{ id: 7, name: '' }],
-      goals: [],
-      activities: [],
-    };
-    const t = buildChainTable(doc);
-    expect(t.rows[0][0]?.cell?.label).toBe('7');
-  });
-});