@transitrix/diagrams 1.0.0

package/dist/element-envelope.js

@@ -0,0 +1,55 @@
+// Shared §3 envelope validator for standalone element primitives.
+//
+// Every standalone element file in the methodology canon carries the same
+// envelope: a fixed `notation` tag, a canonical `id` whose TYPE prefix matches
+// the element TYPE, `name`, an admission record (`zone`/`admitted_at`/
+// `admitted_by`/`gate_checks`), and a primitive lifecycle
+// (`valid_from`/`valid_to`). Per-TYPE fields (§7) sit between.
+//
+// Each per-TYPE validator delegates envelope checks here so the §3 rule lives
+// in one place; per-TYPE fields (subtype enums, cross-references) are checked
+// in the TYPE's own validator. The error `code` is parameterised so an
+// envelope failure surfaces under the TYPE's own code (e.g. `FACTOR-001`,
+// `CHANGE-001`), preserving per-TYPE attribution.
+import { isCanonicalIdOfType } from './typed-id.js';
+export function validateElementEnvelope(input, opts) {
+    const errors = [];
+    if (input === null || typeof input !== 'object' || Array.isArray(input)) {
+        errors.push({ code: opts.code, message: `${opts.idType} must be a YAML mapping.` });
+        return { record: null, errors };
+    }
+    const r = input;
+    if (r.notation !== opts.notation) {
+        errors.push({
+            code: opts.code,
+            message: `notation must be the fixed value "${opts.notation}".`,
+            path: 'notation',
+        });
+    }
+    if (!isCanonicalIdOfType(r.id, opts.idType)) {
+        errors.push({
+            code: opts.code,
+            message: `id "${String(r.id)}" must match ${opts.idType}-[<middle>-]<INTEGER>.`,
+            path: 'id',
+        });
+    }
+    for (const f of ['name', 'admitted_at', 'admitted_by', 'valid_from']) {
+        if (typeof r[f] !== 'string' || r[f].trim() === '') {
+            errors.push({ code: opts.code, message: `${f} is required.`, path: f });
+        }
+    }
+    if (r.zone !== 'canon') {
+        errors.push({ code: opts.code, message: 'zone is required and must be "canon".', path: 'zone' });
+    }
+    if (r.gate_checks === null || typeof r.gate_checks !== 'object' || Array.isArray(r.gate_checks)) {
+        errors.push({ code: opts.code, message: 'gate_checks is required and must be a mapping.', path: 'gate_checks' });
+    }
+    if (!('valid_to' in r) || !(typeof r.valid_to === 'string' || r.valid_to === null)) {
+        errors.push({
+            code: opts.code,
+            message: 'valid_to is required (an ISO date string or null).',
+            path: 'valid_to',
+        });
+    }
+    return { record: r, errors };
+}

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

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

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

