@transitrix/diagrams 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023-2026 Valerii Korobeinikov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,47 @@
+# @transitrix/diagrams
+
+Shared rendering, validation, and pure mutations for Transitrix custom diagram
+formats (BPMN, Goals, FGCA, Capability Map, Process Blueprint, and the rest of
+the Transitrix notation family).
+
+This package is the runtime library used by the **Transitrix Studio** VS Code
+extension, the `@transitrix/cli`, and downstream tools that need to read,
+validate, or render Transitrix diagrams.
+
+## Install
+
+```bash
+npm install @transitrix/diagrams
+```
+
+`react` and `reactflow` are declared as peer dependencies — install them in the
+host application if you use the React renderers; pure validation / mutation
+APIs do not require them.
+
+## What's inside
+
+The package re-exports the per-notation modules under one entry point:
+
+- Activities, Activity Card, Applications, Assertion, Blocks, Capability Map,
+  Compliance + Compliance Matrix, Confidence, FGCA, Goals, Process Blueprint,
+  Process Map, Products, Requirement, Scenarios.
+- Shared primitives: `geometry`, `typed-id`, `validation-types`,
+  `yaml-normalize`, `SCHEMA_VERSION`, theme tokens, repository-level validators.
+
+See the source layout under [`src/`](./src) and the per-module `index.ts`
+exports for the public surface.
+
+## Versioning
+
+`@transitrix/diagrams` ships on its own version line, independent of the
+Transitrix Studio extension version. The first published release is `1.0.0`.
+
+## License
+
+MIT — see [`LICENSE`](./LICENSE).
+
+## Links
+
+- Monorepo: <https://github.com/transitrix/transitrix-studio>
+- Issues: <https://github.com/transitrix/transitrix-studio/issues>
+- Methodology spec: <https://github.com/transitrix/methodology>

package/dist/__tests__/edge-path.test.d.ts

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

package/dist/__tests__/edge-path.test.js

@@ -0,0 +1,39 @@
+import { describe, it, expect } from 'vitest';
+import { horizontalCubicEdgePath, EDGE_MIN_HANDLE } from '../edge-path.js';
+describe('horizontalCubicEdgePath', () => {
+    // A short horizontal edge: |dx|=40 < EDGE_MIN_HANDLE*2, |dy|=0, so the
+    // base handle is the floor (64).
+    const sx = 0, sy = 0, tx = 40, ty = 0;
+    it('curvature 1 uses the floor handle (historical appearance)', () => {
+        const d = horizontalCubicEdgePath(sx, sy, tx, ty, 1);
+        // handle = max(64, 20, 0) = 64
+        expect(d).toBe(`M0,0 C${EDGE_MIN_HANDLE},0 ${40 - EDGE_MIN_HANDLE},0 40,0`);
+    });
+    it('default curvature equals explicit curvature 1', () => {
+        expect(horizontalCubicEdgePath(sx, sy, tx, ty)).toBe(horizontalCubicEdgePath(sx, sy, tx, ty, 1));
+    });
+    it('curvature 0 collapses control points onto the endpoints (straight line)', () => {
+        const d = horizontalCubicEdgePath(sx, sy, tx, ty, 0);
+        expect(d).toBe('M0,0 C0,0 40,0 40,0');
+    });
+    it('changing curvature changes the path output (AC#6)', () => {
+        const a = horizontalCubicEdgePath(sx, sy, tx, ty, 1);
+        const b = horizontalCubicEdgePath(sx, sy, tx, ty, 2);
+        expect(b).not.toBe(a);
+    });
+    it('larger curvature pushes the control handles further out', () => {
+        const handleOf = (curv) => {
+            // First control point x is `sx + handle`; parse it back out.
+            const m = horizontalCubicEdgePath(0, 0, 40, 0, curv).match(/^M0,0 C(-?\d+(?:\.\d+)?),0/);
+            return Number(m[1]);
+        };
+        expect(handleOf(2)).toBeGreaterThan(handleOf(1));
+        expect(handleOf(0.5)).toBeLessThan(handleOf(1));
+        expect(handleOf(2)).toBe(2 * EDGE_MIN_HANDLE);
+    });
+    it('handle scales with the vertical span for stacked nodes', () => {
+        // |dy|=200 ⇒ base handle = max(64, 0, 160) = 160; ×1 = 160.
+        const d = horizontalCubicEdgePath(0, 0, 0, 200, 1);
+        expect(d).toBe('M0,0 C160,0 -160,200 0,200');
+    });
+});

