@transitrix/diagrams 1.8.6 → 1.8.8

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

@@ -1,169 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { validateIntegration } from '../validate.js';
-function valid() {
-    return {
-        notation: 'integration',
-        id: 'INTEGRATION-OMS-CRM-1',
-        source: 'APPLICATION-OMS-1',
-        target: 'APPLICATION-CRM-1',
-        direction: 'outbound',
-        protocol: 'REST',
-        zone: 'canon',
-        admitted_at: '2026-06-28',
-        admitted_by: 'v.korobeinikov',
-        gate_checks: { uniqueness: 'pass', consistency: 'pass', completeness: 'pass' },
-        valid_from: '2024-01-01',
-        valid_to: null,
-    };
-}
-function validWithInterface() {
-    return {
-        ...valid(),
-        id: 'INTEGRATION-OMS-EVENTS-1',
-        interface_semantics: true,
-        payload_class: 'domain_event',
-        sensitivity: 'internal',
-        directionality: 'producer',
-    };
-}
-const codes = (input) => validateIntegration(input).errors.map(e => e.code);
-describe('validateIntegration — positive', () => {
-    it('accepts a well-formed integration without interface_semantics', () => {
-        const r = validateIntegration(valid());
-        expect(r.valid, JSON.stringify(r.errors)).toBe(true);
-    });
-    it('accepts integration with no optional fields except required ones', () => {
-        const a = valid();
-        delete a.direction;
-        delete a.protocol;
-        expect(validateIntegration(a).valid).toBe(true);
-    });
-    it('accepts a valid integration with interface_semantics: true and all required fields', () => {
-        const r = validateIntegration(validWithInterface());
-        expect(r.valid, JSON.stringify(r.errors)).toBe(true);
-    });
-    it('accepts valid_to as a date string', () => {
-        expect(validateIntegration({ ...valid(), valid_to: '2026-12-31' }).valid).toBe(true);
-    });
-    it('accepts interface_semantics: false without requiring conditional fields', () => {
-        expect(validateIntegration({ ...valid(), interface_semantics: false }).valid).toBe(true);
-    });
-    it('accepts all four directionality values', () => {
-        for (const d of ['producer', 'consumer', 'request_reply', 'bidirectional_stream']) {
-            expect(validateIntegration({ ...validWithInterface(), directionality: d }).valid).toBe(true);
-        }
-    });
-    it('accepts all four sensitivity values', () => {
-        for (const s of ['public', 'internal', 'confidential', 'restricted']) {
-            expect(validateIntegration({ ...validWithInterface(), sensitivity: s }).valid).toBe(true);
-        }
-    });
-});
-describe('validateIntegration — INT-001 (shape / id grammar)', () => {
-    it('flags a non-object input', () => {
-        expect(codes(null)).toEqual(['INT-001']);
-        expect(codes('string')).toEqual(['INT-001']);
-    });
-    it('flags an id that violates the grammar', () => {
-        expect(codes({ ...valid(), id: 'INTEGRATION-001' })).toContain('INT-001');
-        expect(codes({ ...valid(), id: 'INT-1' })).toContain('INT-001');
-        expect(codes({ ...valid(), id: 'integration-oms-1' })).toContain('INT-001');
-    });
-    it('flags a wrong notation tag', () => {
-        expect(codes({ ...valid(), notation: 'integrations' })).toContain('INT-001');
-        expect(codes({ ...valid(), notation: 'application' })).toContain('INT-001');
-    });
-    it('flags a non-canon zone', () => {
-        expect(codes({ ...valid(), zone: 'sandbox' })).toContain('INT-001');
-    });
-    it('flags a missing zone', () => {
-        const a = valid();
-        delete a.zone;
-        expect(codes(a)).toContain('INT-001');
-    });
-    it('flags a missing source', () => {
-        const a = valid();
-        delete a.source;
-        expect(codes(a)).toContain('INT-001');
-    });
-    it('flags a missing target', () => {
-        const a = valid();
-        delete a.target;
-        expect(codes(a)).toContain('INT-001');
-    });
-    it('flags a missing admitted_at', () => {
-        const a = valid();
-        delete a.admitted_at;
-        expect(codes(a)).toContain('INT-001');
-    });
-    it('flags a missing valid_to key', () => {
-        const a = valid();
-        delete a.valid_to;
-        expect(codes(a)).toContain('INT-001');
-    });
-    it('flags missing gate_checks', () => {
-        const a = valid();
-        delete a.gate_checks;
-        expect(codes(a)).toContain('INT-001');
-    });
-    it('flags an invalid direction value', () => {
-        expect(codes({ ...valid(), direction: 'both' })).toContain('INT-001');
-    });
-});
-describe('validateIntegration — INT-001 (interface_semantics conditional fields)', () => {
-    it('flags missing protocol when interface_semantics is true', () => {
-        const a = validWithInterface();
-        delete a.protocol;
-        expect(codes(a)).toContain('INT-001');
-    });
-    it('flags missing payload_class when interface_semantics is true', () => {
-        const a = validWithInterface();
-        delete a.payload_class;
-        expect(codes(a)).toContain('INT-001');
-    });
-    it('flags missing sensitivity when interface_semantics is true', () => {
-        const a = validWithInterface();
-        delete a.sensitivity;
-        expect(codes(a)).toContain('INT-001');
-    });
-    it('flags missing directionality when interface_semantics is true', () => {
-        const a = validWithInterface();
-        delete a.directionality;
-        expect(codes(a)).toContain('INT-001');
-    });
-    it('flags all four missing at once', () => {
-        const a = valid();
-        a.interface_semantics = true;
-        delete a.protocol;
-        const errs = validateIntegration(a).errors.filter(e => e.code === 'INT-001');
-        expect(errs.length).toBeGreaterThanOrEqual(4);
-    });
-    it('flags an invalid sensitivity value when interface_semantics is true', () => {
-        expect(codes({ ...validWithInterface(), sensitivity: 'secret' })).toContain('INT-001');
-    });
-    it('flags an invalid directionality value when interface_semantics is true', () => {
-        expect(codes({ ...validWithInterface(), directionality: 'both_ways' })).toContain('INT-001');
-    });
-    it('does not fire INT-001 conditional checks when interface_semantics is absent', () => {
-        const a = valid();
-        const errs = validateIntegration(a).errors.filter(e => e.code === 'INT-001' && e.path && ['protocol', 'payload_class', 'sensitivity', 'directionality'].includes(e.path));
-        expect(errs).toHaveLength(0);
-    });
-});
-describe('validateIntegration — INT-002 (endpoint APPLICATION type)', () => {
-    it('flags a source that is not an APPLICATION-… id when interface_semantics is true', () => {
-        expect(codes({ ...validWithInterface(), source: 'INTEGRATION-OTHER-1' })).toContain('INT-002');
-        expect(codes({ ...validWithInterface(), source: 'ACTOR-SALES-1' })).toContain('INT-002');
-    });
-    it('flags a target that is not an APPLICATION-… id when interface_semantics is true', () => {
-        expect(codes({ ...validWithInterface(), target: 'TECHNOLOGY_SERVICE-KAFKA-1' })).toContain('INT-002');
-        expect(codes({ ...validWithInterface(), target: 'NODE-HOST-1' })).toContain('INT-002');
-    });
-    it('does not fire INT-002 when interface_semantics is absent', () => {
-        const a = { ...valid(), source: 'ACTOR-OPS-1', target: 'NODE-HOST-1' };
-        expect(codes(a)).not.toContain('INT-002');
-    });
-    it('does not fire INT-002 for valid APPLICATION-… endpoints', () => {
-        expect(codes(validWithInterface())).not.toContain('INT-002');
-    });
-});

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

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

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

