@transitrix/diagrams 1.8.6 → 1.8.7

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

@@ -1,80 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { validateRequirement } from '../validate.js';
-function valid() {
-    return {
-        notation: 'requirement',
-        id: 'REQUIREMENT-DATA-ERASURE-1',
-        name: 'Personal-data erasure within 30 days',
-        description: 'The controller must erase personal data within 30 days of a verified request.',
-        severity: 'high',
-        zone: 'canon',
-        admitted_at: '2026-05-28',
-        admitted_by: 'v.korobeinikov',
-        gate_checks: { uniqueness: 'pass', consistency: 'pass', completeness: 'pass' },
-        valid_from: '2017-05-01',
-        valid_to: null,
-    };
-}
-const codes = (input, opts) => validateRequirement(input, opts).errors.map(e => e.code);
-describe('validateRequirement — positive', () => {
-    it('accepts a well-formed requirement', () => {
-        const r = validateRequirement(valid());
-        expect(r.valid, JSON.stringify(r.errors)).toBe(true);
-        expect(r.errors).toHaveLength(0);
-    });
-    it('accepts an internal-only requirement with no derived_from', () => {
-        const r = valid();
-        delete r.derived_from;
-        r.severity = 'medium';
-        expect(validateRequirement(r).valid).toBe(true);
-    });
-});
-describe('validateRequirement — REQ-001 (shape / id grammar)', () => {
-    it('flags a missing required field', () => {
-        const r = valid();
-        delete r.name;
-        expect(codes(r)).toContain('REQ-001');
-    });
-    it('flags an id that violates the grammar', () => {
-        expect(codes({ ...valid(), id: 'REQUIREMENT-DATA-ERASURE-001' })).toContain('REQ-001'); // leading zero
-        expect(codes({ ...valid(), id: 'REQ-1' })).toContain('REQ-001'); // wrong TYPE
-        expect(codes({ ...valid(), id: 'requirement-data-1' })).toContain('REQ-001'); // lowercase TYPE
-    });
-    it('flags a wrong notation tag and a non-canon zone', () => {
-        expect(codes({ ...valid(), notation: 'req' })).toContain('REQ-001');
-        expect(codes({ ...valid(), zone: 'sandbox' })).toContain('REQ-001');
-    });
-    it('flags a missing valid_to key (distinct from a null value)', () => {
-        const r = valid();
-        delete r.valid_to;
-        expect(codes(r)).toContain('REQ-001');
-        expect(validateRequirement({ ...valid(), valid_to: null }).valid).toBe(true);
-    });
-    it('rejects a non-object', () => {
-        expect(codes(null)).toEqual(['REQ-001']);
-        expect(codes('x')).toEqual(['REQ-001']);
-        expect(codes(['a'])).toEqual(['REQ-001']);
-    });
-});
-describe('validateRequirement — REQ-002 (derived_from resolution)', () => {
-    it('flags a well-formed allowed-type ref that does not resolve in the catalog', () => {
-        const catalog = { typeOf: () => undefined };
-        expect(codes({ ...valid(), derived_from: ['LAW-PERSONAL-DATA-2017-1'] }, { catalog })).toContain('REQ-002');
-    });
-    it('flags a malformed derived_from entry (cannot resolve)', () => {
-        expect(codes({ ...valid(), derived_from: ['not an id'] })).toContain('REQ-002');
-    });
-    it('does not flag REQ-002 without a catalog for a well-formed allowed-type ref', () => {
-        expect(codes({ ...valid(), derived_from: ['LAW-PERSONAL-DATA-2017-1'] })).not.toContain('REQ-002');
-    });
-});
-describe('validateRequirement — REQ-003 (derived_from TYPE)', () => {
-    it('flags a derived_from TYPE outside LAW/REGULATION/POLICY/INTERNAL_STANDARD', () => {
-        expect(codes({ ...valid(), derived_from: ['PRODUCT-MOBILE-1'] })).toContain('REQ-003');
-    });
-    it('accepts each permitted derived_from TYPE', () => {
-        for (const id of ['LAW-X-1', 'REGULATION-X-1', 'POLICY-X-1', 'INTERNAL_STANDARD-X-1']) {
-            expect(codes({ ...valid(), derived_from: [id] })).not.toContain('REQ-003');
-        }
-    });
-});

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

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

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

