@transitrix/diagrams 1.8.6 → 1.8.8

package/src/capability-map/__tests__/validate.test.ts

@@ -1,238 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import yaml from 'js-yaml';
-import { validateCapabilityMap } from '../validate.js';
-
-const EXAMPLES_DIR = path.resolve(process.cwd(), '..', '..', 'tests', 'fixtures', 'notation-corpus', 'capability-map');
-
-const VALID_MAP = {
-  notation: 'capability-map',
-  capability_map: {
-    id: 'CM-BUSINESS-001',
-    name: 'Business Capabilities Map',
-    assessment_date: '2026-05-08',
-    capabilities: [
-      {
-        id: 'V1',
-        name: 'Order Management',
-        type: 'domain',
-        current_maturity: 2,
-        target_maturity: 3,
-        target_date: '2026-12-31',
-        children: [
-          { id: 'V1.1', name: 'Order Intake', current_maturity: 3 },
-          { id: 'V1.2', name: 'Order Fulfilment', current_maturity: 2, target_maturity: 3 },
-        ],
-      },
-      {
-        id: 'H1',
-        name: 'Master Data Management',
-        type: 'supporting',
-        current_maturity: 1,
-        target_maturity: 3,
-      },
-    ],
-  },
-};
-
-describe('validateCapabilityMap', () => {
-  it('passes on valid input', () => {
-    const r = validateCapabilityMap(VALID_MAP);
-    expect(r.valid).toBe(true);
-    expect(r.errors).toHaveLength(0);
-  });
-
-  it('CMAP-001: rejects non-object input', () => {
-    const r = validateCapabilityMap(null);
-    expect(r.errors[0].code).toBe('CMAP-001');
-  });
-
-  it('CMAP-001: rejects missing notation', () => {
-    const { notation: _, ...rest } = VALID_MAP;
-    const r = validateCapabilityMap(rest);
-    expect(r.errors.some(e => e.code === 'CMAP-001')).toBe(true);
-  });
-
-  it('CMAP-001: rejects wrong notation value', () => {
-    const r = validateCapabilityMap({ ...VALID_MAP, notation: 'goals' });
-    expect(r.errors.some(e => e.code === 'CMAP-001')).toBe(true);
-  });
-
-  it('CMAP-002: rejects missing capability_map', () => {
-    const r = validateCapabilityMap({ notation: 'capability-map' });
-    expect(r.errors.some(e => e.code === 'CMAP-002')).toBe(true);
-  });
-
-  it('CMAP-002: rejects missing id/name/assessment_date', () => {
-    const r = validateCapabilityMap({ notation: 'capability-map', capability_map: { capabilities: [] } });
-    expect(r.errors.filter(e => e.code === 'CMAP-002').length).toBeGreaterThanOrEqual(3);
-  });
-
-  it('CMAP-002: rejects non-array capabilities', () => {
-    const map = { ...VALID_MAP.capability_map, capabilities: 'oops' };
-    const r = validateCapabilityMap({ ...VALID_MAP, capability_map: map });
-    expect(r.errors.some(e => e.code === 'CMAP-002')).toBe(true);
-  });
-
-  it('CMAP-003: rejects capability missing id/name/current_maturity', () => {
-    const map = { ...VALID_MAP.capability_map, capabilities: [{}] };
-    const r = validateCapabilityMap({ ...VALID_MAP, capability_map: map });
-    expect(r.errors.filter(e => e.code === 'CMAP-003').length).toBeGreaterThanOrEqual(3);
-  });
-
-  it('CMAP-004: rejects invalid type', () => {
-    const map = {
-      ...VALID_MAP.capability_map,
-      capabilities: [{ id: 'V1', name: 'X', type: 'core', current_maturity: 2 }],
-    };
-    const r = validateCapabilityMap({ ...VALID_MAP, capability_map: map });
-    expect(r.errors.some(e => e.code === 'CMAP-004')).toBe(true);
-  });
-
-  it('CMAP-004: accepts type domain/supporting', () => {
-    for (const type of ['domain', 'supporting']) {
-      const map = {
-        ...VALID_MAP.capability_map,
-        capabilities: [{ id: 'V1', name: 'X', type, current_maturity: 2 }],
-      };
-      const r = validateCapabilityMap({ ...VALID_MAP, capability_map: map });
-      expect(r.errors.some(e => e.code === 'CMAP-004')).toBe(false);
-    }
-  });
-
-  it('CMAP-005: rejects current_maturity out of range', () => {
-    const map = {
-      ...VALID_MAP.capability_map,
-      capabilities: [{ id: 'V1', name: 'X', current_maturity: 6 }],
-    };
-    const r = validateCapabilityMap({ ...VALID_MAP, capability_map: map });
-    expect(r.errors.some(e => e.code === 'CMAP-005')).toBe(true);
-  });
-
-  it('CMAP-005: rejects non-integer current_maturity', () => {
-    const map = {
-      ...VALID_MAP.capability_map,
-      capabilities: [{ id: 'V1', name: 'X', current_maturity: 2.5 }],
-    };
-    const r = validateCapabilityMap({ ...VALID_MAP, capability_map: map });
-    expect(r.errors.some(e => e.code === 'CMAP-005')).toBe(true);
-  });
-
-  it('CMAP-006: rejects target_maturity out of range', () => {
-    const map = {
-      ...VALID_MAP.capability_map,
-      capabilities: [{ id: 'V1', name: 'X', current_maturity: 2, target_maturity: 0 }],
-    };
-    const r = validateCapabilityMap({ ...VALID_MAP, capability_map: map });
-    expect(r.errors.some(e => e.code === 'CMAP-006')).toBe(true);
-  });
-
-  it('CMAP-007: rejects malformed assessment_date', () => {
-    const map = { ...VALID_MAP.capability_map, assessment_date: '08-05-2026' };
-    const r = validateCapabilityMap({ ...VALID_MAP, capability_map: map });
-    expect(r.errors.some(e => e.code === 'CMAP-007')).toBe(true);
-  });
-
-  it('CMAP-007: rejects malformed target_date on a node', () => {
-    const map = {
-      ...VALID_MAP.capability_map,
-      capabilities: [{ id: 'V1', name: 'X', current_maturity: 2, target_date: 'tomorrow' }],
-    };
-    const r = validateCapabilityMap({ ...VALID_MAP, capability_map: map });
-    expect(r.errors.some(e => e.code === 'CMAP-007')).toBe(true);
-  });
-
-  it('CMAP-008: rejects duplicate capability id across the tree', () => {
-    const map = {
-      ...VALID_MAP.capability_map,
-      capabilities: [
-        { id: 'V1', name: 'A', current_maturity: 2, children: [{ id: 'V1', name: 'B', current_maturity: 1 }] },
-      ],
-    };
-    const r = validateCapabilityMap({ ...VALID_MAP, capability_map: map });
-    expect(r.errors.some(e => e.code === 'CMAP-008')).toBe(true);
-  });
-
-  it('CMAP-009: rejects malformed capability id', () => {
-    const map = {
-      ...VALID_MAP.capability_map,
-      capabilities: [{ id: 'X1', name: 'A', current_maturity: 2 }],
-    };
-    const r = validateCapabilityMap({ ...VALID_MAP, capability_map: map });
-    expect(r.errors.some(e => e.code === 'CMAP-009')).toBe(true);
-  });
-
-  it('CMAP-009: accepts V/H ids with dotted levels', () => {
-    for (const id of ['V1', 'V1.2', 'V1.2.3', 'H1', 'H1.2', 'H10.20.30']) {
-      const map = {
-        ...VALID_MAP.capability_map,
-        capabilities: [{ id, name: 'A', current_maturity: 2 }],
-      };
-      const r = validateCapabilityMap({ ...VALID_MAP, capability_map: map });
-      expect(r.errors.some(e => e.code === 'CMAP-009')).toBe(false);
-    }
-  });
-
-  it('CMAP-009: accepts the canonical CAPABILITY- prefix', () => {
-    for (const id of ['CAPABILITY-V1', 'CAPABILITY-V1.2', 'CAPABILITY-V1.2.3', 'CAPABILITY-H1', 'CAPABILITY-H1.2']) {
-      const map = {
-        ...VALID_MAP.capability_map,
-        capabilities: [{ id, name: 'A', current_maturity: 2 }],
-      };
-      const r = validateCapabilityMap({ ...VALID_MAP, capability_map: map });
-      expect(r.errors.some(e => e.code === 'CMAP-009')).toBe(false);
-    }
-  });
-
-  it('validates children recursively', () => {
-    const map = {
-      ...VALID_MAP.capability_map,
-      capabilities: [{
-        id: 'V1', name: 'Root', current_maturity: 2,
-        children: [{ id: 'BAD_ID', name: 'X', current_maturity: 7 }],
-      }],
-    };
-    const r = validateCapabilityMap({ ...VALID_MAP, capability_map: map });
-    expect(r.errors.some(e => e.code === 'CMAP-009')).toBe(true);
-    expect(r.errors.some(e => e.code === 'CMAP-005')).toBe(true);
-  });
-
-  it('accepts empty capabilities array', () => {
-    const map = { ...VALID_MAP.capability_map, capabilities: [] };
-    const r = validateCapabilityMap({ ...VALID_MAP, capability_map: map });
-    expect(r.valid).toBe(true);
-  });
-
-  // Pre-release blocker regression (orchestrator review 2026-05-21).
-  it('[blocker] tolerates a null element in capabilities[] without throwing', () => {
-    const map = { ...VALID_MAP.capability_map, capabilities: [null] };
-    const r = validateCapabilityMap({ ...VALID_MAP, capability_map: map });
-    expect(r.valid).toBe(false);
-    expect(r.errors.some(e => e.code === 'CMAP-003')).toBe(true);
-  });
-
-  it('[blocker] tolerates a null child capability without throwing', () => {
-    const map = {
-      ...VALID_MAP.capability_map,
-      capabilities: [{ id: 'V1', name: 'X', current_maturity: 2, children: [null] }],
-    };
-    const r = validateCapabilityMap({ ...VALID_MAP, capability_map: map });
-    expect(r.valid).toBe(false);
-    expect(r.errors.some(e => e.code === 'CMAP-003')).toBe(true);
-  });
-});
-
-describe('capability-map examples (regression)', () => {
-  const files = fs.readdirSync(EXAMPLES_DIR).filter(f => f.endsWith('.yaml'));
-  expect(files.length).toBeGreaterThan(0);
-  for (const file of files) {
-    it(`validates tests/fixtures/notation-corpus/capability-map/${file}`, () => {
-      const text = fs.readFileSync(path.join(EXAMPLES_DIR, file), 'utf8');
-      const parsed = yaml.load(text);
-      const r = validateCapabilityMap(parsed);
-      expect(r.errors).toEqual([]);
-      expect(r.valid).toBe(true);
-    });
-  }
-});

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