package/dist/__tests__/scope.test.d.ts

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

package/dist/__tests__/scope.test.js

@@ -0,0 +1,23 @@
+import { describe, it, expect } from 'vitest';
+import { checkScopeRoot, SCOPE_MISSING_ROOT_CODE } from '../scope.js';
+describe('checkScopeRoot', () => {
+    it('returns null for non-root scopes', () => {
+        expect(checkScopeRoot({ mode: 'all' }, [1, 2])).toBeNull();
+        expect(checkScopeRoot({ mode: 'level', maxLevel: 1 }, [1, 2])).toBeNull();
+    });
+    it('returns null when the root id is present (numeric ids compared as strings)', () => {
+        const scope = { mode: 'root', rootGoalId: '2' };
+        expect(checkScopeRoot(scope, [1, 2, 3])).toBeNull();
+    });
+    it('returns a SCOPE-001 warning when the root id is absent', () => {
+        const scope = { mode: 'root', rootGoalId: '99' };
+        const w = checkScopeRoot(scope, [1, 2, 3]);
+        expect(w).not.toBeNull();
+        expect(w.code).toBe(SCOPE_MISSING_ROOT_CODE);
+        expect(w.message).toContain('99');
+    });
+    it('handles string goal ids', () => {
+        expect(checkScopeRoot({ mode: 'root', rootGoalId: 'g1' }, ['g1', 'g2'])).toBeNull();
+        expect(checkScopeRoot({ mode: 'root', rootGoalId: 'gX' }, ['g1', 'g2'])).not.toBeNull();
+    });
+});

package/dist/__tests__/yaml-normalize.test.d.ts

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

package/dist/__tests__/yaml-normalize.test.js