@@ -0,0 +1,83 @@
+import { describe, it, expect } from 'vitest';
+import { validateFactor } from '../validate.js';
+function valid() {
+    return {
+        notation: 'factor',
+        id: 'FACTOR-EU-REG-1',
+        name: 'EU regulatory window for market entry',
+        type: 'external',
+        category: 'legal',
+        description: 'Standing external driver — the EU regulatory regime.',
+        references_constraint: ['CONSTRAINT-GDPR-RESIDENCY-1'],
+        zone: 'canon',
+        admitted_at: '2026-05-29',
+        admitted_by: 'v.korobeinikov',
+        gate_checks: { uniqueness: 'pass', consistency: 'pass', completeness: 'pass' },
+        valid_from: '2026-05-26',
+        valid_to: null,
+    };
+}
+const codes = (input) => validateFactor(input).errors.map(e => e.code);
+const warns = (input) => validateFactor(input).warnings.map(w => w.code);
+describe('validateFactor — positive', () => {
+    it('accepts the worked-example FACTOR-EU-REG-1', () => {
+        const r = validateFactor(valid());
+        expect(r.valid, JSON.stringify(r.errors)).toBe(true);
+        expect(r.errors).toHaveLength(0);
+    });
+    it('accepts a minimal factor (no type/category/references)', () => {
+        const r = valid();
+        delete r.type;
+        delete r.category;
+        delete r.references_constraint;
+        expect(validateFactor(r).valid).toBe(true);
+    });
+});
+describe('validateFactor — FACTOR-001 (envelope / shape)', () => {
+    it('flags a non-object', () => {
+        expect(codes(null)).toEqual(['FACTOR-001']);
+        expect(codes(['x'])).toEqual(['FACTOR-001']);
+    });
+    it('flags a wrong notation tag', () => {
+        expect(codes({ ...valid(), notation: 'driver' })).toContain('FACTOR-001');
+    });
+    it('flags an id with the wrong TYPE prefix', () => {
+        expect(codes({ ...valid(), id: 'GOAL-EU-1' })).toContain('FACTOR-001');
+    });
+    it('flags an id with a leading-zero terminal', () => {
+        expect(codes({ ...valid(), id: 'FACTOR-EU-REG-01' })).toContain('FACTOR-001');
+    });
+    it('flags a missing valid_to key (distinct from a null value)', () => {
+        const r = valid();
+        delete r.valid_to;
+        expect(codes(r)).toContain('FACTOR-001');
+        expect(validateFactor({ ...valid(), valid_to: null }).valid).toBe(true);
+    });
+    it('flags references_constraint entries that are not CONSTRAINT typed ids', () => {
+        expect(codes({ ...valid(), references_constraint: ['GOAL-EU-1'] })).toContain('FACTOR-001');
+        expect(codes({ ...valid(), references_constraint: 'CONSTRAINT-X-1' })).toContain('FACTOR-001');
+    });
+});
+describe('validateFactor — FACTOR-002 (type enum)', () => {
+    it('flags a type outside external/internal', () => {
+        expect(codes({ ...valid(), type: 'driver' })).toContain('FACTOR-002');
+    });
+    it('accepts each permitted type', () => {
+        for (const t of ['external', 'internal']) {
+            expect(codes({ ...valid(), type: t, category: undefined })).not.toContain('FACTOR-002');
+        }
+    });
+});
+describe('validateFactor — FACTOR-003 (PESTLE category)', () => {
+    it('flags a category outside the PESTLE classes', () => {
+        expect(codes({ ...valid(), category: 'cultural' })).toContain('FACTOR-003');
+    });
+    it('warns when category is set on an internal factor', () => {
+        expect(warns({ ...valid(), type: 'internal', category: 'economic' })).toContain('FACTOR-003');
+    });
+    it('accepts each permitted PESTLE class', () => {
+        for (const c of ['political', 'economic', 'social', 'technological', 'legal', 'environmental']) {
+            expect(codes({ ...valid(), category: c })).not.toContain('FACTOR-003');
+        }
+    });
+});

package/dist/factor/index.d.ts

@@ -0,0 +1,3 @@
+export type { Factor as FactorPrimitive, FactorType, FactorCategory } from './types.js';
+export { FACTOR_TYPES, FACTOR_CATEGORIES } from './types.js';
+export { validateFactor } from './validate.js';

package/dist/factor/index.js

@@ -0,0 +1,2 @@
+export { FACTOR_TYPES, FACTOR_CATEGORIES } from './types.js';
+export { validateFactor } from './validate.js';

package/dist/factor/types.d.ts

@@ -0,0 +1,23 @@
+import type { GateChecks } from '../requirement/types.js';
+/** Optional subtype — internal/external organisation force. */
+export type FactorType = 'external' | 'internal';
+export declare const FACTOR_TYPES: readonly ["external", "internal"];
+/** PESTLE sub-classification — external factors only. Open-ended in practice
+ *  but v1 fixes the six standard classes; an unknown category is flagged. */
+export type FactorCategory = 'political' | 'economic' | 'social' | 'technological' | 'legal' | 'environmental';
+export declare const FACTOR_CATEGORIES: readonly ["political", "economic", "social", "technological", "legal", "environmental"];
+export interface Factor {
+    notation: 'factor';
+    id: string;
+    name: string;
+    type?: FactorType;
+    category?: FactorCategory;
+    description?: string;
+    references_constraint?: string[];
+    zone: 'canon';
+    admitted_at: string;
+    admitted_by: string;
+    gate_checks: GateChecks;
+    valid_from: string;
+    valid_to: string | null;
+}

package/dist/factor/types.js

@@ -0,0 +1,6 @@
+// FACTOR — motivation-layer driver primitive.
+// Schema: methodology notations/ELEMENT_PRIMITIVES.md §7.1 + envelope §3.
+export const FACTOR_TYPES = ['external', 'internal'];
+export const FACTOR_CATEGORIES = [
+    'political', 'economic', 'social', 'technological', 'legal', 'environmental',
+];

package/dist/factor/validate.d.ts

@@ -0,0 +1,2 @@
+import type { ValidationResult } from '../validation-types.js';
+export declare function validateFactor(input: unknown): ValidationResult;