@@ -1,183 +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 { validateScenario } from '../validate.js';
-const EXAMPLES_DIR = path.resolve(process.cwd(), '..', '..', 'tests', 'fixtures', 'notation-corpus', 'scenarios');
-const VALID_SCENARIO = {
-    notation: 'scenarios',
-    scenario: {
-        id: 'SCN-001',
-        name: 'Optimistic Growth 2027',
-        status: 'Active',
-        created_at: '2026-01-01',
-        vision: 'Aggressive expansion scenario.',
-        factors_view: [
-            { factor_id: 'FAC-MARKET-001', relevance: 'High', impact: 'Revenue growth' },
-            { factor_id: 'FAC-TECH-001', relevance: 'Medium' },
-        ],
-        goals: [{ goal_id: 'GOAL-REV-001' }],
-        capabilities: [{ capability_id: 'CAP-ECOMM-001' }],
-        activities: [{ activity_id: 'ACT-EXPAND-001' }],
-        products: [{ product_id: 'PROD-PLATFORM-001' }],
-        processes: [{ process_id: 'PROC-DELIVERY-001' }],
-        applications: [{ app_id: 'APP-CRM-001' }, { app_id: 'APP-OMS-001' }],
-    },
-};
-describe('validateScenario', () => {
-    it('passes on valid input', () => {
-        const r = validateScenario(VALID_SCENARIO);
-        expect(r.valid).toBe(true);
-        expect(r.errors).toHaveLength(0);
-    });
-    it('SCN-001: rejects non-object input', () => {
-        const r = validateScenario(null);
-        expect(r.errors[0].code).toBe('SCN-001');
-    });
-    it('SCN-001: rejects missing notation', () => {
-        const { notation: _, ...rest } = VALID_SCENARIO;
-        const r = validateScenario(rest);
-        expect(r.errors.some(e => e.code === 'SCN-001')).toBe(true);
-    });
-    it('SCN-001: rejects wrong notation value', () => {
-        const r = validateScenario({ ...VALID_SCENARIO, notation: 'goals' });
-        expect(r.errors.some(e => e.code === 'SCN-001')).toBe(true);
-    });
-    it('SCN-002: rejects missing scenario', () => {
-        const r = validateScenario({ notation: 'scenarios' });
-        expect(r.errors.some(e => e.code === 'SCN-002')).toBe(true);
-    });
-    it('SCN-002: rejects missing id/name/status', () => {
-        const r = validateScenario({ notation: 'scenarios', scenario: {} });
-        expect(r.errors.filter(e => e.code === 'SCN-002').length).toBeGreaterThanOrEqual(3);
-    });
-    it('SCN-003: rejects invalid status', () => {
-        const scn = { ...VALID_SCENARIO.scenario, status: 'Retired' };
-        const r = validateScenario({ ...VALID_SCENARIO, scenario: scn });
-        expect(r.errors.some(e => e.code === 'SCN-003')).toBe(true);
-    });
-    it('SCN-003: accepts all valid statuses', () => {
-        for (const status of ['Draft', 'Active', 'Archived']) {
-            const scn = { ...VALID_SCENARIO.scenario, status };
-            const r = validateScenario({ ...VALID_SCENARIO, scenario: scn });
-            expect(r.errors.some(e => e.code === 'SCN-003')).toBe(false);
-        }
-    });
-    it('SCN-004: rejects malformed created_at', () => {
-        const scn = { ...VALID_SCENARIO.scenario, created_at: '01-01-2026' };
-        const r = validateScenario({ ...VALID_SCENARIO, scenario: scn });
-        expect(r.errors.some(e => e.code === 'SCN-004')).toBe(true);
-    });
-    it('SCN-004: accepts missing created_at', () => {
-        const { created_at: _, ...scn } = VALID_SCENARIO.scenario;
-        const r = validateScenario({ ...VALID_SCENARIO, scenario: scn });
-        expect(r.errors.some(e => e.code === 'SCN-004')).toBe(false);
-    });
-    it('SCN-005: rejects non-array factors_view', () => {
-        const scn = { ...VALID_SCENARIO.scenario, factors_view: 'oops' };
-        const r = validateScenario({ ...VALID_SCENARIO, scenario: scn });
-        expect(r.errors.some(e => e.code === 'SCN-005')).toBe(true);
-    });
-    it('SCN-005: rejects factor missing factor_id', () => {
-        const scn = { ...VALID_SCENARIO.scenario, factors_view: [{ relevance: 'High' }] };
-        const r = validateScenario({ ...VALID_SCENARIO, scenario: scn });
-        expect(r.errors.some(e => e.code === 'SCN-005')).toBe(true);
-    });
-    it('SCN-006: rejects invalid factor relevance', () => {
-        const scn = {
-            ...VALID_SCENARIO.scenario,
-            factors_view: [{ factor_id: 'F1', relevance: 'Critical' }],
-        };
-        const r = validateScenario({ ...VALID_SCENARIO, scenario: scn });
-        expect(r.errors.some(e => e.code === 'SCN-006')).toBe(true);
-    });
-    it('SCN-013: rejects duplicate factor_id', () => {
-        const scn = {
-            ...VALID_SCENARIO.scenario,
-            factors_view: [{ factor_id: 'F1' }, { factor_id: 'F1' }],
-        };
-        const r = validateScenario({ ...VALID_SCENARIO, scenario: scn });
-        expect(r.errors.some(e => e.code === 'SCN-013')).toBe(true);
-    });
-    const refCases = [
-        { field: 'goals', idField: 'goal_id', errorCode: 'SCN-007' },
-        { field: 'capabilities', idField: 'capability_id', errorCode: 'SCN-008' },
-        { field: 'activities', idField: 'activity_id', errorCode: 'SCN-009' },
-        { field: 'products', idField: 'product_id', errorCode: 'SCN-010' },
-        { field: 'processes', idField: 'process_id', errorCode: 'SCN-011' },
-        { field: 'applications', idField: 'app_id', errorCode: 'SCN-012' },
-    ];
-    for (const c of refCases) {
-        it(`${c.errorCode}: rejects ${c.field}[*] missing ${c.idField}`, () => {
-            const scn = { ...VALID_SCENARIO.scenario, [c.field]: [{}] };
-            const r = validateScenario({ ...VALID_SCENARIO, scenario: scn });
-            expect(r.errors.some(e => e.code === c.errorCode)).toBe(true);
-        });
-        it(`${c.errorCode}: rejects non-array ${c.field}`, () => {
-            const scn = { ...VALID_SCENARIO.scenario, [c.field]: 'oops' };
-            const r = validateScenario({ ...VALID_SCENARIO, scenario: scn });
-            expect(r.errors.some(e => e.code === c.errorCode)).toBe(true);
-        });
-        it(`${c.errorCode}: rejects duplicate ${c.idField}`, () => {
-            const scn = {
-                ...VALID_SCENARIO.scenario,
-                [c.field]: [{ [c.idField]: 'X1' }, { [c.idField]: 'X1' }],
-            };
-            const r = validateScenario({ ...VALID_SCENARIO, scenario: scn });
-            expect(r.errors.some(e => e.code === c.errorCode)).toBe(true);
-        });
-    }
-    it('accepts minimal scenario (id+name+status only)', () => {
-        const r = validateScenario({
-            notation: 'scenarios',
-            scenario: { id: 'S1', name: 'Minimal', status: 'Draft' },
-        });
-        expect(r.valid).toBe(true);
-    });
-    it('accepts scenario with all reference lists empty', () => {
-        const scn = {
-            ...VALID_SCENARIO.scenario,
-            factors_view: [],
-            goals: [],
-            capabilities: [],
-            activities: [],
-            products: [],
-            processes: [],
-            applications: [],
-        };
-        const r = validateScenario({ ...VALID_SCENARIO, scenario: scn });
-        expect(r.valid).toBe(true);
-    });
-    // Pre-release blocker regression (orchestrator review 2026-05-21).
-    it('[blocker] tolerates a null element in factors_view[] without throwing', () => {
-        const scn = { ...VALID_SCENARIO.scenario, factors_view: [null] };
-        const r = validateScenario({ ...VALID_SCENARIO, scenario: scn });
-        expect(r.valid).toBe(false);
-        expect(r.errors.some(e => e.code === 'SCN-005')).toBe(true);
-    });
-    it('[blocker] tolerates a null element in goals[] without throwing', () => {
-        const scn = { ...VALID_SCENARIO.scenario, goals: [null] };
-        const r = validateScenario({ ...VALID_SCENARIO, scenario: scn });
-        expect(r.valid).toBe(false);
-        expect(r.errors.some(e => e.code === 'SCN-007')).toBe(true);
-    });
-    it('[blocker] tolerates a string element in applications[] without throwing', () => {
-        const scn = { ...VALID_SCENARIO.scenario, applications: ['x'] };
-        const r = validateScenario({ ...VALID_SCENARIO, scenario: scn });
-        expect(r.valid).toBe(false);
-        expect(r.errors.some(e => e.code === 'SCN-012')).toBe(true);
-    });
-});
-describe('scenarios 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/scenarios/${file}`, () => {
-            const text = fs.readFileSync(path.join(EXAMPLES_DIR, file), 'utf8');
-            const parsed = yaml.load(text);
-            const r = validateScenario(parsed);
-            expect(r.errors).toEqual([]);
-            expect(r.valid).toBe(true);
-        });
-    }
-});

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

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

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