@@ -0,0 +1,148 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import yaml from 'js-yaml';
+import { coerceDatesToIsoStrings } from '../yaml-normalize.js';
+import { validateActivities } from '../activities/index.js';
+describe('coerceDatesToIsoStrings', () => {
+    it('replaces top-level Date with ISO YYYY-MM-DD string', () => {
+        const out = coerceDatesToIsoStrings(new Date(Date.UTC(2026, 5, 1))); // 2026-06-01 UTC
+        expect(out).toBe('2026-06-01');
+    });
+    it('replaces Date values inside nested arrays of objects', () => {
+        const input = {
+            activities: [
+                { id: 'A-001', start_date: new Date(Date.UTC(2026, 5, 1)), end_date: new Date(Date.UTC(2026, 5, 5)) },
+                { id: 'A-002', start_date: '2026-06-06' },
+            ],
+        };
+        coerceDatesToIsoStrings(input);
+        expect(input.activities[0].start_date).toBe('2026-06-01');
+        expect(input.activities[0].end_date).toBe('2026-06-05');
+        expect(input.activities[1].start_date).toBe('2026-06-06');
+    });
+    it('walks objects recursively', () => {
+        const input = {
+            project: { start_date: new Date(Date.UTC(2026, 0, 15)) },
+        };
+        coerceDatesToIsoStrings(input);
+        expect(input.project.start_date).toBe('2026-01-15');
+    });
+    it('leaves non-Date values untouched', () => {
+        const input = {
+            notation: 'activities',
+            activities: [{ id: 'A-001', duration: 3, start_date: '2026-06-01' }],
+        };
+        const out = coerceDatesToIsoStrings(input);
+        expect(out).toBe(input);
+        expect(input.activities[0].start_date).toBe('2026-06-01');
+        expect(input.activities[0].duration).toBe(3);
+    });
+    it('handles null, undefined, and primitive scalars', () => {
+        expect(coerceDatesToIsoStrings(null)).toBe(null);
+        expect(coerceDatesToIsoStrings(undefined)).toBe(undefined);
+        expect(coerceDatesToIsoStrings('hello')).toBe('hello');
+        expect(coerceDatesToIsoStrings(42)).toBe(42);
+        expect(coerceDatesToIsoStrings(true)).toBe(true);
+    });
+    it('handles arrays that contain bare Date elements', () => {
+        const arr = [new Date(Date.UTC(2026, 5, 1)), 'x', { d: new Date(Date.UTC(2026, 5, 2)) }];
+        coerceDatesToIsoStrings(arr);
+        expect(arr[0]).toBe('2026-06-01');
+        expect(arr[1]).toBe('x');
+        expect(arr[2].d).toBe('2026-06-02');
+    });
+});
+describe('coerceDatesToIsoStrings — js-yaml integration', () => {
+    it('quoted ISO dates are preserved untouched', () => {
+        const text = [
+            'notation: activities',
+            'activities:',
+            '  - id: "A-001"',
+            '    name: "Quoted dates"',
+            '    duration: 3',
+            '    start_date: "2026-06-01"',
+            '    end_date: "2026-06-03"',
+            '',
+        ].join('\n');
+        const parsed = yaml.load(text);
+        coerceDatesToIsoStrings(parsed);
+        expect(parsed.activities[0].start_date).toBe('2026-06-01');
+        expect(parsed.activities[0].end_date).toBe('2026-06-03');
+        const v = validateActivities(parsed);
+        expect(v.valid).toBe(true);
+    });
+    it('bare ISO dates are coerced to ISO strings and pass validation', () => {
+        const text = [
+            'notation: activities',
+            'activities:',
+            '  - id: "A-001"',
+            '    name: "Bare dates"',
+            '    duration: 3',
+            '    start_date: 2026-06-01',
+            '    end_date: 2026-06-03',
+            '',
+        ].join('\n');
+        const parsed = yaml.load(text);
+        // Without coercion, js-yaml returns Date instances and the validator
+        // would emit ACT-008 because typeof !== 'string'. Sanity-check that
+        // assumption before normalisation.
+        expect(parsed.activities[0].start_date).toBeInstanceOf(Date);
+        coerceDatesToIsoStrings(parsed);
+        expect(parsed.activities[0].start_date).toBe('2026-06-01');
+        expect(parsed.activities[0].end_date).toBe('2026-06-03');
+        const v = validateActivities(parsed);
+        expect(v.valid).toBe(true);
+    });
+});
+// The issue calls out the timezone trap: a Date built from a bare ISO
+// date is midnight UTC, but if we used `getFullYear / getMonth / getDate`
+// instead of the UTC variants, a non-UTC process timezone would shift the
+// day. Pin a non-UTC TZ for this block so the regression bites if anyone
+// later swaps to local-time accessors.
+describe('coerceDatesToIsoStrings — non-UTC timezone', () => {
+    const originalTz = process.env.TZ;
+    beforeAll(() => {
+        // Pacific/Auckland is UTC+12/+13 — the most aggressive eastward shift
+        // available without DST gymnastics. If local-time accessors are used,
+        // `2026-06-01` parsed as midnight UTC reads back as `2026-06-01 12:00
+        // local`, which is still the right day — so use a westward TZ for the
+        // real test below. Auckland is here as a sanity case.
+        process.env.TZ = 'Pacific/Auckland';
+    });
+    afterAll(() => {
+        if (originalTz === undefined) {
+            delete process.env.TZ;
+        }
+        else {
+            process.env.TZ = originalTz;
+        }
+    });
+    it('does not drift the day forward in an eastward timezone', () => {
+        const text = 'd: 2026-06-01\n';
+        const parsed = yaml.load(text);
+        coerceDatesToIsoStrings(parsed);
+        expect(parsed.d).toBe('2026-06-01');
+    });
+});
+describe('coerceDatesToIsoStrings — westward (negative offset) timezone', () => {
+    const originalTz = process.env.TZ;
+    beforeAll(() => {
+        // Pacific/Honolulu is UTC-10, no DST. Midnight UTC `2026-06-01` reads
+        // back as `2026-05-31 14:00 local`. Local-time accessors would yield
+        // `2026-05-31` — wrong by one day. UTC accessors yield `2026-06-01`.
+        process.env.TZ = 'Pacific/Honolulu';
+    });
+    afterAll(() => {
+        if (originalTz === undefined) {
+            delete process.env.TZ;
+        }
+        else {
+            process.env.TZ = originalTz;
+        }
+    });
+    it('does not drift the day backward in a westward timezone', () => {
+        const text = 'd: 2026-06-01\n';
+        const parsed = yaml.load(text);
+        coerceDatesToIsoStrings(parsed);
+        expect(parsed.d).toBe('2026-06-01');
+    });
+});

