@transitrix/diagrams 1.8.6 → 1.8.8

package/src/goals/__tests__/parse-canonical.test.ts

@@ -1,147 +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 { parseCanonicalGoals } from '../parse-canonical.js';
-
-const VALID = {
-  notation: 'goals',
-  spec_version: '0.1',
-  id: 'GOALS-SAMPLE-1',
-  name: 'Sample goals tree',
-  goal_types: [
-    { name: 'Strategy', level: 0 },
-    { name: 'Project', level: 1 },
-  ],
-  goals: [
-    { id: 'GOAL-1', name: 'Root', type: 'Strategy', level: 0 },
-    { id: 'GOAL-2', name: 'Child', type: 'Project', level: 1, parent: 'GOAL-1' },
-  ],
-};
-
-describe('parseCanonicalGoals', () => {
-  it('accepts a valid canonical document', () => {
-    const r = parseCanonicalGoals(VALID);
-    expect(r.valid).toBe(true);
-    expect(r.errors).toEqual([]);
-    expect(r.parsed?.goals).toHaveLength(2);
-  });
-
-  it('GOALS-001: rejects non-object input', () => {
-    expect(parseCanonicalGoals(null).errors[0].code).toBe('GOALS-001');
-  });
-
-  it('GOALS-001: rejects wrong notation', () => {
-    const r = parseCanonicalGoals({ ...VALID, notation: 'fga' });
-    expect(r.errors.some((e) => e.code === 'GOALS-001')).toBe(true);
-  });
-
-  it('GOALS-002: rejects malformed doc id', () => {
-    const r = parseCanonicalGoals({ ...VALID, id: 'goals-1' });
-    expect(r.errors.some((e) => e.code === 'GOALS-002')).toBe(true);
-  });
-
-  it('GOALS-003: rejects missing name', () => {
-    const { name: _, ...rest } = VALID;
-    const r = parseCanonicalGoals(rest);
-    expect(r.errors.some((e) => e.code === 'GOALS-003')).toBe(true);
-  });
-
-  it('GOALS-004: rejects empty goal_types', () => {
-    const r = parseCanonicalGoals({ ...VALID, goal_types: [] });
-    expect(r.errors.some((e) => e.code === 'GOALS-004')).toBe(true);
-  });
-
-  it('GOALS-007: rejects malformed goal id', () => {
-    const r = parseCanonicalGoals({
-      ...VALID,
-      goals: [{ id: 'goal-1', name: 'A', type: 'Strategy', level: 0 }],
-    });
-    expect(r.errors.some((e) => e.code === 'GOALS-007')).toBe(true);
-  });
-
-  it('GOALS-007: rejects duplicate goal ids', () => {
-    const r = parseCanonicalGoals({
-      ...VALID,
-      goals: [
-        { id: 'GOAL-1', name: 'A', type: 'Strategy', level: 0 },
-        { id: 'GOAL-1', name: 'B', type: 'Strategy', level: 0 },
-      ],
-    });
-    expect(r.errors.some((e) => e.code === 'GOALS-007')).toBe(true);
-  });
-
-  it('GOALS-008: rejects goal.type not in goal_types', () => {
-    const r = parseCanonicalGoals({
-      ...VALID,
-      goals: [{ id: 'GOAL-1', name: 'A', type: 'Unknown', level: 0 }],
-    });
-    expect(r.errors.some((e) => e.code === 'GOALS-008')).toBe(true);
-  });
-
-  it('GOALS-008: rejects goal.level mismatched with goal_types', () => {
-    const r = parseCanonicalGoals({
-      ...VALID,
-      goals: [{ id: 'GOAL-1', name: 'A', type: 'Strategy', level: 5 }],
-    });
-    expect(r.errors.some((e) => e.code === 'GOALS-008')).toBe(true);
-  });
-
-  it('GOALS-009: warns on broken parent ref', () => {
-    const r = parseCanonicalGoals({
-      ...VALID,
-      goals: [
-        { id: 'GOAL-1', name: 'Root', type: 'Strategy', level: 0 },
-        { id: 'GOAL-2', name: 'Orphan', type: 'Project', level: 1, parent: 'GOAL-99' },
-      ],
-    });
-    expect(r.valid).toBe(true);
-    expect(r.warnings.some((w) => w.code === 'GOALS-009')).toBe(true);
-  });
-
-  it('GOALS-010: detects parent-chain cycle', () => {
-    const r = parseCanonicalGoals({
-      ...VALID,
-      goals: [
-        { id: 'GOAL-1', name: 'A', type: 'Strategy', level: 0, parent: 'GOAL-2' },
-        { id: 'GOAL-2', name: 'B', type: 'Strategy', level: 0, parent: 'GOAL-1' },
-      ],
-    });
-    expect(r.errors.some((e) => e.code === 'GOALS-010')).toBe(true);
-  });
-
-  it('GOALS-011: warns when non-root goal has no parent', () => {
-    const r = parseCanonicalGoals({
-      ...VALID,
-      goals: [{ id: 'GOAL-1', name: 'A', type: 'Project', level: 1 }],
-    });
-    expect(r.valid).toBe(true);
-    expect(r.warnings.some((w) => w.code === 'GOALS-011')).toBe(true);
-  });
-
-  it('maps canonical IDs to internal numeric ids; parent_id is the parent\'s mapped id', () => {
-    const r = parseCanonicalGoals(VALID);
-    expect(r.parsed?.goals[0].id).toBe(1);
-    expect(r.parsed?.goals[0].canonical_id).toBe('GOAL-1');
-    expect(r.parsed?.goals[0].parent_id).toBe(0);
-    expect(r.parsed?.goals[1].id).toBe(2);
-    expect(r.parsed?.goals[1].canonical_id).toBe('GOAL-2');
-    expect(r.parsed?.goals[1].parent_id).toBe(1);
-  });
-});
-
-describe('parseCanonicalGoals — example file regression', () => {
-  const EXAMPLES_DIR = path.resolve(process.cwd(), '..', '..', 'tests', 'fixtures', 'notation-corpus', 'goals');
-  const files = fs.existsSync(EXAMPLES_DIR)
-    ? fs.readdirSync(EXAMPLES_DIR).filter((f) => f.endsWith('.transitrix.yaml'))
-    : [];
-  for (const file of files) {
-    it(`accepts tests/fixtures/notation-corpus/goals/${file}`, () => {
-      const text = fs.readFileSync(path.join(EXAMPLES_DIR, file), 'utf8');
-      const parsedYaml = yaml.load(text);
-      const r = parseCanonicalGoals(parsedYaml);
-      expect(r.errors).toEqual([]);
-      expect(r.valid).toBe(true);
-    });
-  }
-});

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

