@transitrix/diagrams 1.8.6 → 1.8.8

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

@@ -1,24 +0,0 @@
-// Conformance test for the shipped REQUIREMENT worked examples — the
-// acme_corp canon files mirrored under `tests/fixtures/notation-corpus/requirement/`. Pins the
-// success signal of vkgeorgia/strategy#84 Phase 1: the library consumes the
-// canonical example files without error.
-
-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 { validateRequirement } from '../validate.js';
-
-const dir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../../../../tests/fixtures/notation-corpus/requirement');
-const load = (f: string): unknown => yaml.load(readFileSync(path.join(dir, f), 'utf-8'));
-
-describe('requirement worked examples (acme_corp)', () => {
-  for (const f of ['REQUIREMENT-DATA-ERASURE-1.yaml', 'REQUIREMENT-AUDIT-LOG-RETENTION-1.yaml']) {
-    it(`validates ${f} without error`, () => {
-      const v = validateRequirement(load(f));
-      expect(v.valid, JSON.stringify(v.errors)).toBe(true);
-      expect(v.errors).toHaveLength(0);
-    });
-  }
-});

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

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

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

@@ -1,105 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { validateStakeholder } from '../validate.js';
-import type { CanonCatalog } from '../../typed-id.js';
-
-function valid(): Record<string, unknown> {
-  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: unknown, opts?: Parameters<typeof validateStakeholder>[1]): string[] =>
-  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: CanonCatalog = { 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: CanonCatalog = { typeOf: () => undefined };
-    expect(codes(valid(), { catalog })).toContain('STAKE-002');
-  });
-
-  it('flags an actor whose catalog TYPE is not ACTOR', () => {
-    const catalog: CanonCatalog = { 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/src/target-state/__tests__/validate.test.ts

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

@@ -1,143 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { validateTechnologyService } from '../validate.js';
-
-function valid(): Record<string, unknown> {
-  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: unknown): string[] =>
-  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');
-  });
-});