package/dist/factor/validate.js

@@ -0,0 +1,69 @@
+// FACTOR validator — methodology notations/ELEMENT_PRIMITIVES.md §7.1.
+//
+// Implements FACTOR-001..003. Cross-cutting HDR-/LIFECYCLE-/policy rules
+// (CONTRACT.md §8) are owned elsewhere and out of scope for this
+// single-artefact validator.
+import { typeOfId } from '../typed-id.js';
+import { validateElementEnvelope } from '../element-envelope.js';
+import { FACTOR_CATEGORIES, FACTOR_TYPES } from './types.js';
+export function validateFactor(input) {
+    const errors = [];
+    const warnings = [];
+    const { record, errors: envErrors } = validateElementEnvelope(input, {
+        notation: 'factor',
+        idType: 'FACTOR',
+        code: 'FACTOR-001',
+    });
+    errors.push(...envErrors);
+    if (!record)
+        return { valid: false, errors, warnings };
+    // FACTOR-002 — type subtype enum (optional field).
+    if (record.type !== undefined && !FACTOR_TYPES.includes(record.type)) {
+        errors.push({
+            code: 'FACTOR-002',
+            message: `type "${String(record.type)}" must be one of ${FACTOR_TYPES.join(', ')}.`,
+            path: 'type',
+        });
+    }
+    // FACTOR-003 — PESTLE category enum on external factors; warn on internal.
+    if (record.category !== undefined) {
+        if (!FACTOR_CATEGORIES.includes(record.category)) {
+            errors.push({
+                code: 'FACTOR-003',
+                message: `category "${String(record.category)}" must be a PESTLE class (${FACTOR_CATEGORIES.join(', ')}).`,
+                path: 'category',
+            });
+        }
+        else if (record.type === 'internal') {
+            // §7.1: "Omit on internal factors — PESTLE does not apply."
+            warnings.push({
+                code: 'FACTOR-003',
+                message: 'category is set on an internal factor; PESTLE applies to external drivers only.',
+                path: 'category',
+            });
+        }
+    }
+    // FACTOR-001 — references_constraint shape + TYPE on each entry.
+    if (record.references_constraint !== undefined) {
+        if (!Array.isArray(record.references_constraint)) {
+            errors.push({
+                code: 'FACTOR-001',
+                message: 'references_constraint must be a list of typed CONSTRAINT IDs.',
+                path: 'references_constraint',
+            });
+        }
+        else {
+            record.references_constraint.forEach((ref, i) => {
+                const type = typeOfId(ref);
+                if (type !== 'CONSTRAINT') {
+                    errors.push({
+                        code: 'FACTOR-001',
+                        message: `references_constraint[${i}] "${String(ref)}" must be a CONSTRAINT typed ID.`,
+                        path: `references_constraint[${i}]`,
+                    });
+                }
+            });
+        }
+    }
+    return { valid: errors.length === 0, errors, warnings };
+}

package/dist/fgca/__tests__/chain-table.test.d.ts

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

package/dist/fgca/__tests__/chain-table.test.js