@@ -1,202 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { validateGoalTree } from '../validate.js';
-
-const VALID_TREE = {
-  goal_types: [
-    { name: 'Strategy', level: 0 },
-    { name: 'Business Goal', level: 1 },
-    { name: 'Project', level: 2 },
-  ],
-  goals: [
-    { id: 1, name: 'Triple revenue', type: 'Strategy', level: 0, parent_id: 0 },
-    { id: 2, name: 'Launch EU', type: 'Business Goal', level: 1, parent_id: 1 },
-    { id: 3, name: 'Open Berlin office', type: 'Project', level: 2, parent_id: 2 },
-  ],
-};
-
-describe('validateGoalTree', () => {
-  it('passes on valid input', () => {
-    const r = validateGoalTree(VALID_TREE);
-    expect(r.valid).toBe(true);
-    expect(r.errors).toHaveLength(0);
-  });
-
-  it('SCHEMA_INVALID: rejects non-object', () => {
-    expect(validateGoalTree(null).valid).toBe(false);
-    expect(validateGoalTree('string').errors[0].code).toBe('SCHEMA_INVALID');
-  });
-
-  it('SCHEMA_INVALID: rejects missing goals array', () => {
-    const r = validateGoalTree({ goal_types: [] });
-    expect(r.errors.some(e => e.code === 'SCHEMA_INVALID')).toBe(true);
-  });
-
-  it('DUPLICATE_ID: detects duplicate goal ids', () => {
-    const tree = {
-      ...VALID_TREE,
-      goals: [
-        { id: 1, name: 'A', type: 'Strategy', level: 0, parent_id: 0 },
-        { id: 1, name: 'B', type: 'Strategy', level: 0, parent_id: 0 },
-      ],
-    };
-    const r = validateGoalTree(tree);
-    expect(r.errors.some(e => e.code === 'DUPLICATE_ID')).toBe(true);
-  });
-
-  it('EMPTY_NAME: detects empty name', () => {
-    const tree = {
-      ...VALID_TREE,
-      goals: [{ id: 1, name: '', type: 'Strategy', level: 0, parent_id: 0 }],
-    };
-    expect(validateGoalTree(tree).errors.some(e => e.code === 'EMPTY_NAME')).toBe(true);
-  });
-
-  it('MAX_LEVEL_EXCEEDED: detects level overflow', () => {
-    const tree = {
-      goal_types: [{ name: 'Strategy', level: 0 }],
-      goals: [{ id: 1, name: 'Too deep', type: 'Strategy', level: 5, parent_id: 0 }],
-    };
-    expect(validateGoalTree(tree).errors.some(e => e.code === 'MAX_LEVEL_EXCEEDED')).toBe(true);
-  });
-
-  it('TYPE_LEVEL_MISMATCH: warns when type level disagrees', () => {
-    const tree = {
-      ...VALID_TREE,
-      goals: [{ id: 1, name: 'Mismatch', type: 'Project', level: 0, parent_id: 0 }],
-    };
-    const r = validateGoalTree(tree);
-    expect(r.warnings.some(w => w.code === 'TYPE_LEVEL_MISMATCH')).toBe(true);
-  });
-
-  it('BROKEN_PARENT_REF: warns on missing parent (renders to backlog)', () => {
-    const tree = {
-      ...VALID_TREE,
-      goals: [
-        { id: 1, name: 'Root', type: 'Strategy', level: 0, parent_id: 0 },
-        { id: 2, name: 'Orphan', type: 'Business Goal', level: 1, parent_id: 99 },
-      ],
-    };
-    const r = validateGoalTree(tree);
-    expect(r.valid).toBe(true);
-    expect(r.warnings.some(w => w.code === 'BROKEN_PARENT_REF')).toBe(true);
-  });
-
-  it('CYCLE_DETECTED: detects direct cycle', () => {
-    const tree = {
-      goal_types: [{ name: 'S', level: 0 }, { name: 'B', level: 1 }],
-      goals: [
-        { id: 1, name: 'A', type: 'S', level: 0, parent_id: 2 },
-        { id: 2, name: 'B', type: 'B', level: 1, parent_id: 1 },
-      ],
-    };
-    expect(validateGoalTree(tree).errors.some(e => e.code === 'CYCLE_DETECTED')).toBe(true);
-  });
-
-  // Pre-release blocker regression tests (orchestrator review 2026-05-21).
-  it('[blocker] tolerates a null element in goals[] without throwing', () => {
-    const tree = { ...VALID_TREE, goals: [null] };
-    const r = validateGoalTree(tree);
-    expect(r.valid).toBe(false);
-    expect(r.errors.some(e => e.code === 'SCHEMA_INVALID')).toBe(true);
-  });
-
-  it('[blocker] tolerates a non-object element in goals[] without throwing', () => {
-    const tree = { ...VALID_TREE, goals: ['x'] };
-    const r = validateGoalTree(tree);
-    expect(r.valid).toBe(false);
-    expect(r.errors.some(e => e.code === 'SCHEMA_INVALID')).toBe(true);
-  });
-
-  it('[blocker] rejects non-numeric level (does not silently slip a string compare)', () => {
-    const tree = {
-      ...VALID_TREE,
-      goals: [{ id: 1, name: 'A', type: 'Strategy', level: '5', parent_id: 0 }],
-    };
-    const r = validateGoalTree(tree);
-    expect(r.valid).toBe(false);
-    expect(r.errors.some(e => e.code === 'SCHEMA_INVALID' && /level/.test(e.message))).toBe(true);
-  });
-
-  it('[blocker] rejects missing level (does not silently slip undefined > N)', () => {
-    const tree = {
-      ...VALID_TREE,
-      goals: [{ id: 1, name: 'A', type: 'Strategy', parent_id: 0 }],
-    };
-    const r = validateGoalTree(tree);
-    expect(r.valid).toBe(false);
-    expect(r.errors.some(e => e.code === 'SCHEMA_INVALID' && /level/.test(e.message))).toBe(true);
-  });
-
-  // GOALS-012 / GOALS-013 — N+1 parent/child hierarchy keyed on goal_types[]
-  // (decision in vkgeorgia/strategy#66; spec in transitrix/methodology
-  // notations/04-goals.md §6).
-  it('GOALS-012/013: accepts a contiguous goal_types + N+1 parent/child tree', () => {
-    const r = validateGoalTree(VALID_TREE);
-    expect(r.valid).toBe(true);
-    expect(r.errors.some(e => e.code === 'GOALS-012')).toBe(false);
-    expect(r.errors.some(e => e.code === 'GOALS-013')).toBe(false);
-  });
-
-  it('GOALS-013: rejects a gap in goal_types[].level', () => {
-    const tree = {
-      goal_types: [
-        { name: 'Strategy', level: 0 },
-        { name: 'Strategic Goal', level: 2 },
-        { name: 'Project Goal', level: 4 },
-      ],
-      goals: [
-        { id: 1, name: 'Root', type: 'Strategy', level: 0, parent_id: 0 },
-      ],
-    };
-    const r = validateGoalTree(tree);
-    expect(r.valid).toBe(false);
-    expect(r.errors.some(e => e.code === 'GOALS-013')).toBe(true);
-  });
-
-  it('GOALS-013: rejects goal_types[].level that does not start at 0', () => {
-    const tree = {
-      goal_types: [
-        { name: 'Mid', level: 1 },
-        { name: 'Deep', level: 2 },
-      ],
-      goals: [
-        { id: 1, name: 'A', type: 'Mid', level: 1, parent_id: 0 },
-      ],
-    };
-    const r = validateGoalTree(tree);
-    expect(r.valid).toBe(false);
-    expect(r.errors.some(e => e.code === 'GOALS-013')).toBe(true);
-  });
-
-  it('GOALS-012: rejects a parent–child level gap > 1', () => {
-    const tree = {
-      goal_types: [
-        { name: 'Strategy', level: 0 },
-        { name: 'Business Goal', level: 1 },
-        { name: 'Project', level: 2 },
-      ],
-      goals: [
-        { id: 1, name: 'Root', type: 'Strategy', level: 0, parent_id: 0 },
-        // Skips level 1: a Project (level 2) attached directly to a Strategy
-        // (level 0) violates N+1.
-        { id: 2, name: 'Sub', type: 'Project', level: 2, parent_id: 1 },
-      ],
-    };
-    const r = validateGoalTree(tree);
-    expect(r.valid).toBe(false);
-    expect(r.errors.some(e => e.code === 'GOALS-012')).toBe(true);
-  });
-
-  it('GOALS-012: does not fire when the parent reference is broken (BROKEN_PARENT_REF covers it)', () => {
-    const tree = {
-      ...VALID_TREE,
-      goals: [
-        { id: 1, name: 'Root', type: 'Strategy', level: 0, parent_id: 0 },
-        { id: 2, name: 'Orphan', type: 'Project', level: 2, parent_id: 99 },
-      ],
-    };
-    const r = validateGoalTree(tree);
-    expect(r.errors.some(e => e.code === 'GOALS-012')).toBe(false);
-    expect(r.warnings.some(w => w.code === 'BROKEN_PARENT_REF')).toBe(true);
-  });
-});

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

@@ -1,203 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { validateIntegration } from '../validate.js';
-
-function valid(): Record<string, unknown> {
-  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(): Record<string, unknown> {
-  return {
-    ...valid(),
-    id: 'INTEGRATION-OMS-EVENTS-1',
-    interface_semantics: true,
-    payload_class: 'domain_event',
-    sensitivity: 'internal',
-    directionality: 'producer',
-  };
-}
-
-const codes = (input: unknown): string[] =>
-  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/src/location/__tests__/validate.test.ts

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