@@ -1,88 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { validateStakeholder } from '../validate.js';
-function valid() {
-    return {
-        notation: 'stakeholder',
-        id: 'STAKEHOLDER-DPA-1',
-        name: 'Data Protection Authority',
-        type: 'external',
-        actor: 'ACTOR-DPA-1',
-        concern: 'Lawful processing and timely erasure of personal data.',
-        interest: 'high',
-        influence: 'high',
-        description: 'External oversight stakeholder.',
-        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,
-    };
-}
-const codes = (input, opts) => validateStakeholder(input, opts).errors.map(e => e.code);
-describe('validateStakeholder — positive', () => {
-    it('accepts a well-formed external stakeholder', () => {
-        const r = validateStakeholder(valid());
-        expect(r.valid, JSON.stringify(r.errors)).toBe(true);
-    });
-    it('accepts a minimal internal stakeholder with no optional profile fields', () => {
-        const s = valid();
-        s.id = 'STAKEHOLDER-OPS-1';
-        s.name = 'Operations';
-        s.type = 'internal';
-        s.actor = 'ACTOR-OPS-1';
-        delete s.concern;
-        delete s.interest;
-        delete s.influence;
-        delete s.description;
-        expect(validateStakeholder(s).valid).toBe(true);
-    });
-    it('accepts when the catalog resolves the actor', () => {
-        const catalog = { typeOf: id => (id === 'ACTOR-DPA-1' ? 'ACTOR' : undefined) };
-        expect(validateStakeholder(valid(), { catalog }).valid).toBe(true);
-    });
-});
-describe('validateStakeholder — STAKE-001 (shape / id grammar / levels)', () => {
-    it('flags a missing required envelope field', () => {
-        const s = valid();
-        delete s.name;
-        expect(codes(s)).toContain('STAKE-001');
-    });
-    it('flags an id that violates the grammar', () => {
-        expect(codes({ ...valid(), id: 'STAKEHOLDER-DPA-001' })).toContain('STAKE-001');
-        expect(codes({ ...valid(), id: 'STAKE-1' })).toContain('STAKE-001');
-    });
-    it('flags a wrong notation tag', () => {
-        expect(codes({ ...valid(), notation: 'stakeholders' })).toContain('STAKE-001');
-    });
-    it('flags an interest / influence value outside {high, medium, low}', () => {
-        expect(codes({ ...valid(), interest: 'critical' })).toContain('STAKE-001');
-        expect(codes({ ...valid(), influence: 'none' })).toContain('STAKE-001');
-    });
-    it('rejects a non-object', () => {
-        expect(codes(null)).toEqual(['STAKE-001']);
-    });
-});
-describe('validateStakeholder — STAKE-002 (actor binding)', () => {
-    it('flags a missing actor', () => {
-        const s = valid();
-        delete s.actor;
-        expect(codes(s)).toContain('STAKE-002');
-    });
-    it('flags an actor of the wrong TYPE', () => {
-        expect(codes({ ...valid(), actor: 'ROLE-OPS-1' })).toContain('STAKE-002');
-    });
-    it('flags an actor that does not resolve when a catalog is supplied', () => {
-        const catalog = { typeOf: () => undefined };
-        expect(codes(valid(), { catalog })).toContain('STAKE-002');
-    });
-    it('flags an actor whose catalog TYPE is not ACTOR', () => {
-        const catalog = { typeOf: () => 'ROLE' };
-        expect(codes(valid(), { catalog })).toContain('STAKE-002');
-    });
-});
-describe('validateStakeholder — STAKE-003 (type enum)', () => {
-    it('flags a type outside {internal, external}', () => {
-        expect(codes({ ...valid(), type: 'partner' })).toContain('STAKE-003');
-    });
-});