@@ -1,107 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { validateLocation } from '../validate.js';
-function valid() {
-    return {
-        notation: 'location',
-        id: 'LOCATION-TBILISI-1',
-        name: 'Tbilisi Office',
-        type: 'office',
-        address: '14 Rustaveli Ave, Tbilisi 0108, Georgia',
-        country_code: 'GE',
-        timezone: 'Asia/Tbilisi',
-        zone: 'canon',
-        admitted_at: '2026-06-28',
-        admitted_by: 'v.korobeinikov',
-        gate_checks: { uniqueness: 'pass', consistency: 'pass', completeness: 'pass' },
-        valid_from: '2024-01-01',
-        valid_to: null,
-    };
-}
-const codes = (input) => validateLocation(input).errors.map(e => e.code);
-describe('validateLocation — positive', () => {
-    it('accepts a well-formed office location', () => {
-        const r = validateLocation(valid());
-        expect(r.valid, JSON.stringify(r.errors)).toBe(true);
-    });
-    it('accepts a country with no optional fields', () => {
-        const a = valid();
-        a.id = 'LOCATION-GE-1';
-        a.name = 'Georgia';
-        a.type = 'country';
-        delete a.address;
-        delete a.country_code;
-        delete a.timezone;
-        expect(validateLocation(a).valid).toBe(true);
-    });
-    it('accepts a virtual location', () => {
-        const a = valid();
-        a.id = 'LOCATION-VIRTUAL-1';
-        a.name = 'Remote';
-        a.type = 'virtual';
-        expect(validateLocation(a).valid).toBe(true);
-    });
-    it('accepts a location with a valid parent reference', () => {
-        expect(validateLocation({ ...valid(), parent: 'LOCATION-GE-1' }).valid).toBe(true);
-    });
-    it('accepts valid_to as a date string', () => {
-        expect(validateLocation({ ...valid(), valid_to: '2026-12-31' }).valid).toBe(true);
-    });
-});
-describe('validateLocation — LOC-001 (shape / id grammar)', () => {
-    it('flags a missing required envelope field (name)', () => {
-        const a = valid();
-        delete a.name;
-        expect(codes(a)).toContain('LOC-001');
-    });
-    it('flags an id that violates the grammar', () => {
-        expect(codes({ ...valid(), id: 'LOCATION-001' })).toContain('LOC-001');
-        expect(codes({ ...valid(), id: 'LOC-1' })).toContain('LOC-001');
-    });
-    it('flags a wrong notation tag', () => {
-        expect(codes({ ...valid(), notation: 'place' })).toContain('LOC-001');
-    });
-    it('flags a non-canon zone', () => {
-        expect(codes({ ...valid(), zone: 'sandbox' })).toContain('LOC-001');
-    });
-    it('flags a missing zone', () => {
-        const a = valid();
-        delete a.zone;
-        expect(codes(a)).toContain('LOC-001');
-    });
-    it('flags a missing type', () => {
-        const a = valid();
-        delete a.type;
-        expect(codes(a)).toContain('LOC-001');
-    });
-    it('flags a missing valid_to key', () => {
-        const a = valid();
-        delete a.valid_to;
-        expect(codes(a)).toContain('LOC-001');
-    });
-    it('flags missing gate_checks', () => {
-        const a = valid();
-        delete a.gate_checks;
-        expect(codes(a)).toContain('LOC-001');
-    });
-    it('rejects a non-object', () => {
-        expect(codes(null)).toEqual(['LOC-001']);
-    });
-});
-describe('validateLocation — LOC-002 (type enum)', () => {
-    it('flags a type outside the allowed enum', () => {
-        expect(codes({ ...valid(), type: 'building' })).toContain('LOC-002');
-        expect(codes({ ...valid(), type: 'facility' })).toContain('LOC-002');
-    });
-});
-describe('validateLocation — LOC-003 (parent grammar)', () => {
-    it('flags a parent that is not a LOCATION-… id', () => {
-        expect(codes({ ...valid(), parent: 'ACTOR-OPS-1' })).toContain('LOC-003');
-        expect(codes({ ...valid(), parent: 'not-an-id' })).toContain('LOC-003');
-    });
-    it('accepts a null or absent parent without error', () => {
-        expect(codes({ ...valid(), parent: undefined })).not.toContain('LOC-003');
-        const a = valid();
-        delete a.parent;
-        expect(codes(a)).not.toContain('LOC-003');
-    });
-});

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

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

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