@@ -0,0 +1,158 @@
+import { describe, it, expect } from 'vitest';
+import { buildChainTable } from '../chain-table.js';
+// Renders a ChainTable to a compact text grid for readable assertions. Each
+// cell shows "label×rowSpan" (×1 omitted); a position covered by a span above
+// shows "·".
+function asGrid(t) {
+    return t.rows.map(row => row.map(c => {
+        if (c === null)
+            return '·';
+        const label = c.cell ? c.cell.label : '∅';
+        return c.rowSpan > 1 ? `${label}×${c.rowSpan}` : label;
+    }));
+}
+describe('buildChainTable — worked example (FGCA)', () => {
+    // F1 → G1, G2 ; G1 → C1 → A1 ; G2 → C2 → A2, A3
+    const doc = {
+        factors: [{ id: 1, name: 'F1' }],
+        goals: [
+            { id: 10, name: 'G1', factor: [{ id: 1 }] },
+            { id: 11, name: 'G2', factor: [{ id: 1 }] },
+        ],
+        changes: [
+            { id: 20, name: 'C1', goal_id: 10, activity_ids: [30] },
+            { id: 21, name: 'C2', goal_id: 11, activity_ids: [31, 32] },
+        ],
+        activities: [
+            { id: 30, name: 'A1', goal_id: 10 },
+            { id: 31, name: 'A2', goal_id: 11 },
+            { id: 32, name: 'A3', goal_id: 11 },
+        ],
+    };
+    it('produces the spec grid with F1 spanning 3 and G2/C2 spanning 2', () => {
+        const t = buildChainTable(doc);
+        expect(t.columns).toEqual(['factor', 'goal', 'change', 'activity']);
+        expect(asGrid(t)).toEqual([
+            ['F1×3', 'G1', 'C1', 'A1'],
+            ['·', 'G2×2', 'C2×2', 'A2'],
+            ['·', '·', '·', 'A3'],
+        ]);
+    });
+    it('orders the merged cells with correct rowSpans on the model', () => {
+        const t = buildChainTable(doc);
+        // Factor cell spans all three rows.
+        expect(t.rows[0][0]).toMatchObject({ rowSpan: 3, cell: { label: 'F1' } });
+        // Covered positions are null (no <td> emitted).
+        expect(t.rows[1][0]).toBeNull();
+        expect(t.rows[2][1]).toBeNull();
+    });
+});
+describe('buildChainTable — FGA (no Change column)', () => {
+    // FGA links Goal → Activity directly via activity.goal_id; no changes.
+    const doc = {
+        factors: [{ id: 1, name: 'F1' }],
+        goals: [{ id: 10, name: 'G1', factor: [{ id: 1 }] }],
+        activities: [
+            { id: 30, name: 'A1', goal_id: 10 },
+            { id: 31, name: 'A2', goal_id: 10 },
+        ],
+    };
+    it('emits three columns and merges Factor/Goal across the two activities', () => {
+        const t = buildChainTable(doc, { hideChanges: true });
+        expect(t.columns).toEqual(['factor', 'goal', 'activity']);
+        expect(asGrid(t)).toEqual([
+            ['F1×2', 'G1×2', 'A1'],
+            ['·', '·', 'A2'],
+        ]);
+    });
+});
+describe('buildChainTable — missing downstream links (gaps stay visible)', () => {
+    it('shows a factor with no goal, a goal with no change, and a change with no activity', () => {
+        const doc = {
+            factors: [
+                { id: 1, name: 'F1' },
+                { id: 2, name: 'F2' }, // no goals
+            ],
+            goals: [
+                { id: 10, name: 'G1', factor: [{ id: 1 }] }, // no change, no activity
+                { id: 11, name: 'G2', factor: [{ id: 1 }] }, // has a change with no activity
+            ],
+            changes: [{ id: 20, name: 'C1', goal_id: 11, activity_ids: [] }],
+            activities: [],
+        };
+        const t = buildChainTable(doc);
+        expect(asGrid(t)).toEqual([
+            ['F1×2', 'G1', '∅', '∅'],
+            ['·', 'G2', 'C1', '∅'],
+            ['F2', '∅', '∅', '∅'],
+        ]);
+    });
+    it('renders a change-less direct goal→activity path with an empty Change cell', () => {
+        const doc = {
+            factors: [{ id: 1, name: 'F1' }],
+            goals: [{ id: 10, name: 'G1', factor: [{ id: 1 }] }],
+            // activity bound straight to the goal, not covered by any change
+            changes: [],
+            activities: [{ id: 30, name: 'A1', goal_id: 10 }],
+        };
+        const t = buildChainTable(doc);
+        expect(asGrid(t)).toEqual([['F1', 'G1', '∅', 'A1']]);
+    });
+});
+describe('buildChainTable — orphans (broken refs are warnings, not errors)', () => {
+    it('places a goal with a missing factor in a trailing empty-Factor row', () => {
+        const doc = {
+            factors: [{ id: 1, name: 'F1' }],
+            goals: [
+                { id: 10, name: 'G1', factor: [{ id: 1 }] },
+                { id: 11, name: 'Gx', factor: [{ id: 99 }] }, // factor 99 does not exist
+                { id: 12, name: 'Gy' }, // no factor at all
+            ],
+            changes: [{ id: 20, name: 'C1', goal_id: 10, activity_ids: [30] }],
+            activities: [{ id: 30, name: 'A1', goal_id: 10 }],
+        };
+        const t = buildChainTable(doc);
+        expect(asGrid(t)).toEqual([
+            ['F1', 'G1', 'C1', 'A1'],
+            ['∅×2', 'Gx', '∅', '∅'],
+            ['·', 'Gy', '∅', '∅'],
+        ]);
+    });
+    it('surfaces an unlinked activity as a trailing row with empty cells to its left', () => {
+        const doc = {
+            factors: [{ id: 1, name: 'F1' }],
+            goals: [{ id: 10, name: 'G1', factor: [{ id: 1 }] }],
+            changes: [{ id: 20, name: 'C1', goal_id: 10, activity_ids: [30] }],
+            activities: [
+                { id: 30, name: 'A1', goal_id: 10 },
+                { id: 99, name: 'Aorphan' }, // no goal, no change
+            ],
+        };
+        const t = buildChainTable(doc);
+        expect(asGrid(t)).toEqual([
+            ['F1', 'G1', 'C1', 'A1'],
+            ['∅', '∅', '∅', 'Aorphan'],
+        ]);
+    });
+    it('surfaces a change whose goal is missing as an empty Factor+Goal row', () => {
+        const doc = {
+            factors: [],
+            goals: [],
+            changes: [{ id: 20, name: 'Cx', goal_id: 999, activity_ids: [30] }],
+            activities: [{ id: 30, name: 'A1' }],
+        };
+        const t = buildChainTable(doc);
+        expect(asGrid(t)).toEqual([['∅', '∅', 'Cx', 'A1']]);
+    });
+});
+describe('buildChainTable — name fallback', () => {
+    it('falls back to the id when an element has an empty name', () => {
+        const doc = {
+            factors: [{ id: 7, name: '' }],
+            goals: [],
+            activities: [],
+        };
+        const t = buildChainTable(doc);
+        expect(t.rows[0][0]?.cell?.label).toBe('7');
+    });
+});