package/dist/target-state/__tests__/validate.test.d.ts

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

package/dist/target-state/__tests__/validate.test.js

@@ -1,78 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { validateTargetState } from '../validate.js';
-function valid() {
-    return {
-        notation: 'target-state',
-        id: 'TARGET_STATE-EU-LIVE-1',
-        name: 'EU operations live — three markets, localised CRM and payments',
-        description: 'The structural end-state.',
-        capabilities: ['CAPABILITY-V1', 'CAPABILITY-V1.2', 'CAPABILITY-V2'],
-        processes: ['PROCESS-CUST-ONBOARD-1', 'PROCESS-ORD-FULFILL-1'],
-        applications: ['APPLICATION-CRM-1', 'APPLICATION-OMS-1'],
-        zone: 'canon',
-        admitted_at: '2026-05-31',
-        admitted_by: 'v.korobeinikov',
-        gate_checks: { uniqueness: 'pass', consistency: 'pass', completeness: 'pass' },
-        valid_from: '2026-05-31',
-        valid_to: null,
-    };
-}
-const codes = (input, opts) => validateTargetState(input, opts).errors.map(e => e.code);
-describe('validateTargetState — positive', () => {
-    it('accepts a well-formed target state', () => {
-        const r = validateTargetState(valid());
-        expect(r.valid, JSON.stringify(r.errors)).toBe(true);
-    });
-    it('accepts a target state with empty composition lists', () => {
-        const t = valid();
-        delete t.capabilities;
-        delete t.processes;
-        delete t.applications;
-        expect(validateTargetState(t).valid).toBe(true);
-    });
-    it('accepts CAPABILITY V/H ids without integer terminal', () => {
-        const t = valid();
-        t.capabilities = ['CAPABILITY-V1.2.3', 'CAPABILITY-H1.2'];
-        expect(validateTargetState(t).valid).toBe(true);
-    });
-});
-describe('validateTargetState — TSTATE-001 (shape / id grammar)', () => {
-    it('flags a missing required envelope field', () => {
-        const t = valid();
-        delete t.name;
-        expect(codes(t)).toContain('TSTATE-001');
-    });
-    it('flags an id that violates the grammar', () => {
-        expect(codes({ ...valid(), id: 'TARGET_STATE-EU-LIVE-001' })).toContain('TSTATE-001');
-        expect(codes({ ...valid(), id: 'TS-1' })).toContain('TSTATE-001');
-    });
-    it('flags a wrong notation tag', () => {
-        expect(codes({ ...valid(), notation: 'target_state' })).toContain('TSTATE-001');
-    });
-    it('flags a non-array composition list', () => {
-        expect(codes({ ...valid(), capabilities: 'CAPABILITY-V1' })).toContain('TSTATE-001');
-    });
-    it('rejects a non-object', () => {
-        expect(codes(null)).toEqual(['TSTATE-001']);
-    });
-});
-describe('validateTargetState — TSTATE-002 (composition TYPEs)', () => {
-    it('flags a capabilities entry of the wrong TYPE', () => {
-        expect(codes({ ...valid(), capabilities: ['PROCESS-X-1'] })).toContain('TSTATE-002');
-    });
-    it('flags a processes entry of the wrong TYPE', () => {
-        expect(codes({ ...valid(), processes: ['APPLICATION-X-1'] })).toContain('TSTATE-002');
-    });
-    it('flags an applications entry of the wrong TYPE', () => {
-        expect(codes({ ...valid(), applications: ['CAPABILITY-V1'] })).toContain('TSTATE-002');
-    });
-    it('flags an unresolved id when a catalog is supplied', () => {
-        const catalog = { typeOf: () => undefined };
-        expect(codes(valid(), { catalog })).toContain('TSTATE-002');
-    });
-});
-describe('validateTargetState — TSTATE-003 (forbidden inline goals)', () => {
-    it('flags an inline goals field', () => {
-        expect(codes({ ...valid(), goals: ['GOAL-EU-1'] })).toContain('TSTATE-003');
-    });
-});

