@transitrix/diagrams 1.8.6 → 1.8.8

package/dist/goals/__tests__/layout.test.js

@@ -1,153 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { layoutGoalTree } from '../layout.js';
-const TREE = {
-    goal_types: [
-        { name: 'Strategy', level: 0 },
-        { name: 'Business Goal', level: 1 },
-        { name: 'Project', level: 2 },
-    ],
-    goals: [
-        { id: 1, name: 'North Star', type: 'Strategy', level: 0, parent_id: 0 },
-        { id: 2, name: 'EU Expansion', type: 'Business Goal', level: 1, parent_id: 1 },
-        { id: 3, name: 'Berlin Office', type: 'Project', level: 2, parent_id: 2 },
-        { id: 4, name: 'London Office', type: 'Project', level: 2, parent_id: 2 },
-    ],
-};
-describe('layoutGoalTree', () => {
-    it('returns nodes for all goals', () => {
-        const layout = layoutGoalTree(TREE);
-        expect(layout.nodes).toHaveLength(4);
-    });
-    it('returns edges for parent-child pairs', () => {
-        const layout = layoutGoalTree(TREE);
-        expect(layout.edges).toHaveLength(3); // 1→2, 2→3, 2→4
-    });
-    it('levels map to increasing x positions', () => {
-        const layout = layoutGoalTree(TREE);
-        const byId = new Map(layout.nodes.map(n => [n.id, n]));
-        expect(byId.get(1).x).toBeLessThan(byId.get(2).x);
-        expect(byId.get(2).x).toBeLessThan(byId.get(3).x);
-    });
-    it('siblings at same level have different y positions', () => {
-        const layout = layoutGoalTree(TREE);
-        const byId = new Map(layout.nodes.map(n => [n.id, n]));
-        expect(byId.get(3).y).not.toBe(byId.get(4).y);
-    });
-    it('returns non-zero bounds for non-empty tree', () => {
-        const layout = layoutGoalTree(TREE);
-        expect(layout.bounds.width).toBeGreaterThan(0);
-        expect(layout.bounds.height).toBeGreaterThan(0);
-    });
-    it('returns empty layout for empty goals', () => {
-        const layout = layoutGoalTree({ goal_types: [], goals: [] });
-        expect(layout.nodes).toHaveLength(0);
-        expect(layout.edges).toHaveLength(0);
-    });
-    it('nodes have default 250×80 size', () => {
-        const layout = layoutGoalTree(TREE);
-        expect(layout.nodes[0].width).toBe(250);
-        expect(layout.nodes[0].height).toBe(80);
-    });
-    it('respects custom nodeWidth/nodeHeight', () => {
-        const layout = layoutGoalTree(TREE, { nodeWidth: 200, nodeHeight: 60 });
-        expect(layout.nodes[0].width).toBe(200);
-        expect(layout.nodes[0].height).toBe(60);
-    });
-    // vkgeorgia/strategy#75 — configurable spacing. The preview maps
-    // horizontalGap → rankSep and verticalGap → nodeSep.
-    it('larger rankSep widens the column step', () => {
-        const tight = layoutGoalTree(TREE, { rankSep: 80 });
-        const wide = layoutGoalTree(TREE, { rankSep: 200 });
-        const stepOf = (l) => {
-            const byId = new Map(l.nodes.map(n => [n.id, n]));
-            return byId.get(2).x - byId.get(1).x;
-        };
-        expect(stepOf(wide)).toBeGreaterThan(stepOf(tight));
-    });
-    it('larger nodeSep increases the gap between stacked siblings', () => {
-        const gapOf = (sep) => {
-            const l = layoutGoalTree(TREE, { nodeSep: sep });
-            const byId = new Map(l.nodes.map(n => [n.id, n]));
-            return Math.abs(byId.get(4).y - byId.get(3).y);
-        };
-        expect(gapOf(120)).toBeGreaterThan(gapOf(24));
-    });
-    it('each node carries original goal data', () => {
-        const layout = layoutGoalTree(TREE);
-        const node1 = layout.nodes.find(n => n.id === 1);
-        expect(node1.data.name).toBe('North Star');
-    });
-    it('viewDepth hides nodes beyond depth', () => {
-        const layout = layoutGoalTree(TREE, { viewDepth: 1 });
-        // Level 2 nodes (id 3, 4) should be hidden
-        expect(layout.nodes.every(n => n.data.level <= 1)).toBe(true);
-    });
-    it('compresses non-contiguous levels into adjacent columns (no phantom empty columns)', () => {
-        // Legacy / non-canonical input: goal_types skip levels 1 and 3, so
-        // goals sit at levels 0, 2, 4. Column x must advance by exactly one
-        // step per used level, not per absolute level value — otherwise the
-        // skipped levels open empty columns and double the horizontal spacing.
-        const gapped = {
-            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 },
-                { id: 2, name: 'Mid', type: 'Strategic Goal', level: 2, parent_id: 1 },
-                { id: 3, name: 'Leaf', type: 'Project Goal', level: 4, parent_id: 2 },
-            ],
-        };
-        const layout = layoutGoalTree(gapped);
-        const byId = new Map(layout.nodes.map(n => [n.id, n]));
-        const step = byId.get(2).x - byId.get(1).x;
-        // Root→Mid and Mid→Leaf must use the same single-column step despite
-        // the level numbers jumping by 2 each time.
-        expect(byId.get(3).x - byId.get(2).x).toBe(step);
-        // And that step is one node width + one rank separator (250 + 80).
-        expect(step).toBe(250 + 80);
-    });
-    // Pre-release blocker regression (orchestrator review 2026-05-21).
-    it('[blocker] does not stack-overflow on a self-parent cycle', () => {
-        const cyclic = {
-            goal_types: [{ name: 'X', level: 0 }],
-            goals: [{ id: 1, name: 'self-parent', type: 'X', level: 0, parent_id: 1 }],
-        };
-        // Without a visited-set inside placeSubtree, this recurses forever.
-        expect(() => layoutGoalTree(cyclic)).not.toThrow();
-    });
-    it('[blocker] does not stack-overflow on a 2-node mutual cycle', () => {
-        const cyclic = {
-            goal_types: [{ name: 'X', level: 0 }, { name: 'Y', level: 1 }],
-            goals: [
-                { id: 1, name: 'A', type: 'X', level: 0, parent_id: 2 },
-                { id: 2, name: 'B', type: 'Y', level: 1, parent_id: 1 },
-            ],
-        };
-        expect(() => layoutGoalTree(cyclic)).not.toThrow();
-    });
-    // vkgeorgia/strategy#77 — scope filtering.
-    describe('scope', () => {
-        const ids = (l) => l.nodes.map(n => n.id).sort((a, b) => a - b);
-        it("mode 'all' matches the baseline", () => {
-            expect(ids(layoutGoalTree(TREE, { scope: { mode: 'all' } }))).toEqual(ids(layoutGoalTree(TREE)));
-        });
-        it("mode 'level' trims goals strictly above the cap", () => {
-            // TREE: id1 level0, id2 level1, id3/id4 level2.
-            const layout = layoutGoalTree(TREE, { scope: { mode: 'level', maxLevel: 1 } });
-            expect(ids(layout)).toEqual([1, 2]);
-            expect(layout.nodes.every(n => n.data.level <= 1)).toBe(true);
-        });
-        it("mode 'root' keeps the chosen goal and its descendants", () => {
-            // root id2 → itself + children id3, id4.
-            const layout = layoutGoalTree(TREE, { scope: { mode: 'root', rootGoalId: '2' } });
-            expect(ids(layout)).toEqual([2, 3, 4]);
-        });
-        it("mode 'root' returns an empty layout when the root is absent", () => {
-            const layout = layoutGoalTree(TREE, { scope: { mode: 'root', rootGoalId: '999' } });
-            expect(layout.nodes).toHaveLength(0);
-            expect(layout.edges).toHaveLength(0);
-        });
-    });
-});

