@transitrix/diagrams 1.8.6 → 1.8.8

package/src/fgca/__tests__/layout.test.ts

@@ -1,179 +0,0 @@
-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 type { DriverItem, GoalItem, BdnChangeWithActivities, ActivityItem } from "../types";
-import { ALL_FGCA_COLUMNS } from "../types";
-
-const ALL_COLS = new Set(ALL_FGCA_COLUMNS);
-
-const factors: DriverItem[] = [
-  { id: 1, name: "Digital growth" },
-  { id: 2, name: "Talent shortage" },
-];
-
-const goals: GoalItem[] = [
-  { id: 10, name: "Grow revenue", level: 0, factor: [{ id: 1 }] },
-  { id: 11, name: "Build talent pipeline", level: 1, factor: [{ id: 2 }] },
-];
-
-const changes: BdnChangeWithActivities[] = [
-  { 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: ActivityItem[] = [
-  { 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 === "fgcaDriver")).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("driver_") && e.target.startsWith("goal_"));
-    expect(fgEdges).toHaveLength(2);
-    expect(fgEdges.find((e) => e.source === "driver_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 === "driver_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 — Driver column hidden", () => {
-  const cols = new Set(ALL_FGCA_COLUMNS.filter((c) => c !== "driver"));
-  const { nodes, edges } = buildFGCALayout({ factors, goals, changes, activities, visibleColumns: cols });
-
-  it("produces no driver nodes", () => {
-    expect(nodes.filter((n) => n.type === "fgcaDriver")).toHaveLength(0);
-  });
-
-  it("produces no Driver→Goal edges", () => {
-    expect(edges.filter((e) => e.source.startsWith("driver_"))).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"] as const),
-  });
-
-  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 === "fgcaDriver")!;
-    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: BdnChangeWithActivities[] = [
-      { id: 100, name: "No activities", goal_id: 10 } as BdnChangeWithActivities,
-    ];
-    expect(() =>
-      buildFGCALayout({ factors, goals, changes: changesNoIds, activities, visibleColumns: ALL_COLS }),
-    ).not.toThrow();
-  });
-});

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