package/dist/fgca/__tests__/layout.test.d.ts

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

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

@@ -0,0 +1,140 @@
+import { describe, it, expect, vi, beforeAll } from "vitest";
+// reactflow uses browser APIs — stub the minimum required before importing layout
+beforeAll(() => {
+    vi.mock("reactflow", () => ({
+        Position: { Left: "left", Right: "right" },
+        MarkerType: { ArrowClosed: "arrowclosed" },
+    }));
+});
+import { buildFGCALayout } from "../layout";
+import { ALL_FGCA_COLUMNS } from "../types";
+const ALL_COLS = new Set(ALL_FGCA_COLUMNS);
+const factors = [
+    { id: 1, name: "Digital growth" },
+    { id: 2, name: "Talent shortage" },
+];
+const goals = [
+    { id: 10, name: "Grow revenue", level: 0, factor: [{ id: 1 }] },
+    { id: 11, name: "Build talent pipeline", level: 1, factor: [{ id: 2 }] },
+];
+const changes = [
+    { id: 100, name: "Launch digital channel", goal_id: 10, activity_ids: [200] },
+    { id: 101, name: "Partner with bootcamps", goal_id: 11, activity_ids: [201] },
+];
+const activities = [
+    { id: 200, name: "Build e-commerce MVP", goal_id: 10, activity_type_id: 1 },
+    { id: 201, name: "Run hiring sprint", goal_id: 11, activity_type_id: 1 },
+];
+describe("buildFGCALayout — all columns visible", () => {
+    const { nodes, edges } = buildFGCALayout({
+        factors,
+        goals,
+        changes,
+        activities,
+        visibleColumns: ALL_COLS,
+        activityTypeList: [{ id: 1, name: "Initiative" }],
+    });
+    it("produces the correct number of nodes", () => {
+        expect(nodes).toHaveLength(factors.length + goals.length + changes.length + activities.length);
+    });
+    it("assigns correct node types", () => {
+        const types = nodes.map((n) => n.type);
+        expect(types.filter((t) => t === "fgcaFactor")).toHaveLength(factors.length);
+        expect(types.filter((t) => t === "fgcaGoal")).toHaveLength(goals.length);
+        expect(types.filter((t) => t === "fgcaChange")).toHaveLength(changes.length);
+        expect(types.filter((t) => t === "fgcaActivity")).toHaveLength(activities.length);
+    });
+    it("creates Factor→Goal edges", () => {
+        const fgEdges = edges.filter((e) => e.source.startsWith("factor_") && e.target.startsWith("goal_"));
+        expect(fgEdges).toHaveLength(2);
+        expect(fgEdges.find((e) => e.source === "factor_1" && e.target === "goal_10")).toBeTruthy();
+    });
+    it("creates Goal→Change edges", () => {
+        const gcEdges = edges.filter((e) => e.source.startsWith("goal_") && e.target.startsWith("change_"));
+        expect(gcEdges).toHaveLength(2);
+    });
+    it("creates Change→Activity edges", () => {
+        const caEdges = edges.filter((e) => e.source.startsWith("change_") && e.target.startsWith("activity_"));
+        expect(caEdges).toHaveLength(2);
+    });
+    it("does NOT create direct Goal→Activity edges when Change column is visible and all activities are covered", () => {
+        const directEdges = edges.filter((e) => e.source.startsWith("goal_") && e.target.startsWith("activity_"));
+        expect(directEdges).toHaveLength(0);
+    });
+    it("uses the activity type name in activity node data", () => {
+        const actNode = nodes.find((n) => n.id === "activity_200");
+        expect(actNode?.data.activityTypeName).toBe("Initiative");
+    });
+    it("encodes F-XXXX label format via id in node data", () => {
+        const factorNode = nodes.find((n) => n.id === "factor_1");
+        expect(String(factorNode?.data.id).padStart(4, "0")).toBe("0001");
+    });
+    it("encodes C-XXX label format via id in node data", () => {
+        const changeNode = nodes.find((n) => n.id === "change_100");
+        expect(String(changeNode?.data.id).padStart(3, "0")).toBe("100");
+    });
+});
+describe("buildFGCALayout — Factor column hidden", () => {
+    const cols = new Set(ALL_FGCA_COLUMNS.filter((c) => c !== "factor"));
+    const { nodes, edges } = buildFGCALayout({ factors, goals, changes, activities, visibleColumns: cols });
+    it("produces no factor nodes", () => {
+        expect(nodes.filter((n) => n.type === "fgcaFactor")).toHaveLength(0);
+    });
+    it("produces no Factor→Goal edges", () => {
+        expect(edges.filter((e) => e.source.startsWith("factor_"))).toHaveLength(0);
+    });
+    it("still produces Goal and downstream nodes", () => {
+        expect(nodes.filter((n) => n.type === "fgcaGoal")).toHaveLength(goals.length);
+    });
+});
+describe("buildFGCALayout — Change column hidden", () => {
+    const cols = new Set(ALL_FGCA_COLUMNS.filter((c) => c !== "change"));
+    const { nodes, edges } = buildFGCALayout({ factors, goals, changes, activities, visibleColumns: cols });
+    it("produces no change nodes", () => {
+        expect(nodes.filter((n) => n.type === "fgcaChange")).toHaveLength(0);
+    });
+    it("creates direct Goal→Activity edges when Change column is hidden", () => {
+        const directEdges = edges.filter((e) => e.source.startsWith("goal_") && e.target.startsWith("activity_"));
+        expect(directEdges.length).toBeGreaterThan(0);
+    });
+});
+describe("buildFGCALayout — only one column visible", () => {
+    const { nodes, edges } = buildFGCALayout({
+        factors,
+        goals,
+        changes,
+        activities,
+        visibleColumns: new Set(["goal"]),
+    });
+    it("produces only goal nodes", () => {
+        expect(nodes.filter((n) => n.type !== "fgcaGoal")).toHaveLength(0);
+    });
+    it("produces no edges", () => {
+        expect(edges).toHaveLength(0);
+    });
+});
+describe("buildFGCALayout — columns are positioned left to right", () => {
+    const { nodes } = buildFGCALayout({ factors, goals, changes, activities, visibleColumns: ALL_COLS });
+    it("factor column x < goal column x", () => {
+        const f = nodes.find((n) => n.type === "fgcaFactor");
+        const g = nodes.find((n) => n.type === "fgcaGoal");
+        expect(f.position.x).toBeLessThan(g.position.x);
+    });
+    it("goal column x < change column x", () => {
+        const g = nodes.find((n) => n.type === "fgcaGoal");
+        const c = nodes.find((n) => n.type === "fgcaChange");
+        expect(g.position.x).toBeLessThan(c.position.x);
+    });
+    it("change column x < activity column x", () => {
+        const c = nodes.find((n) => n.type === "fgcaChange");
+        const a = nodes.find((n) => n.type === "fgcaActivity");
+        expect(c.position.x).toBeLessThan(a.position.x);
+    });
+    // Pre-release blocker regression (orchestrator review 2026-05-21).
+    it("[blocker] tolerates a change with no activity_ids (optional per validator)", () => {
+        const changesNoIds = [
+            { id: 100, name: "No activities", goal_id: 10 },
+        ];
+        expect(() => buildFGCALayout({ factors, goals, changes: changesNoIds, activities, visibleColumns: ALL_COLS })).not.toThrow();
+    });
+});

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

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