package/dist/goals/__tests__/mutations.test.d.ts

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

package/dist/goals/__tests__/mutations.test.js

@@ -1,134 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { reparent, addChild, deleteWithDescendants, moveToBacklog, restoreFromBacklog } from '../mutations.js';
-const TREE = {
-    goal_types: [
-        { name: 'Strategy', level: 0 },
-        { name: 'Business Goal', level: 1 },
-        { name: 'Project', level: 2 },
-    ],
-    goals: [
-        { id: 1, name: 'North Star', type: 'Strategy', level: 0, parent_id: 0 },
-        { id: 2, name: 'EU Expansion', type: 'Business Goal', level: 1, parent_id: 1 },
-        { id: 3, name: 'Berlin Office', type: 'Project', level: 2, parent_id: 2 },
-    ],
-};
-describe('reparent', () => {
-    it('moves a goal to a new parent', () => {
-        const r = reparent(TREE, 3, 1);
-        expect(r.ok).toBe(true);
-        const moved = r.result.goals.find(g => g.id === 3);
-        expect(moved.parent_id).toBe(1);
-        expect(moved.level).toBe(1);
-    });
-    it('refuses to create a cycle', () => {
-        const r = reparent(TREE, 1, 3);
-        expect(r.ok).toBe(false);
-        expect(r.error?.code).toBe('MUTATION_REFUSED');
-    });
-    it('refuses self-reparent', () => {
-        expect(reparent(TREE, 1, 1).ok).toBe(false);
-    });
-    it('refuses reparent that would exceed max level', () => {
-        const r = reparent(TREE, 1, 3); // would make level 3 which exceeds max 2
-        expect(r.ok).toBe(false);
-    });
-    it('preserves immutability — original tree unchanged', () => {
-        reparent(TREE, 3, 1);
-        expect(TREE.goals.find(g => g.id === 3).parent_id).toBe(2);
-    });
-});
-describe('addChild', () => {
-    it('adds a child with auto-assigned id and level', () => {
-        const r = addChild(TREE, 2, { name: 'Warsaw Office', type: 'Project', level: 2, parent_id: 2 });
-        expect(r.ok).toBe(true);
-        const newGoal = r.result.goals.find(g => g.name === 'Warsaw Office');
-        expect(newGoal.id).toBeGreaterThan(3);
-        expect(newGoal.parent_id).toBe(2);
-        expect(newGoal.level).toBe(2);
-    });
-    it('adds root-level child when parentId is 0', () => {
-        const r = addChild(TREE, 0, { name: 'Second Strategy', type: 'Strategy', level: 0, parent_id: 0 });
-        expect(r.ok).toBe(true);
-        expect(r.result.goals.find(g => g.name === 'Second Strategy').level).toBe(0);
-    });
-    it('refuses when parent not found', () => {
-        const r = addChild(TREE, 99, { name: 'X', type: 'Project', level: 2, parent_id: 99 });
-        expect(r.ok).toBe(false);
-    });
-    it('preserves immutability', () => {
-        const before = TREE.goals.length;
-        addChild(TREE, 1, { name: 'New', type: 'Business Goal', level: 1, parent_id: 1 });
-        expect(TREE.goals.length).toBe(before);
-    });
-});
-describe('deleteWithDescendants', () => {
-    it('deletes goal and all descendants', () => {
-        const r = deleteWithDescendants(TREE, 2);
-        expect(r.ok).toBe(true);
-        const ids = r.result.goals.map(g => g.id);
-        expect(ids).not.toContain(2);
-        expect(ids).not.toContain(3);
-        expect(ids).toContain(1);
-    });
-    it('refuses when goal not found', () => {
-        expect(deleteWithDescendants(TREE, 99).ok).toBe(false);
-    });
-    it('preserves immutability', () => {
-        deleteWithDescendants(TREE, 2);
-        expect(TREE.goals.length).toBe(3);
-    });
-});
-describe('moveToBacklog', () => {
-    it('sets parent_id to 0', () => {
-        const r = moveToBacklog(TREE, 3);
-        expect(r.ok).toBe(true);
-        expect(r.result.goals.find(g => g.id === 3).parent_id).toBe(0);
-    });
-});
-describe('restoreFromBacklog', () => {
-    it('reparents the goal to the new parent', () => {
-        const backlogged = moveToBacklog(TREE, 3).result;
-        const r = restoreFromBacklog(backlogged, 3, 1);
-        expect(r.ok).toBe(true);
-        expect(r.result.goals.find(g => g.id === 3).parent_id).toBe(1);
-    });
-});
-describe('reparent — descendant type relabeling and level cap', () => {
-    const DEEP = {
-        goal_types: [
-            { name: 'Strategy', level: 0 },
-            { name: 'Business Goal', level: 1 },
-            { name: 'Project', level: 2 },
-            { name: 'Task', level: 3 },
-        ],
-        goals: [
-            { id: 1, name: 'Root', type: 'Strategy', level: 0, parent_id: 0 },
-            { id: 2, name: 'BG1', type: 'Business Goal', level: 1, parent_id: 1 },
-            { id: 3, name: 'Proj1', type: 'Project', level: 2, parent_id: 2 },
-            { id: 4, name: 'Task1', type: 'Task', level: 3, parent_id: 3 },
-        ],
-    };
-    it('relabels descendant types via getTypeForLevel when reparenting shifts levels', () => {
-        // Move Proj1 (id=3, level=2) directly under Root (id=1, level=0); delta = -1
-        // Task1 (child of Proj1, level=3): new level = 2, type should be 'Project'
-        const r = reparent(DEEP, 3, 1);
-        expect(r.ok).toBe(true);
-        const proj = r.result.goals.find(g => g.id === 3);
-        const task = r.result.goals.find(g => g.id === 4);
-        expect(proj.level).toBe(1);
-        expect(proj.type).toBe('Business Goal');
-        expect(task.level).toBe(2);
-        expect(task.type).toBe('Project');
-    });
-    it('caps descendant level at maxLevel and refuses when that violates GOALS-012', () => {
-        // Move Root (id=1, level=0) under Root2 (id=5, level=0); delta = +1
-        // BG1: 1→2, Proj1: 2→3 (maxLevel), Task1: 3→4, capped at 3
-        // Task1 (capped level=3) under Proj1 (level=3) violates GOALS-012 → refused
-        const tree = {
-            ...DEEP,
-            goals: [...DEEP.goals, { id: 5, name: 'Root2', type: 'Strategy', level: 0, parent_id: 0 }],
-        };
-        const r = reparent(tree, 1, 5);
-        expect(r.ok).toBe(false);
-    });
-});

package/dist/goals/__tests__/parse-canonical.test.d.ts

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

package/dist/goals/__tests__/parse-canonical.test.js

@@ -1,131 +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/dist/goals/__tests__/validate.test.d.ts

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

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

@@ -1,183 +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/dist/integration/__tests__/validate.test.d.ts

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