@@ -1,296 +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 { parseCanonicalFGCA, parseCanonicalFGA } from '../parse-canonical.js';
-
-const VALID = {
-  notation: 'dgca',
-  spec_version: '0.1',
-  id: 'FGCA-SAMPLE-1',
-  name: 'Sample FGCA chain',
-  factors: [
-    { id: 'FACTOR-1', name: 'Driver one', type: 'external' },
-  ],
-  goals: [
-    { id: 'GOAL-1', name: 'Outcome one', factors: ['FACTOR-1'] },
-  ],
-  changes: [
-    { id: 'CHANGE-1', name: 'Transformation', goals: ['GOAL-1'] },
-  ],
-  actions: [
-    { id: 'ACTIVITY-1', name: 'Workstream', changes: ['CHANGE-1'] },
-  ],
-};
-
-describe('parseCanonicalFGCA', () => {
-  it('accepts a valid canonical document', () => {
-    const r = parseCanonicalFGCA(VALID);
-    expect(r.valid).toBe(true);
-    expect(r.errors).toEqual([]);
-    expect(r.parsed).toBeDefined();
-    expect(r.parsed?.factors).toHaveLength(1);
-    expect(r.parsed?.goals).toHaveLength(1);
-    expect(r.parsed?.changes).toHaveLength(1);
-    expect(r.parsed?.activities).toHaveLength(1);
-  });
-
-  it('accepts ACTION-* ids (methodology 1.0) alongside legacy ACTIVITY-*', () => {
-    const r = parseCanonicalFGCA({
-      ...VALID,
-      actions: [
-        { id: 'ACTION-CRM-EU-1', name: 'CRM rollout', changes: ['CHANGE-1'] },
-        { id: 'ACTIVITY-2', name: 'Legacy workstream', changes: ['CHANGE-1'] },
-      ],
-    });
-    expect(r.valid, JSON.stringify(r.errors)).toBe(true);
-    expect(r.parsed?.activities.map((a) => a.id)).toEqual(['ACTION-CRM-EU-1', 'ACTIVITY-2']);
-  });
-
-  it('defaults changes to [] when view_config.layers.changes is off (DGA-in-dgca)', () => {
-    const r = parseCanonicalFGCA({
-      ...VALID,
-      changes: undefined,
-      view_config: { layers: { changes: 'off' } },
-      actions: [
-        { id: 'ACTION-DISCOVERY-1', name: 'Gap assessment', goals: ['GOAL-1'] },
-      ],
-    });
-    expect(r.valid, JSON.stringify(r.errors)).toBe(true);
-    expect(r.parsed?.changes).toEqual([]);
-  });
-
-  it('FGCA-001: rejects non-object input', () => {
-    expect(parseCanonicalFGCA(null).errors[0].code).toBe('FGCA-001');
-    expect(parseCanonicalFGCA('string').errors[0].code).toBe('FGCA-001');
-  });
-
-  it('FGCA-001: rejects wrong notation', () => {
-    const r = parseCanonicalFGCA({ ...VALID, notation: 'fga' });
-    expect(r.valid).toBe(false);
-    expect(r.errors.some((e) => e.code === 'FGCA-001')).toBe(true);
-  });
-
-  it('FGCA-002: rejects malformed doc id', () => {
-    const r = parseCanonicalFGCA({ ...VALID, id: 'fgca-lowercase-1' });
-    expect(r.valid).toBe(false);
-    expect(r.errors.some((e) => e.code === 'FGCA-002')).toBe(true);
-  });
-
-  it('FGCA-003: rejects missing name', () => {
-    const { name: _, ...rest } = VALID;
-    const r = parseCanonicalFGCA(rest);
-    expect(r.valid).toBe(false);
-    expect(r.errors.some((e) => e.code === 'FGCA-003')).toBe(true);
-  });
-
-  it('FGCA-004: rejects missing factors array', () => {
-    const { factors: _, ...rest } = VALID;
-    const r = parseCanonicalFGCA(rest);
-    expect(r.valid).toBe(false);
-    expect(r.errors.some((e) => e.code === 'FGCA-004')).toBe(true);
-  });
-
-  it('FGCA-006: rejects duplicate IDs within a layer', () => {
-    const r = parseCanonicalFGCA({
-      ...VALID,
-      factors: [
-        { id: 'FACTOR-1', name: 'A' },
-        { id: 'FACTOR-1', name: 'B' },
-      ],
-    });
-    expect(r.valid).toBe(false);
-    expect(r.errors.some((e) => e.code === 'FGCA-006')).toBe(true);
-  });
-
-  it('FGCA-007: rejects malformed factor id', () => {
-    const r = parseCanonicalFGCA({
-      ...VALID,
-      factors: [{ id: 'F-1', name: 'A' }],
-    });
-    expect(r.valid).toBe(false);
-    expect(r.errors.some((e) => e.code === 'FGCA-007')).toBe(true);
-  });
-
-  it('FGCA-008: rejects goal.factors[] referencing undefined factor', () => {
-    const r = parseCanonicalFGCA({
-      ...VALID,
-      goals: [{ id: 'GOAL-1', name: 'A', factors: ['FACTOR-99'] }],
-    });
-    expect(r.valid).toBe(false);
-    expect(r.errors.some((e) => e.code === 'FGCA-008')).toBe(true);
-  });
-
-  it('FGCA-009: rejects change.goals[] referencing undefined goal', () => {
-    const r = parseCanonicalFGCA({
-      ...VALID,
-      changes: [{ id: 'CHANGE-1', name: 'A', goals: ['GOAL-99'] }],
-    });
-    expect(r.valid).toBe(false);
-    expect(r.errors.some((e) => e.code === 'FGCA-009')).toBe(true);
-  });
-
-  it('FGCA-010: rejects activity.changes[] referencing undefined change', () => {
-    const r = parseCanonicalFGCA({
-      ...VALID,
-      actions: [{ id: 'ACTIVITY-1', name: 'A', changes: ['CHANGE-99'] }],
-    });
-    expect(r.valid).toBe(false);
-    expect(r.errors.some((e) => e.code === 'FGCA-010')).toBe(true);
-  });
-
-  it('FGCA-015: rejects factor.references_constraint with malformed ID', () => {
-    const r = parseCanonicalFGCA({
-      ...VALID,
-      factors: [{ id: 'FACTOR-1', name: 'A', references_constraint: ['BAD-1'] }],
-    });
-    expect(r.valid).toBe(false);
-    expect(r.errors.some((e) => e.code === 'FGCA-015')).toBe(true);
-  });
-
-  it('accepts factor.references_constraint with valid CONSTRAINT ID', () => {
-    const r = parseCanonicalFGCA({
-      ...VALID,
-      factors: [{ id: 'FACTOR-1', name: 'A', references_constraint: ['CONSTRAINT-GDPR-1'] }],
-    });
-    expect(r.valid).toBe(true);
-  });
-
-  it('populates internal change.activity_ids from canonical activity.changes (reversed direction)', () => {
-    const r = parseCanonicalFGCA({
-      ...VALID,
-      changes: [{ id: 'CHANGE-1', name: 'C', goals: ['GOAL-1'] }],
-      actions: [
-        { id: 'ACTIVITY-1', name: 'A1', changes: ['CHANGE-1'] },
-        { id: 'ACTIVITY-2', name: 'A2', changes: ['CHANGE-1'] },
-      ],
-    });
-    expect(r.valid).toBe(true);
-    expect(r.parsed?.changes[0].activity_ids).toHaveLength(2);
-  });
-});
-
-// The "FGCA preview blank / FGA no edges" regression (vkgeorgia/strategy#65,
-// transitrix/methodology#65) was a data defect: the canonical flat shape was
-// not being mapped to the internal cross-ref fields the renderer turns into
-// edges. These assert the edge-driving fields are populated, so the renderer
-// has something to draw — locking the fix.
-describe('parseCanonicalFGCA — edge-driving fields populated', () => {
-  it('maps goal.factors → goal.factor[], change.goals → change.goal_id, activity.changes → change.activity_ids', () => {
-    const r = parseCanonicalFGCA(VALID);
-    expect(r.valid).toBe(true);
-    const parsed = r.parsed!;
-    // factor → goal edge source
-    expect(parsed.goals[0].factor).toHaveLength(1);
-    // goal → change edge
-    expect(parsed.changes[0].goal_id).not.toBe(0);
-    expect(parsed.changes[0].goal_id).not.toBe('');
-    // change → activity edge
-    expect(parsed.changes[0].activity_ids).toHaveLength(1);
-  });
-
-  it('preserves canonical string IDs — not converted to sequential numbers', () => {
-    const r = parseCanonicalFGCA(VALID);
-    expect(r.valid).toBe(true);
-    const parsed = r.parsed!;
-    expect(parsed.factors[0].id).toBe('FACTOR-1');
-    expect(parsed.goals[0].id).toBe('GOAL-1');
-    expect(parsed.goals[0].factor![0].id).toBe('FACTOR-1');
-    expect(parsed.changes[0].id).toBe('CHANGE-1');
-    expect(parsed.changes[0].goal_id).toBe('GOAL-1');
-    expect(parsed.changes[0].activity_ids[0]).toBe('ACTIVITY-1');
-    expect(parsed.activities[0].id).toBe('ACTIVITY-1');
-  });
-});
-
-describe('parseCanonicalFGA', () => {
-  const VALID_FGA = {
-    notation: 'dga',
-    spec_version: '0.1',
-    id: 'FGA-SAMPLE-1',
-    name: 'Sample FGA chain',
-    factors: [{ id: 'FACTOR-1', name: 'Driver' }],
-    goals: [{ id: 'GOAL-1', name: 'Outcome', factors: ['FACTOR-1'] }],
-    actions: [{ id: 'ACTIVITY-1', name: 'Workstream', goals: ['GOAL-1'] }],
-  };
-
-  it('accepts a valid canonical FGA document (no changes layer)', () => {
-    const r = parseCanonicalFGA(VALID_FGA);
-    expect(r.valid).toBe(true);
-    expect(r.errors).toEqual([]);
-    expect(r.parsed?.factors).toHaveLength(1);
-    expect(r.parsed?.goals).toHaveLength(1);
-    expect(r.parsed?.activities).toHaveLength(1);
-  });
-
-  it('accepts ACTION-* ids in FGA mode', () => {
-    const r = parseCanonicalFGA({
-      ...VALID_FGA,
-      actions: [{ id: 'ACTION-GDPR-DSR-WORKFLOW-1', name: 'DSR workflow', goals: ['GOAL-1'] }],
-    });
-    expect(r.valid, JSON.stringify(r.errors)).toBe(true);
-    expect(r.parsed?.activities[0].id).toBe('ACTION-GDPR-DSR-WORKFLOW-1');
-  });
-
-  it('populates activity.goal_id from activity.goals[] (the FGA edge-driving field)', () => {
-    // The "FGA nodes render, no edges" bug: activities had no resolvable
-    // goal_id, so the renderer drew no goal → activity edges.
-    const r = parseCanonicalFGA(VALID_FGA);
-    expect(r.valid).toBe(true);
-    expect(r.parsed?.activities[0].goal_id).not.toBeNull();
-    expect(r.parsed?.activities[0].goal_id).not.toBe(0);
-  });
-
-  it('FGA-001: rejects wrong notation', () => {
-    const r = parseCanonicalFGA({ ...VALID_FGA, notation: 'fgca' });
-    expect(r.valid).toBe(false);
-    expect(r.errors.some((e) => e.code === 'FGA-001')).toBe(true);
-  });
-
-  it('FGA-002: rejects malformed doc id', () => {
-    const r = parseCanonicalFGA({ ...VALID_FGA, id: 'fga-lower-1' });
-    expect(r.valid).toBe(false);
-    expect(r.errors.some((e) => e.code === 'FGA-002')).toBe(true);
-  });
-
-  it('remaps FGCA layer codes into the FGA registry (e.g. FGA-007 for a bad id)', () => {
-    const r = parseCanonicalFGA({ ...VALID_FGA, factors: [{ id: 'F-1', name: 'bad' }] });
-    expect(r.valid).toBe(false);
-    expect(r.errors.some((e) => e.code === 'FGA-007')).toBe(true);
-    // No raw FGCA-prefixed code should leak through the remap.
-    expect(r.errors.every((e) => !e.code.startsWith('FGCA-'))).toBe(true);
-  });
-});
-
-describe('parseCanonicalFGCA — example file regression', () => {
-  const EXAMPLES_DIR = path.resolve(process.cwd(), '..', '..', 'tests', 'fixtures', 'notation-corpus', 'dgca');
-  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/dgca/${file}`, () => {
-      const text = fs.readFileSync(path.join(EXAMPLES_DIR, file), 'utf8');
-      const parsedYaml = yaml.load(text);
-      const r = parseCanonicalFGCA(parsedYaml);
-      expect(r.errors).toEqual([]);
-      expect(r.valid).toBe(true);
-    });
-  }
-});
-
-describe('parseCanonicalFGA — example file regression', () => {
-  const EXAMPLES_DIR = path.resolve(process.cwd(), '..', '..', 'tests', 'fixtures', 'notation-corpus', 'dga');
-  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/dga/${file} and resolves every activity to a goal`, () => {
-      const text = fs.readFileSync(path.join(EXAMPLES_DIR, file), 'utf8');
-      const r = parseCanonicalFGA(yaml.load(text));
-      expect(r.errors).toEqual([]);
-      expect(r.valid).toBe(true);
-      // Every activity must carry a goal_id, or the FGA preview draws no edges.
-      expect(r.parsed!.activities.every((a) => a.goal_id != null && a.goal_id !== 0 && a.goal_id !== '')).toBe(true);
-    });
-  }
-});