package/dist/technology-service/__tests__/validate.test.d.ts

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

package/dist/technology-service/__tests__/validate.test.js

@@ -1,121 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { validateTechnologyService } from '../validate.js';
-function valid() {
-    return {
-        notation: 'technology-service',
-        id: 'TECHNOLOGY_SERVICE-KAFKA-1',
-        name: 'Kafka Event Bus',
-        type: 'messaging',
-        description: 'Managed Kafka cluster for async event streaming.',
-        node: 'NODE-KAFKA-HOST-1',
-        endpoint: 'kafka.internal:9092',
-        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) => validateTechnologyService(input).errors.map(e => e.code);
-describe('validateTechnologyService — positive', () => {
-    it('accepts a well-formed messaging service with all optional fields', () => {
-        const r = validateTechnologyService(valid());
-        expect(r.valid, JSON.stringify(r.errors)).toBe(true);
-    });
-    it('accepts a storage service with no optional fields', () => {
-        const a = valid();
-        a.id = 'TECHNOLOGY_SERVICE-S3-1';
-        a.name = 'Object Storage';
-        a.type = 'storage';
-        delete a.description;
-        delete a.node;
-        delete a.endpoint;
-        expect(validateTechnologyService(a).valid).toBe(true);
-    });
-    it('accepts all five type values', () => {
-        for (const t of ['messaging', 'storage', 'api_gateway', 'database', 'compute']) {
-            expect(validateTechnologyService({ ...valid(), type: t }).valid).toBe(true);
-        }
-    });
-    it('accepts valid_to as a date string', () => {
-        expect(validateTechnologyService({ ...valid(), valid_to: '2026-12-31' }).valid).toBe(true);
-    });
-    it('accepts absent node without error', () => {
-        const a = valid();
-        delete a.node;
-        expect(validateTechnologyService(a).valid).toBe(true);
-    });
-});
-describe('validateTechnologyService — TSVC-001 (shape / id grammar)', () => {
-    it('flags a non-object input', () => {
-        expect(codes(null)).toEqual(['TSVC-001']);
-    });
-    it('flags an id that violates the grammar', () => {
-        expect(codes({ ...valid(), id: 'TECHNOLOGY_SERVICE-001' })).toContain('TSVC-001');
-        expect(codes({ ...valid(), id: 'TSVC-1' })).toContain('TSVC-001');
-        expect(codes({ ...valid(), id: 'technology-service-kafka-1' })).toContain('TSVC-001');
-    });
-    it('flags a wrong notation tag', () => {
-        expect(codes({ ...valid(), notation: 'technology_service' })).toContain('TSVC-001');
-        expect(codes({ ...valid(), notation: 'service' })).toContain('TSVC-001');
-    });
-    it('flags a non-canon zone', () => {
-        expect(codes({ ...valid(), zone: 'sandbox' })).toContain('TSVC-001');
-    });
-    it('flags a missing zone', () => {
-        const a = valid();
-        delete a.zone;
-        expect(codes(a)).toContain('TSVC-001');
-    });
-    it('flags a missing name', () => {
-        const a = valid();
-        delete a.name;
-        expect(codes(a)).toContain('TSVC-001');
-    });
-    it('flags a missing valid_to key', () => {
-        const a = valid();
-        delete a.valid_to;
-        expect(codes(a)).toContain('TSVC-001');
-    });
-    it('flags missing gate_checks', () => {
-        const a = valid();
-        delete a.gate_checks;
-        expect(codes(a)).toContain('TSVC-001');
-    });
-    it('flags a missing type', () => {
-        const a = valid();
-        delete a.type;
-        expect(codes(a)).toContain('TSVC-001');
-    });
-});
-describe('validateTechnologyService — TSVC-002 (type enum)', () => {
-    it('flags a type outside the allowed enum', () => {
-        expect(codes({ ...valid(), type: 'queue' })).toContain('TSVC-002');
-        expect(codes({ ...valid(), type: 'event_streaming' })).toContain('TSVC-002');
-        expect(codes({ ...valid(), type: 'cache' })).toContain('TSVC-002');
-    });
-    it('does not flag a missing type with TSVC-002 (TSVC-001 fires instead)', () => {
-        const a = valid();
-        delete a.type;
-        expect(codes(a)).not.toContain('TSVC-002');
-        expect(codes(a)).toContain('TSVC-001');
-    });
-});
-describe('validateTechnologyService — TSVC-003 (node grammar)', () => {
-    it('flags a node reference that is not a NODE-… id', () => {
-        expect(codes({ ...valid(), node: 'ACTOR-OPS-1' })).toContain('TSVC-003');
-        expect(codes({ ...valid(), node: 'not-an-id' })).toContain('TSVC-003');
-        expect(codes({ ...valid(), node: 'NODE-001' })).toContain('TSVC-003');
-    });
-    it('accepts a null or absent node without error', () => {
-        expect(codes({ ...valid(), node: undefined })).not.toContain('TSVC-003');
-        const a = valid();
-        delete a.node;
-        expect(codes(a)).not.toContain('TSVC-003');
-    });
-    it('accepts a well-formed NODE-… id', () => {
-        expect(codes({ ...valid(), node: 'NODE-KAFKA-HOST-1' })).not.toContain('TSVC-003');
-        expect(codes({ ...valid(), node: 'NODE-K8S-CLUSTER-1' })).not.toContain('TSVC-003');
-    });
-});

package/dist/theme/__tests__/tokens.test.d.ts

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