package/dist/activities/__tests__/cpm.test.d.ts

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

package/dist/activities/__tests__/cpm.test.js

@@ -0,0 +1,146 @@
+import { describe, it, expect } from 'vitest';
+import { computeCpm } from '../cpm.js';
+// PMBoK textbook example (5-activity network):
+//   A(5) → B(8) → D(7)
+//   A(5) → C(3) → D(7)
+//   D(7) → E(4)
+// Critical path: A→B→D→E = 5+8+7+4 = 24
+// A: ES=0, EF=5, LS=0, LF=5, slack=0 (critical)
+// B: ES=5, EF=13, LS=5, LF=13, slack=0 (critical)
+// C: ES=5, EF=8, LS=10, LF=13, slack=5
+// D: ES=13, EF=20, LS=13, LF=20, slack=0 (critical)
+// E: ES=20, EF=24, LS=20, LF=24, slack=0 (critical)
+const pmBokActivities = [
+    { id: 'A', name: 'A', duration: 5 },
+    { id: 'B', name: 'B', duration: 8, predecessors: ['A'] },
+    { id: 'C', name: 'C', duration: 3, predecessors: ['A'] },
+    { id: 'D', name: 'D', duration: 7, predecessors: ['B', 'C'] },
+    { id: 'E', name: 'E', duration: 4, predecessors: ['D'] },
+];
+describe('computeCpm — PMBoK textbook example', () => {
+    const result = computeCpm(pmBokActivities);
+    it('computes ES for each activity', () => {
+        expect(result.get('A').es).toBe(0);
+        expect(result.get('B').es).toBe(5);
+        expect(result.get('C').es).toBe(5);
+        expect(result.get('D').es).toBe(13);
+        expect(result.get('E').es).toBe(20);
+    });
+    it('computes EF for each activity', () => {
+        expect(result.get('A').ef).toBe(5);
+        expect(result.get('B').ef).toBe(13);
+        expect(result.get('C').ef).toBe(8);
+        expect(result.get('D').ef).toBe(20);
+        expect(result.get('E').ef).toBe(24);
+    });
+    it('computes LS for each activity', () => {
+        expect(result.get('A').ls).toBe(0);
+        expect(result.get('B').ls).toBe(5);
+        expect(result.get('C').ls).toBe(10);
+        expect(result.get('D').ls).toBe(13);
+        expect(result.get('E').ls).toBe(20);
+    });
+    it('computes LF for each activity', () => {
+        expect(result.get('A').lf).toBe(5);
+        expect(result.get('B').lf).toBe(13);
+        expect(result.get('C').lf).toBe(13);
+        expect(result.get('D').lf).toBe(20);
+        expect(result.get('E').lf).toBe(24);
+    });
+    it('computes slack', () => {
+        expect(result.get('A').slack).toBe(0);
+        expect(result.get('B').slack).toBe(0);
+        expect(result.get('C').slack).toBe(5);
+        expect(result.get('D').slack).toBe(0);
+        expect(result.get('E').slack).toBe(0);
+    });
+    it('marks critical path activities', () => {
+        expect(result.get('A').isCritical).toBe(true);
+        expect(result.get('B').isCritical).toBe(true);
+        expect(result.get('C').isCritical).toBe(false);
+        expect(result.get('D').isCritical).toBe(true);
+        expect(result.get('E').isCritical).toBe(true);
+    });
+});
+describe('computeCpm — edge cases', () => {
+    it('returns empty map for empty input', () => {
+        const result = computeCpm([]);
+        expect(result.size).toBe(0);
+    });
+    it('single node with no predecessors: ES=0, EF=duration, slack=0', () => {
+        const result = computeCpm([{ id: 'A', name: 'A', duration: 5 }]);
+        expect(result.get('A').es).toBe(0);
+        expect(result.get('A').ef).toBe(5);
+        expect(result.get('A').slack).toBe(0);
+        expect(result.get('A').isCritical).toBe(true);
+    });
+    it('activity with no duration treated as zero-duration', () => {
+        const result = computeCpm([{ id: 'A', name: 'Milestone' }]);
+        expect(result.get('A').ef).toBe(0);
+    });
+    it('linear chain A(3)→B(5)→C(2): total=10, all critical', () => {
+        const activities = [
+            { id: 'A', name: 'A', duration: 3 },
+            { id: 'B', name: 'B', duration: 5, predecessors: ['A'] },
+            { id: 'C', name: 'C', duration: 2, predecessors: ['B'] },
+        ];
+        const result = computeCpm(activities);
+        expect(result.get('A').ef).toBe(3);
+        expect(result.get('B').ef).toBe(8);
+        expect(result.get('C').ef).toBe(10);
+        expect(result.get('A').isCritical).toBe(true);
+        expect(result.get('B').isCritical).toBe(true);
+        expect(result.get('C').isCritical).toBe(true);
+    });
+    it('parallel paths: longer path is critical, shorter has positive slack', () => {
+        // A(1) → C(10)
+        // B(5) → C(10)
+        // merge at D(2): predecessors [C]
+        // path via A: 1+10+2=13; path via B: 5+10+2=17 → critical
+        const activities = [
+            { id: 'A', name: 'A', duration: 1 },
+            { id: 'B', name: 'B', duration: 5 },
+            { id: 'C', name: 'C', duration: 10, predecessors: ['A', 'B'] },
+            { id: 'D', name: 'D', duration: 2, predecessors: ['C'] },
+        ];
+        const result = computeCpm(activities);
+        // C.es = max(EF[A], EF[B]) = max(1,5) = 5
+        expect(result.get('C').es).toBe(5);
+        expect(result.get('A').isCritical).toBe(false);
+        expect(result.get('B').isCritical).toBe(true);
+        expect(result.get('C').isCritical).toBe(true);
+        expect(result.get('D').isCritical).toBe(true);
+        expect(result.get('A').slack).toBe(4);
+        expect(result.get('B').slack).toBe(0);
+    });
+});
+describe('computeCpm — cycle defence', () => {
+    // Pre-release should-fix: Kahn's topo-order silently omits cyclic nodes.
+    // The validator's ACT-006 is the authoritative cycle error, but
+    // layoutActivities is reachable without validation, so computeCpm must
+    // still produce an entry for every activity (filled with neutral values
+    // for omitted cyclic ones) — otherwise consumers see `undefined` and
+    // bars render without CPM data.
+    it('emits entries for every activity on a 2-node mutual cycle', () => {
+        const result = computeCpm([
+            { id: 'A', name: 'A', duration: 3, predecessors: ['B'] },
+            { id: 'B', name: 'B', duration: 2, predecessors: ['A'] },
+        ]);
+        expect(result.size).toBe(2);
+        expect(result.get('A')).toMatchObject({ es: 0, ef: 0, slack: 0, isCritical: false });
+        expect(result.get('B')).toMatchObject({ es: 0, ef: 0, slack: 0, isCritical: false });
+    });
+    it('keeps real CPM data for the acyclic prefix when a cycle exists downstream', () => {
+        // A → B is acyclic; C ↔ D is a mutual cycle disconnected from A/B.
+        const result = computeCpm([
+            { id: 'A', name: 'A', duration: 5 },
+            { id: 'B', name: 'B', duration: 3, predecessors: ['A'] },
+            { id: 'C', name: 'C', duration: 2, predecessors: ['D'] },
+            { id: 'D', name: 'D', duration: 2, predecessors: ['C'] },
+        ]);
+        expect(result.get('A')?.ef).toBe(5);
+        expect(result.get('B')?.ef).toBe(8);
+        expect(result.get('C')).toMatchObject({ es: 0, ef: 0, isCritical: false });
+        expect(result.get('D')).toMatchObject({ es: 0, ef: 0, isCritical: false });
+    });
+});