package/src/fgca/__tests__/preview-layout.test.ts

@@ -1,124 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import {
-  layoutFGCAPreview,
-  FGCA_PAD,
-  FGCA_NODE_W,
-  type FGCAPreviewDoc,
-} from '../preview-layout.js';
-
-const doc: FGCAPreviewDoc = {
-  factors: [
-    { id: 1, name: 'F1' },
-    { id: 2, name: 'F2' },
-  ],
-  goals: [
-    { id: 10, name: 'G1', factor: [{ id: 1 }] },
-    { id: 11, name: 'G2', factor: [{ id: 2 }] },
-  ],
-  changes: [{ id: 20, name: 'C1', goal_id: 10, activity_ids: [30] }],
-  activities: [
-    { id: 30, name: 'A1', goal_id: 10 },
-    { id: 31, name: 'A2', goal_id: 11 },
-  ],
-};
-
-describe('layoutFGCAPreview', () => {
-  it('lays out all four columns in order (FGCA)', () => {
-    const layout = layoutFGCAPreview(doc);
-    expect(layout.columns.map(c => c.col)).toEqual(['driver', 'goal', 'change', 'activity']);
-    // 2 factors + 2 goals + 1 change + 2 activities
-    expect(layout.nodes).toHaveLength(7);
-    expect(layout.width).toBeGreaterThan(0);
-    expect(layout.height).toBeGreaterThan(0);
-  });
-
-  it('produces the expected FGCA edge set', () => {
-    // F1→G1, F2→G2 (2), G1→C1 (1), C1→A1 (1), G2→A2 direct (1) = 5
-    const layout = layoutFGCAPreview(doc);
-    expect(layout.edges).toHaveLength(5);
-  });
-
-  it('hideChanges (FGA) drops the Changes column and links goals to activities', () => {
-    const layout = layoutFGCAPreview(doc, { hideChanges: true });
-    expect(layout.columns.map(c => c.col)).toEqual(['driver', 'goal', 'activity']);
-    // 2 factors + 2 goals + 2 activities
-    expect(layout.nodes).toHaveLength(6);
-    // F1→G1, F2→G2 (2), G1→A1, G2→A2 (2) = 4
-    expect(layout.edges).toHaveLength(4);
-  });
-
-  it('first column sits at the pad origin', () => {
-    const layout = layoutFGCAPreview(doc);
-    expect(layout.columns[0].x).toBe(FGCA_PAD);
-  });
-
-  it('empty options reproduce the default layout', () => {
-    const a = layoutFGCAPreview(doc);
-    const b = layoutFGCAPreview(doc, {});
-    expect(b.nodes.map(n => `${n.id}:${n.x},${n.y}`)).toEqual(a.nodes.map(n => `${n.id}:${n.x},${n.y}`));
-  });
-
-  it('larger colGap widens the column step', () => {
-    const stepOf = (colGap: number) => {
-      const cols = layoutFGCAPreview(doc, { colGap }).columns;
-      return cols[1].x - cols[0].x;
-    };
-    expect(stepOf(80)).toBe(FGCA_NODE_W + 80);
-    expect(stepOf(240)).toBe(FGCA_NODE_W + 240);
-    expect(stepOf(240)).toBeGreaterThan(stepOf(80));
-  });
-
-  it('larger rowGap increases the gap between stacked nodes', () => {
-    const gapOf = (rowGap: number) => {
-      const factors = layoutFGCAPreview(doc, { rowGap }).nodes.filter(n => n.col === 'driver');
-      return factors[1].y - factors[0].y;
-    };
-    expect(gapOf(120)).toBeGreaterThan(gapOf(20));
-  });
-
-  // vkgeorgia/strategy#77 — scope filtering. FGCA goals are flat, so 'root'
-  // selects the single matching goal plus the factors/changes/activities that
-  // touch it.
-  describe('scope', () => {
-    const idsOf = (layout: ReturnType<typeof layoutFGCAPreview>) => new Set(layout.nodes.map(n => n.id));
-
-    it("mode 'root' keeps only the root goal and what connects to it", () => {
-      // root 10 → factor 1 (referenced by G10), change 20 (goal_id 10),
-      // activity 30 (via change 20). G11/F2/A31 are dropped.
-      const layout = layoutFGCAPreview(doc, { scope: { mode: 'root', rootGoalId: '10' } });
-      expect(idsOf(layout)).toEqual(new Set(['driver_1', 'goal_10', 'change_20', 'activity_30']));
-    });
-
-    it("mode 'root' filters factors and activities to those touching the visible goal", () => {
-      // root 11 → factor 2, activity 31 (direct goal link); no change touches G11.
-      const layout = layoutFGCAPreview(doc, { scope: { mode: 'root', rootGoalId: '11' } });
-      expect(idsOf(layout)).toEqual(new Set(['driver_2', 'goal_11', 'activity_31']));
-      // F1, A30, C20 (which only touch the hidden G10) are excluded.
-      expect(layout.nodes.some(n => n.id === 'driver_1')).toBe(false);
-      expect(layout.nodes.some(n => n.id === 'activity_30')).toBe(false);
-    });
-
-    it("mode 'level' trims goals above the cap and their connections", () => {
-      const leveled: FGCAPreviewDoc = {
-        factors: [{ id: 1, name: 'F1' }, { id: 2, name: 'F2' }],
-        goals: [
-          { id: 10, name: 'G1', level: 0, factor: [{ id: 1 }] },
-          { id: 11, name: 'G2', level: 1, factor: [{ id: 2 }] },
-        ],
-        changes: [],
-        activities: [
-          { id: 30, name: 'A1', goal_id: 10 },
-          { id: 31, name: 'A2', goal_id: 11 },
-        ],
-      };
-      const layout = layoutFGCAPreview(leveled, { scope: { mode: 'level', maxLevel: 0 } });
-      expect(idsOf(layout)).toEqual(new Set(['driver_1', 'goal_10', 'activity_30']));
-    });
-
-    it("mode 'root' returns an empty layout when the root is absent", () => {
-      const layout = layoutFGCAPreview(doc, { scope: { mode: 'root', rootGoalId: '999' } });
-      expect(layout.nodes).toHaveLength(0);
-      expect(layout.edges).toHaveLength(0);
-    });
-  });
-});