@@ -1,100 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { validateNode } from '../validate.js';
-function valid() {
-    return {
-        notation: 'node',
-        id: 'NODE-KAFKA-HOST-1',
-        name: 'Kafka Cluster Host',
-        type: 'cloud_instance',
-        description: 'AWS EC2 auto-scaling group hosting the Kafka broker cluster.',
-        provider: 'AWS',
-        region: 'eu-central-1',
-        zone: 'canon',
-        admitted_at: '2026-06-28',
-        admitted_by: 'v.korobeinikov',
-        gate_checks: { uniqueness: 'pass', consistency: 'pass', completeness: 'pass' },
-        valid_from: '2024-01-01',
-        valid_to: null,
-    };
-}
-const codes = (input) => validateNode(input).errors.map(e => e.code);
-describe('validateNode — positive', () => {
-    it('accepts a well-formed cloud_instance node with all optional fields', () => {
-        const r = validateNode(valid());
-        expect(r.valid, JSON.stringify(r.errors)).toBe(true);
-    });
-    it('accepts a server node with no optional fields', () => {
-        const a = valid();
-        a.id = 'NODE-DB-1';
-        a.name = 'Primary DB Server';
-        a.type = 'server';
-        delete a.description;
-        delete a.provider;
-        delete a.region;
-        expect(validateNode(a).valid).toBe(true);
-    });
-    it('accepts all five type values', () => {
-        for (const t of ['server', 'cloud_instance', 'container_platform', 'database_server', 'network_device']) {
-            expect(validateNode({ ...valid(), type: t }).valid).toBe(true);
-        }
-    });
-    it('accepts valid_to as a date string', () => {
-        expect(validateNode({ ...valid(), valid_to: '2026-12-31' }).valid).toBe(true);
-    });
-});
-describe('validateNode — NOD-001 (shape / id grammar)', () => {
-    it('flags a non-object input', () => {
-        expect(codes(null)).toEqual(['NOD-001']);
-        expect(codes('string')).toEqual(['NOD-001']);
-    });
-    it('flags an id that violates the grammar', () => {
-        expect(codes({ ...valid(), id: 'NODE-001' })).toContain('NOD-001');
-        expect(codes({ ...valid(), id: 'NOD-1' })).toContain('NOD-001');
-        expect(codes({ ...valid(), id: 'node-kafka-1' })).toContain('NOD-001');
-    });
-    it('flags a wrong notation tag', () => {
-        expect(codes({ ...valid(), notation: 'nodes' })).toContain('NOD-001');
-        expect(codes({ ...valid(), notation: 'infrastructure' })).toContain('NOD-001');
-    });
-    it('flags a non-canon zone', () => {
-        expect(codes({ ...valid(), zone: 'sandbox' })).toContain('NOD-001');
-    });
-    it('flags a missing zone', () => {
-        const a = valid();
-        delete a.zone;
-        expect(codes(a)).toContain('NOD-001');
-    });
-    it('flags a missing name', () => {
-        const a = valid();
-        delete a.name;
-        expect(codes(a)).toContain('NOD-001');
-    });
-    it('flags a missing valid_to key', () => {
-        const a = valid();
-        delete a.valid_to;
-        expect(codes(a)).toContain('NOD-001');
-    });
-    it('flags missing gate_checks', () => {
-        const a = valid();
-        delete a.gate_checks;
-        expect(codes(a)).toContain('NOD-001');
-    });
-    it('flags a missing type', () => {
-        const a = valid();
-        delete a.type;
-        expect(codes(a)).toContain('NOD-001');
-    });
-});
-describe('validateNode — NOD-002 (type enum)', () => {
-    it('flags a type outside the allowed enum', () => {
-        expect(codes({ ...valid(), type: 'virtual_machine' })).toContain('NOD-002');
-        expect(codes({ ...valid(), type: 'storage' })).toContain('NOD-002');
-        expect(codes({ ...valid(), type: 'cluster' })).toContain('NOD-002');
-    });
-    it('does not flag a missing type with NOD-002 (NOD-001 fires instead)', () => {
-        const a = valid();
-        delete a.type;
-        expect(codes(a)).not.toContain('NOD-002');
-        expect(codes(a)).toContain('NOD-001');
-    });
-});