package/dist/activities/__tests__/gantt.test.d.ts

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

package/dist/activities/__tests__/gantt.test.js

@@ -0,0 +1,224 @@
+import { describe, it, expect } from 'vitest';
+import { computeGanttLayout, isGanttUnavailable } from '../gantt.js';
+function assertRenders(result) {
+    if (isGanttUnavailable(result)) {
+        throw new Error(`Expected Gantt to render but got unavailable: ${result.reason}`);
+    }
+    return result;
+}
+describe('computeGanttLayout — mode detection', () => {
+    it('returns unavailable when neither project.start_date nor pinned dates exist', () => {
+        const doc = {
+            notation: 'activities',
+            activities: [
+                { id: 'A', name: 'A', duration: 3 },
+                { id: 'B', name: 'B', duration: 2, predecessors: ['A'] },
+            ],
+        };
+        const r = computeGanttLayout(doc);
+        expect(isGanttUnavailable(r)).toBe(true);
+    });
+    it('selects computed mode when project.start_date + every leaf has duration', () => {
+        const doc = {
+            notation: 'activities',
+            project: { start_date: '2026-06-01' },
+            activities: [
+                { id: 'A', name: 'A', duration: 3 },
+                { id: 'B', name: 'B', duration: 2, predecessors: ['A'] },
+            ],
+        };
+        const r = assertRenders(computeGanttLayout(doc));
+        expect(r.mode).toBe('computed');
+    });
+    it('selects pinned mode when every leaf has start_date + end_date', () => {
+        const doc = {
+            notation: 'activities',
+            activities: [
+                { id: 'A', name: 'A', start_date: '2026-06-01', end_date: '2026-06-03' },
+                { id: 'B', name: 'B', start_date: '2026-06-04', end_date: '2026-06-06' },
+            ],
+        };
+        const r = assertRenders(computeGanttLayout(doc));
+        expect(r.mode).toBe('pinned');
+    });
+    it('unavailable when only some leaves have pinned dates and no project.start_date', () => {
+        const doc = {
+            notation: 'activities',
+            activities: [
+                { id: 'A', name: 'A', start_date: '2026-06-01', end_date: '2026-06-03' },
+                { id: 'B', name: 'B', duration: 3 }, // no pinned dates, no project.start_date
+            ],
+        };
+        const r = computeGanttLayout(doc);
+        expect(isGanttUnavailable(r)).toBe(true);
+    });
+    it('unavailable when the document has no activities', () => {
+        const r = computeGanttLayout({ notation: 'activities', activities: [] });
+        expect(isGanttUnavailable(r)).toBe(true);
+    });
+});
+describe('computeGanttLayout — computed mode (CPM + calendar projection)', () => {
+    const doc = {
+        notation: 'activities',
+        project: { start_date: '2026-06-01' }, // Monday
+        activities: [
+            { id: 'A', name: 'A', duration: 3 },
+            { id: 'B', name: 'B', duration: 2, predecessors: ['A'] },
+        ],
+    };
+    it('places the first bar at project.start_date and spans its duration', () => {
+        const r = assertRenders(computeGanttLayout(doc));
+        const a = r.bars.find(b => b.id === 'A');
+        expect(a.startDate).toBe('2026-06-01');
+        // 7-day default calendar: day 0 = start_date, last day = 2026-06-03 (start + 2)
+        expect(a.endDate).toBe('2026-06-03');
+    });
+    it('places successor bars after their predecessor finishes', () => {
+        const r = assertRenders(computeGanttLayout(doc));
+        const b = r.bars.find(b => b.id === 'B');
+        // B has ES = EF(A) = 3 working days, so it starts at 2026-06-04
+        expect(b.startDate).toBe('2026-06-04');
+        expect(b.endDate).toBe('2026-06-05');
+    });
+    it('marks critical-path bars on a linear chain', () => {
+        const r = assertRenders(computeGanttLayout(doc));
+        const a = r.bars.find(b => b.id === 'A');
+        const bbar = r.bars.find(b => b.id === 'B');
+        expect(a.isCritical).toBe(true);
+        expect(bbar.isCritical).toBe(true);
+    });
+    it('emits predecessor → successor links with critical flag carried over', () => {
+        const r = assertRenders(computeGanttLayout(doc));
+        expect(r.links).toHaveLength(1);
+        expect(r.links[0]).toMatchObject({ sourceId: 'A', targetId: 'B', isCritical: true });
+    });
+    it('timeline bounds span min(start) to max(end)', () => {
+        const r = assertRenders(computeGanttLayout(doc));
+        expect(r.timelineStart).toBe('2026-06-01');
+        expect(r.timelineEnd).toBe('2026-06-05');
+    });
+});
+describe('computeGanttLayout — calendar (working_days, holidays)', () => {
+    it('skips weekend days when working_days excludes them', () => {
+        // 2026-06-01 is a Monday. Duration 7 days, only Mon–Fri working.
+        // Day 0 = Mon 06-01, days 1..4 = Tue-Fri, day 5 = next Mon 06-08, day 6 = Tue 06-09.
+        const doc = {
+            notation: 'activities',
+            project: {
+                start_date: '2026-06-01',
+                calendar: { working_days: ['mon', 'tue', 'wed', 'thu', 'fri'] },
+            },
+            activities: [{ id: 'A', name: 'A', duration: 7 }],
+        };
+        const r = assertRenders(computeGanttLayout(doc));
+        const a = r.bars.find(b => b.id === 'A');
+        expect(a.startDate).toBe('2026-06-01');
+        expect(a.endDate).toBe('2026-06-09');
+    });
+    it('skips dates listed under holidays', () => {
+        // 7-day week, but 2026-06-02 is a holiday → 3-day activity ends on 2026-06-04.
+        const doc = {
+            notation: 'activities',
+            project: {
+                start_date: '2026-06-01',
+                calendar: { holidays: ['2026-06-02'] },
+            },
+            activities: [{ id: 'A', name: 'A', duration: 3 }],
+        };
+        const r = assertRenders(computeGanttLayout(doc));
+        const a = r.bars.find(b => b.id === 'A');
+        expect(a.startDate).toBe('2026-06-01');
+        expect(a.endDate).toBe('2026-06-04');
+    });
+});
+describe('computeGanttLayout — milestones', () => {
+    it('renders zero-duration leaves as milestones with start == end', () => {
+        const doc = {
+            notation: 'activities',
+            project: { start_date: '2026-06-01' },
+            activities: [
+                { id: 'A', name: 'A', duration: 3 },
+                { id: 'M', name: 'Launch', duration: 0, predecessors: ['A'] },
+            ],
+        };
+        const r = assertRenders(computeGanttLayout(doc));
+        const m = r.bars.find(b => b.id === 'M');
+        expect(m.kind).toBe('milestone');
+        expect(m.startDate).toBe(m.endDate);
+        // M lives at the working day immediately after A finishes (ES = 3).
+        expect(m.startDate).toBe('2026-06-04');
+    });
+    it('pinned mode treats start==end activities as milestones', () => {
+        const doc = {
+            notation: 'activities',
+            activities: [
+                { id: 'M', name: 'Launch', duration: 0, start_date: '2026-06-15', end_date: '2026-06-15' },
+            ],
+        };
+        const r = assertRenders(computeGanttLayout(doc));
+        const m = r.bars.find(b => b.id === 'M');
+        expect(m.kind).toBe('milestone');
+    });
+});
+describe('computeGanttLayout — phases (parent activities)', () => {
+    it('rolls up phase span from children', () => {
+        const doc = {
+            notation: 'activities',
+            project: { start_date: '2026-06-01' },
+            activities: [
+                { id: 'PHASE-1', name: 'Design' },
+                { id: 'A', name: 'A', duration: 3, parent: 'PHASE-1' },
+                { id: 'B', name: 'B', duration: 5, parent: 'PHASE-1', predecessors: ['A'] },
+            ],
+        };
+        const r = assertRenders(computeGanttLayout(doc));
+        const phase = r.bars.find(b => b.id === 'PHASE-1');
+        expect(phase.kind).toBe('phase');
+        expect(phase.startDate).toBe('2026-06-01'); // earliest child = A start
+        expect(phase.endDate).toBe('2026-06-08'); // latest child = B end (ES=3 + 5 days)
+    });
+    it('marks the phase critical if any child is on the critical path', () => {
+        const doc = {
+            notation: 'activities',
+            project: { start_date: '2026-06-01' },
+            activities: [
+                { id: 'PHASE-1', name: 'Design' },
+                { id: 'A', name: 'A', duration: 3, parent: 'PHASE-1' },
+            ],
+        };
+        const r = assertRenders(computeGanttLayout(doc));
+        const phase = r.bars.find(b => b.id === 'PHASE-1');
+        expect(phase.isCritical).toBe(true);
+    });
+});
+describe('computeGanttLayout — pinned mode', () => {
+    it('places bars at pinned dates without computing CPM', () => {
+        const doc = {
+            notation: 'activities',
+            activities: [
+                { id: 'A', name: 'A', start_date: '2026-08-01', end_date: '2026-08-10' },
+                { id: 'B', name: 'B', start_date: '2026-08-12', end_date: '2026-08-20', predecessors: ['A'] },
+            ],
+        };
+        const r = assertRenders(computeGanttLayout(doc));
+        expect(r.mode).toBe('pinned');
+        expect(r.bars.find(b => b.id === 'A')?.startDate).toBe('2026-08-01');
+        expect(r.bars.find(b => b.id === 'A')?.endDate).toBe('2026-08-10');
+        expect(r.bars.find(b => b.id === 'B')?.startDate).toBe('2026-08-12');
+        // Pinned mode does not compute CPM → critical flag is false.
+        expect(r.bars.find(b => b.id === 'A')?.isCritical).toBe(false);
+    });
+    it('still emits links between pinned leaves', () => {
+        const doc = {
+            notation: 'activities',
+            activities: [
+                { id: 'A', name: 'A', start_date: '2026-08-01', end_date: '2026-08-10' },
+                { id: 'B', name: 'B', start_date: '2026-08-12', end_date: '2026-08-20', predecessors: ['A'] },
+            ],
+        };
+        const r = assertRenders(computeGanttLayout(doc));
+        expect(r.links).toHaveLength(1);
+        expect(r.links[0].sourceId).toBe('A');
+        expect(r.links[0].targetId).toBe('B');
+    });
+});