@@ -1,97 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { validateChange } from '../validate.js';
-import type { CanonCatalog } from '../../typed-id.js';
-
-function valid(): Record<string, unknown> {
-  return {
-    notation: 'change',
-    id: 'CHANGE-EU-CRM-1',
-    name: 'Stand up EU-localised CRM and payment processing',
-    goals: ['GOAL-EU-1'],
-    description: 'The required delta to operate in EU markets.',
-    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 validateChange>[1]): string[] =>
-  validateChange(input, opts).errors.map(e => e.code);
-
-describe('validateChange — positive', () => {
-  it('accepts a well-formed change', () => {
-    const r = validateChange(valid());
-    expect(r.valid, JSON.stringify(r.errors)).toBe(true);
-  });
-
-  it('accepts a minimal change with no optional fields', () => {
-    const c = valid();
-    delete c.goals;
-    delete c.description;
-    expect(validateChange(c).valid).toBe(true);
-  });
-
-  it('accepts a child change with a CHANGE parent', () => {
-    const c = valid();
-    c.id = 'CHANGE-EU-CRM-2';
-    c.parent = 'CHANGE-EU-CRM-1';
-    expect(validateChange(c).valid).toBe(true);
-  });
-});
-
-describe('validateChange — CHANGE-001 (shape / id grammar)', () => {
-  it('flags a missing required envelope field', () => {
-    const c = valid();
-    delete c.name;
-    expect(codes(c)).toContain('CHANGE-001');
-  });
-
-  it('flags an id that violates the grammar', () => {
-    expect(codes({ ...valid(), id: 'CHANGE-EU-CRM-001' })).toContain('CHANGE-001');
-    expect(codes({ ...valid(), id: 'CHG-1' })).toContain('CHANGE-001');
-  });
-
-  it('flags a wrong notation tag', () => {
-    expect(codes({ ...valid(), notation: 'gap' })).toContain('CHANGE-001');
-  });
-
-  it('flags a non-array goals', () => {
-    expect(codes({ ...valid(), goals: 'GOAL-EU-1' })).toContain('CHANGE-001');
-  });
-
-  it('rejects a non-object', () => {
-    expect(codes(null)).toEqual(['CHANGE-001']);
-  });
-});
-
-describe('validateChange — CHANGE-002 (goals references)', () => {
-  it('flags a malformed goals entry', () => {
-    expect(codes({ ...valid(), goals: ['not an id'] })).toContain('CHANGE-002');
-  });
-
-  it('flags a goals entry of the wrong TYPE', () => {
-    expect(codes({ ...valid(), goals: ['FACTOR-X-1'] })).toContain('CHANGE-002');
-  });
-
-  it('flags an unresolved id when a catalog is supplied', () => {
-    const catalog: CanonCatalog = { typeOf: () => undefined };
-    expect(codes(valid(), { catalog })).toContain('CHANGE-002');
-  });
-});
-
-describe('validateChange — CHANGE-003 (parent)', () => {
-  it('flags a parent of the wrong TYPE', () => {
-    expect(codes({ ...valid(), parent: 'GOAL-X-1' })).toContain('CHANGE-003');
-  });
-
-  it('flags a parent equal to self', () => {
-    expect(codes({ ...valid(), parent: 'CHANGE-EU-CRM-1' })).toContain('CHANGE-003');
-  });
-
-  it('flags a malformed parent', () => {
-    expect(codes({ ...valid(), parent: 'not an id' })).toContain('CHANGE-003');
-  });
-});

package/src/codex/__tests__/example.test.ts

@@ -1,40 +0,0 @@
-// Conformance test for CODEX worked examples under
-// `tests/fixtures/notation-corpus/codex/` — pins #518 Phase C2 corpus signal.
-
-import { describe, it, expect } from 'vitest';
-import { readFileSync, readdirSync } from 'node:fs';
-import { fileURLToPath } from 'node:url';
-import path from 'node:path';
-import yaml from 'js-yaml';
-import { validateCodex, folderJurisdictionFromPath } from '../validate.js';
-
-const corpusRoot = path.resolve(
-  path.dirname(fileURLToPath(import.meta.url)),
-  '../../../../../tests/fixtures/notation-corpus/codex',
-);
-
-function codexFixturePaths(): Array<{ rel: string; folderJurisdiction?: string }> {
-  const out: Array<{ rel: string; folderJurisdiction?: string }> = [];
-  for (const zone of ['external/EU', 'internal']) {
-    const dir = path.join(corpusRoot, zone);
-    for (const f of readdirSync(dir).filter((x) => x.endsWith('.yaml'))) {
-      const rel = path.join('codex', zone, f).replace(/\\/g, '/');
-      out.push({
-        rel,
-        folderJurisdiction: folderJurisdictionFromPath(rel),
-      });
-    }
-  }
-  return out;
-}
-
-describe('codex worked examples (notation-corpus)', () => {
-  for (const { rel, folderJurisdiction } of codexFixturePaths()) {
-    it(`validates ${rel} without error`, () => {
-      const data = yaml.load(readFileSync(path.join(corpusRoot, rel.replace(/^codex\//, '')), 'utf-8'));
-      const v = validateCodex(data, { folderJurisdiction });
-      expect(v.valid, JSON.stringify(v.errors)).toBe(true);
-      expect(v.errors).toHaveLength(0);
-    });
-  }
-});

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

@@ -1,84 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import {
-  validateCodex,
-  isCodexDoc,
-  folderJurisdictionFromPath,
-} from '../validate.js';
-
-const VALID_EXTERNAL = {
-  zone: 'codex',
-  id: 'LAW-GDPR-1',
-  name: 'General Data Protection Regulation',
-  type: 'LAW',
-  jurisdiction: 'eu',
-  effective_date: '2018-05-25',
-  admitted_at: '2026-06-01',
-  admitted_by: 'legal.team',
-  gate_checks: { uniqueness: 'pass' },
-};
-
-const VALID_INTERNAL = {
-  zone: 'codex',
-  id: 'INTERNAL_STANDARD-coding-conventions-1',
-  name: 'Engineering Coding Conventions',
-  type: 'INTERNAL_STANDARD',
-  issuing_authority: 'VP Engineering',
-  effective_date: '2026-01-01',
-  admitted_at: '2026-05-27',
-  admitted_by: 'vp.engineering',
-  gate_checks: { source_authority: 'VP Engineering' },
-};
-
-describe('validateCodex', () => {
-  it('accepts a valid external artefact', () => {
-    const r = validateCodex(VALID_EXTERNAL, { folderJurisdiction: 'eu' });
-    expect(r.valid, JSON.stringify(r.errors)).toBe(true);
-  });
-
-  it('accepts a valid internal artefact', () => {
-    expect(validateCodex(VALID_INTERNAL).valid).toBe(true);
-  });
-
-  it('CODEX-001 rejects non-mapping input', () => {
-    expect(validateCodex(null).errors.some((e) => e.code === 'CODEX-001')).toBe(true);
-  });
-
-  it('CODEX-001 rejects wrong zone', () => {
-    const r = validateCodex({ ...VALID_EXTERNAL, zone: 'canon' });
-    expect(r.errors.some((e) => e.code === 'CODEX-001' && e.path === 'zone')).toBe(true);
-  });
-
-  it('CODEX-002 rejects type/id prefix mismatch', () => {
-    const r = validateCodex({ ...VALID_EXTERNAL, type: 'REGULATION' });
-    expect(r.errors.some((e) => e.code === 'CODEX-002')).toBe(true);
-  });
-
-  it('CODEX-003 requires jurisdiction on external artefacts', () => {
-    const r = validateCodex({ ...VALID_EXTERNAL, jurisdiction: '' });
-    expect(r.errors.some((e) => e.code === 'CODEX-003' && e.path === 'jurisdiction')).toBe(true);
-  });
-
-  it('CODEX-005 enforces folder jurisdiction match', () => {
-    const r = validateCodex(VALID_EXTERNAL, { folderJurisdiction: 'ge' });
-    expect(r.errors.some((e) => e.code === 'CODEX-005')).toBe(true);
-  });
-
-  it('CODEX-004 requires issuing_authority on internal artefacts', () => {
-    const r = validateCodex({ ...VALID_INTERNAL, issuing_authority: '' });
-    expect(r.errors.some((e) => e.code === 'CODEX-004')).toBe(true);
-  });
-});
-
-describe('isCodexDoc', () => {
-  it('detects zone: codex', () => {
-    expect(isCodexDoc({ zone: 'codex', id: 'LAW-1' })).toBe(true);
-    expect(isCodexDoc({ zone: 'canon' })).toBe(false);
-  });
-});
-
-describe('folderJurisdictionFromPath', () => {
-  it('parses codex/external/<jurisdiction>/ paths', () => {
-    expect(folderJurisdictionFromPath('codex/external/eu/LAW-GDPR-1.yaml')).toBe('eu');
-    expect(folderJurisdictionFromPath('codex/internal/POLICY-1.yaml')).toBeUndefined();
-  });
-});

package/src/compliance/__tests__/canon-catalog.test.ts

@@ -1,68 +0,0 @@
-import { describe, it, expect } from 'vitest';
-
-import {
-  admitDocumentToCatalog,
-  buildComplianceScan,
-  catalogFromMap,
-} from '../canon-catalog.js';
-
-describe('buildComplianceScan', () => {
-  it('admits codex, requirement, and assertion ids into the catalogue', () => {
-    const docs = [
-      {
-        path: 'codex/external/ge/LAW-PERSONAL-DATA-2017-1.yaml',
-        data: {
-          zone: 'codex',
-          id: 'LAW-PERSONAL-DATA-2017-1',
-          name: 'Law',
-          type: 'LAW',
-        },
-      },
-      {
-        path: 'canon/elements/01_motivation/requirements/REQUIREMENT-DATA-ERASURE-1.yaml',
-        data: {
-          notation: 'requirement',
-          id: 'REQUIREMENT-DATA-ERASURE-1',
-          name: 'Erasure',
-          derived_from: ['LAW-PERSONAL-DATA-2017-1'],
-        },
-      },
-      {
-        path: 'canon/elements/02_business/products/PRODUCT-MOBILE-1.yaml',
-        data: { notation: 'product', id: 'PRODUCT-MOBILE-1', name: 'Mobile' },
-      },
-      {
-        path: 'canon/assertions/ASSERTION-MOBILE-DATA-ERASURE-1.yaml',
-        data: {
-          notation: 'assertion',
-          id: 'ASSERTION-MOBILE-DATA-ERASURE-1',
-          about: 'REQUIREMENT-DATA-ERASURE-1',
-          subject: 'PRODUCT-MOBILE-1',
-          status: 'compliant',
-        },
-      },
-    ];
-
-    const { catalog, complianceCanon, pathById } = buildComplianceScan(docs);
-    expect(catalog.typeOf('LAW-PERSONAL-DATA-2017-1')).toBe('LAW');
-    expect(catalog.typeOf('REQUIREMENT-DATA-ERASURE-1')).toBe('REQUIREMENT');
-    expect(catalog.typeOf('PRODUCT-MOBILE-1')).toBe('PRODUCT');
-    expect(complianceCanon.requirements).toHaveLength(1);
-    expect(complianceCanon.assertions).toHaveLength(1);
-    expect(complianceCanon.codex).toHaveLength(1);
-    expect(pathById.get('REQUIREMENT-DATA-ERASURE-1')).toContain('requirements/');
-  });
-});
-
-describe('admitDocumentToCatalog', () => {
-  it('uses explicit codex type when the id prefix is ambiguous', () => {
-    const map = new Map<string, string>();
-    admitDocumentToCatalog(map, {
-      zone: 'codex',
-      id: 'INTERNAL_STANDARD-coding-conventions-1',
-      type: 'INTERNAL_STANDARD',
-    });
-    const catalog = catalogFromMap(map);
-    expect(catalog.typeOf('INTERNAL_STANDARD-coding-conventions-1')).toBe('INTERNAL_STANDARD');
-  });
-});

package/src/compliance/__tests__/classify.test.ts

@@ -1,64 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { emptyCanon, ingestComplianceDoc } from '../classify.js';
-
-describe('ingestComplianceDoc', () => {
-  it('buckets each artefact kind by notation / zone', () => {
-    const canon = emptyCanon();
-    expect(ingestComplianceDoc(canon, { notation: 'product', id: 'PRODUCT-1', name: 'P' })).toBe('PRODUCT-1');
-    expect(ingestComplianceDoc(canon, { notation: 'requirement', id: 'REQUIREMENT-1', name: 'R', severity: 'high', derived_from: ['LAW-1'], admitted_at: '2026-05-28' })).toBe('REQUIREMENT-1');
-    expect(ingestComplianceDoc(canon, { notation: 'assertion', id: 'ASSERTION-1', about: 'REQUIREMENT-1', subject: 'PRODUCT-1', status: 'compliant', evidence: [{ kind: 'note', text: 'x' }], admitted_at: '2026-05-28' })).toBe('ASSERTION-1');
-    expect(ingestComplianceDoc(canon, { id: 'LAW-1', name: 'Law', type: 'LAW', zone: 'codex', jurisdiction: 'ge' })).toBe('LAW-1');
-
-    expect(canon.products).toEqual([{ id: 'PRODUCT-1', name: 'P' }]);
-    expect(canon.requirements[0]).toMatchObject({ id: 'REQUIREMENT-1', severity: 'high', derived_from: ['LAW-1'] });
-    expect(canon.assertions[0]).toMatchObject({ id: 'ASSERTION-1', status: 'compliant', evidenceCount: 1 });
-    expect(canon.codex[0]).toMatchObject({ id: 'LAW-1', type: 'LAW', jurisdiction: 'ge' });
-    expect(canon.subjects).toEqual([]);
-  });
-
-  it('ingests capability, process, application, system into canon.subjects', () => {
-    const canon = emptyCanon();
-    expect(ingestComplianceDoc(canon, { notation: 'capability', id: 'CAPABILITY-V2', name: 'CRM' })).toBe('CAPABILITY-V2');
-    expect(ingestComplianceDoc(canon, { notation: 'process', id: 'PROCESS-CS-1', name: 'Support' })).toBe('PROCESS-CS-1');
-    expect(ingestComplianceDoc(canon, { notation: 'application', id: 'APP-ERP-1', name: 'ERP System' })).toBe('APP-ERP-1');
-    expect(ingestComplianceDoc(canon, { notation: 'system', id: 'SYSTEM-IAM-1', name: 'IAM' })).toBe('SYSTEM-IAM-1');
-    expect(canon.subjects).toEqual([
-      { id: 'CAPABILITY-V2', name: 'CRM' },
-      { id: 'PROCESS-CS-1', name: 'Support' },
-      { id: 'APP-ERP-1', name: 'ERP System' },
-      { id: 'SYSTEM-IAM-1', name: 'IAM' },
-    ]);
-    expect(canon.products).toEqual([]);
-  });
-
-  it('falls back to id when name is absent for subjects', () => {
-    const canon = emptyCanon();
-    ingestComplianceDoc(canon, { notation: 'capability', id: 'CAPABILITY-X-1' });
-    expect(canon.subjects[0]).toEqual({ id: 'CAPABILITY-X-1', name: 'CAPABILITY-X-1' });
-  });
-
-  it('captures owner_to_confirm on pending_owner assertions', () => {
-    const canon = emptyCanon();
-    ingestComplianceDoc(canon, {
-      notation: 'assertion', id: 'ASSERTION-PO-1',
-      about: 'REQUIREMENT-1', subject: 'PRODUCT-1',
-      status: 'pending_owner', owner_to_confirm: 'alice@example.com',
-    });
-    expect(canon.assertions[0]).toMatchObject({
-      id: 'ASSERTION-PO-1',
-      status: 'pending_owner',
-      owner_to_confirm: 'alice@example.com',
-    });
-  });
-
-  it('returns null for non-artefacts, missing id, and malformed assertions', () => {
-    const canon = emptyCanon();
-    expect(ingestComplianceDoc(canon, { notation: 'goals', id: 'X-1' })).toBeNull();
-    expect(ingestComplianceDoc(canon, { notation: 'product' })).toBeNull(); // no id
-    expect(ingestComplianceDoc(canon, { notation: 'assertion', id: 'ASSERTION-2', about: 'R' })).toBeNull(); // missing subject/status
-    expect(ingestComplianceDoc(canon, null)).toBeNull();
-    expect(ingestComplianceDoc(canon, 'str')).toBeNull();
-    expect(canon.products).toEqual([]);
-    expect(canon.subjects).toEqual([]);
-  });
-});