package/dist/process-blueprint/__tests__/compliance-lane.test.d.ts

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

package/dist/process-blueprint/__tests__/compliance-lane.test.js

@@ -1,272 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { layoutProcessBlueprint } from '../layout.js';
-// ── fixtures ────────────────────────────────────────────────────────────────
-const STAGES = [
-    { id: 'STAGE-1', name: 'Receive', goal: 'g1', result: 'r1' },
-    { id: 'STAGE-2', name: 'Process', goal: 'g2', result: 'r2' },
-    { id: 'STAGE-3', name: 'Ship', goal: 'g3', result: 'r3' },
-];
-function buildFile(overrides = {}) {
-    return {
-        notation: 'process-blueprint',
-        process_blueprint: { id: 'PROCESS_BLUEPRINT-T-1', name: 'Test', stages: STAGES, ...overrides },
-    };
-}
-const REQ_A = { id: 'REQ-1', derived_from: ['LAW-GDPR-1'] };
-const REQ_B = { id: 'REQ-2', derived_from: ['LAW-GDPR-1', 'LAW-SOX-2'] };
-const REQ_DEADLINE = {
-    id: 'REQ-3',
-    derived_from: ['LAW-PCI-3'],
-    deadline: '2020-01-01', // past_due
-};
-// ── helpers ─────────────────────────────────────────────────────────────────
-function makeAssertion(about, status, realisedVia) {
-    return { about, status, realised_via: realisedVia };
-}
-function layout(file, input, overrides = {}) {
-    return layoutProcessBlueprint(file, {
-        complianceLane: { enabled: true, ...overrides },
-        complianceInput: input,
-    });
-}
-// ── tests ───────────────────────────────────────────────────────────────────
-describe('compliance lane derivation', () => {
-    it('returns no complianceRow when lane is disabled (default)', () => {
-        const l = layoutProcessBlueprint(buildFile(), {});
-        expect(l.complianceRow).toBeUndefined();
-    });
-    it('returns no complianceRow when enabled but no input provided', () => {
-        const l = layoutProcessBlueprint(buildFile(), { complianceLane: { enabled: true } });
-        expect(l.complianceRow).toBeUndefined();
-    });
-    it('returns no complianceRow when assertions have no realised_via matching stage IDs', () => {
-        const input = {
-            assertions: [makeAssertion('REQ-1', 'compliant', ['STEP-99'])],
-            requirements: [REQ_A],
-        };
-        const l = layout(buildFile(), input);
-        expect(l.complianceRow).toBeUndefined();
-    });
-    it('derives a chip for each law-stage pair', () => {
-        const input = {
-            assertions: [makeAssertion('REQ-1', 'compliant', ['STAGE-1'])],
-            requirements: [REQ_A],
-        };
-        const l = layout(buildFile(), input);
-        expect(l.complianceRow).toBeDefined();
-        const chips = l.complianceRow.chips;
-        expect(chips).toHaveLength(1);
-        expect(chips[0].lawId).toBe('LAW-GDPR-1');
-        expect(chips[0].stageIndex).toBe(0);
-    });
-    it('produces one chip per law per stage (same law, two stages → two chips)', () => {
-        const input = {
-            assertions: [makeAssertion('REQ-1', 'compliant', ['STAGE-1', 'STAGE-2'])],
-            requirements: [REQ_A],
-        };
-        const l = layout(buildFile(), input);
-        const chips = l.complianceRow.chips;
-        expect(chips).toHaveLength(2);
-        expect(chips.map(c => c.stageIndex).sort()).toEqual([0, 1]);
-        expect(chips.every(c => c.lawId === 'LAW-GDPR-1')).toBe(true);
-    });
-    it('merges multiple assertions for the same law-stage into one chip', () => {
-        const input = {
-            assertions: [
-                makeAssertion('REQ-1', 'compliant', ['STAGE-1']),
-                makeAssertion('REQ-1', 'partial', ['STAGE-1']),
-            ],
-            requirements: [REQ_A],
-        };
-        const l = layout(buildFile(), input);
-        expect(l.complianceRow.chips).toHaveLength(1);
-    });
-    describe('decoration: new', () => {
-        it('marks chip as new when law is not in previous snapshot', () => {
-            const input = {
-                assertions: [makeAssertion('REQ-1', 'compliant', ['STAGE-1'])],
-                requirements: [REQ_A],
-            };
-            const l = layout(buildFile(), input, { previousSnapshot: { 'STAGE-1': [] } });
-            expect(l.complianceRow.chips[0].decorations).toContain('new');
-        });
-        it('does not mark chip as new when law is in previous snapshot', () => {
-            const input = {
-                assertions: [makeAssertion('REQ-1', 'compliant', ['STAGE-1'])],
-                requirements: [REQ_A],
-            };
-            const l = layout(buildFile(), input, { previousSnapshot: { 'STAGE-1': ['LAW-GDPR-1'] } });
-            expect(l.complianceRow.chips[0].decorations).not.toContain('new');
-        });
-    });
-    describe('decoration: gap', () => {
-        it('marks chip as gap when assertion status is non_compliant', () => {
-            const input = {
-                assertions: [makeAssertion('REQ-1', 'non_compliant', ['STAGE-1'])],
-                requirements: [REQ_A],
-            };
-            const l = layout(buildFile(), input);
-            expect(l.complianceRow.chips[0].decorations).toContain('gap');
-        });
-        it('marks chip as gap when assertion status is partial', () => {
-            const input = {
-                assertions: [makeAssertion('REQ-1', 'partial', ['STAGE-2'])],
-                requirements: [REQ_A],
-            };
-            const l = layout(buildFile(), input);
-            expect(l.complianceRow.chips[0].decorations).toContain('gap');
-        });
-        it('does not mark chip as gap for compliant assertion', () => {
-            const input = {
-                assertions: [makeAssertion('REQ-1', 'compliant', ['STAGE-1'])],
-                requirements: [REQ_A],
-            };
-            const l = layout(buildFile(), input);
-            expect(l.complianceRow.chips[0].decorations).not.toContain('gap');
-        });
-        it('propagates gap if any assertion for the same law-stage is non-compliant', () => {
-            const input = {
-                assertions: [
-                    makeAssertion('REQ-1', 'compliant', ['STAGE-1']),
-                    makeAssertion('REQ-1', 'non_compliant', ['STAGE-1']),
-                ],
-                requirements: [REQ_A],
-            };
-            const l = layout(buildFile(), input);
-            expect(l.complianceRow.chips[0].decorations).toContain('gap');
-        });
-    });
-    describe('decoration: deadline', () => {
-        it('marks chip as deadline when gap exists and requirement deadline is past_due', () => {
-            const input = {
-                assertions: [makeAssertion('REQ-3', 'non_compliant', ['STAGE-1'])],
-                requirements: [REQ_DEADLINE],
-            };
-            const l = layout(buildFile(), input);
-            const d = l.complianceRow.chips[0].decorations;
-            expect(d).toContain('gap');
-            expect(d).toContain('deadline');
-        });
-        it('does not mark deadline when gap is absent even if deadline is past_due', () => {
-            const input = {
-                assertions: [makeAssertion('REQ-3', 'compliant', ['STAGE-1'])],
-                requirements: [REQ_DEADLINE],
-            };
-            const l = layout(buildFile(), input);
-            expect(l.complianceRow.chips[0].decorations).not.toContain('deadline');
-        });
-        it('does not mark deadline when no deadline on requirement', () => {
-            const input = {
-                assertions: [makeAssertion('REQ-1', 'non_compliant', ['STAGE-1'])],
-                requirements: [REQ_A],
-            };
-            const l = layout(buildFile(), input);
-            expect(l.complianceRow.chips[0].decorations).not.toContain('deadline');
-        });
-        it('all three decorations can stack on the same chip', () => {
-            const input = {
-                assertions: [makeAssertion('REQ-3', 'non_compliant', ['STAGE-1'])],
-                requirements: [REQ_DEADLINE],
-            };
-            const l = layout(buildFile(), input, { previousSnapshot: { 'STAGE-1': [] } });
-            const d = l.complianceRow.chips[0].decorations;
-            expect(d).toContain('new');
-            expect(d).toContain('gap');
-            expect(d).toContain('deadline');
-        });
-    });
-    describe('jurisdiction filter', () => {
-        it('passes through all laws when no jurisdictions filter', () => {
-            const input = {
-                assertions: [makeAssertion('REQ-2', 'compliant', ['STAGE-1'])],
-                requirements: [REQ_B], // derived_from: [LAW-GDPR-1, LAW-SOX-2]
-                codexJurisdictions: { 'LAW-GDPR-1': 'EU', 'LAW-SOX-2': 'US' },
-            };
-            const l = layout(buildFile(), input, { jurisdictions: [] });
-            expect(l.complianceRow.chips).toHaveLength(2);
-        });
-        it('filters to only the selected jurisdictions', () => {
-            const input = {
-                assertions: [makeAssertion('REQ-2', 'compliant', ['STAGE-1'])],
-                requirements: [REQ_B],
-                codexJurisdictions: { 'LAW-GDPR-1': 'EU', 'LAW-SOX-2': 'US' },
-            };
-            const l = layout(buildFile(), input, { jurisdictions: ['EU'] });
-            expect(l.complianceRow.chips).toHaveLength(1);
-            expect(l.complianceRow.chips[0].lawId).toBe('LAW-GDPR-1');
-        });
-        it('returns no row when jurisdiction filter excludes all laws', () => {
-            const input = {
-                assertions: [makeAssertion('REQ-2', 'compliant', ['STAGE-1'])],
-                requirements: [REQ_B],
-                codexJurisdictions: { 'LAW-GDPR-1': 'EU', 'LAW-SOX-2': 'US' },
-            };
-            const l = layout(buildFile(), input, { jurisdictions: ['AU'] });
-            expect(l.complianceRow).toBeUndefined();
-        });
-    });
-    describe('null-guards', () => {
-        it('tolerates null assertion entries without throwing', () => {
-            const input = {
-                assertions: [null, makeAssertion('REQ-1', 'compliant', ['STAGE-1'])],
-                requirements: [REQ_A],
-            };
-            expect(() => layout(buildFile(), input)).not.toThrow();
-        });
-        it('skips assertions with no realised_via', () => {
-            const input = {
-                assertions: [{ about: 'REQ-1', status: 'compliant' }],
-                requirements: [REQ_A],
-            };
-            const l = layout(buildFile(), input);
-            expect(l.complianceRow).toBeUndefined();
-        });
-        it('skips assertions whose requirement is not in the input', () => {
-            const input = {
-                assertions: [makeAssertion('REQ-MISSING', 'non_compliant', ['STAGE-1'])],
-                requirements: [REQ_A],
-            };
-            const l = layout(buildFile(), input);
-            expect(l.complianceRow).toBeUndefined();
-        });
-    });
-    describe('legend', () => {
-        it('adds a compliance legend entry when the row is present', () => {
-            const input = {
-                assertions: [makeAssertion('REQ-1', 'compliant', ['STAGE-1'])],
-                requirements: [REQ_A],
-            };
-            const l = layout(buildFile(), input);
-            const complianceLegend = l.legend.find(entry => entry.kind === 'compliance');
-            expect(complianceLegend).toBeDefined();
-            expect(complianceLegend.label).toBe('Compliance');
-        });
-        it('does not add compliance legend when row is absent', () => {
-            const l = layoutProcessBlueprint(buildFile(), {});
-            expect(l.legend.some(e => e.kind === 'compliance')).toBe(false);
-        });
-    });
-    describe('layout geometry', () => {
-        it('total height grows by the compliance row height', () => {
-            const withoutLane = layoutProcessBlueprint(buildFile(), {});
-            const input = {
-                assertions: [makeAssertion('REQ-1', 'compliant', ['STAGE-1'])],
-                requirements: [REQ_A],
-            };
-            const withLane = layout(buildFile(), input);
-            expect(withLane.bounds.height).toBeGreaterThan(withoutLane.bounds.height);
-            expect(withLane.bounds.height).toBe(withoutLane.bounds.height + withLane.complianceRow.height);
-        });
-        it('chip x aligns to the stage column', () => {
-            const input = {
-                assertions: [makeAssertion('REQ-1', 'compliant', ['STAGE-2'])],
-                requirements: [REQ_A],
-            };
-            const l = layout(buildFile(), input);
-            const chip = l.complianceRow.chips[0];
-            // Chip x must be at the start of stage-2's column (index 1) + cellPadding.
-            const expectedX = l.legendColumnWidth + 1 * l.stageColumnWidth + 8; // default cellPadding = 8
-            expect(chip.x).toBe(expectedX);
-        });
-    });
-});

package/dist/process-blueprint/__tests__/layout.test.d.ts

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