@transitrix/diagrams 1.0.1 → 1.1.0

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

@@ -2,7 +2,7 @@ import { describe, it, expect } from 'vitest';
 import { validateFactor } from '../validate.js';
 function validExternal() {
     return {
-        notation: 'factor',
+        notation: 'driver',
         id: 'FACTOR-EU-REG-1',
         name: 'EU regulatory window',
         type: 'external',
@@ -19,7 +19,7 @@ function validExternal() {
 }
 function validInternal() {
     return {
-        notation: 'factor',
+        notation: 'driver',
         id: 'FACTOR-COMP-1',
         name: 'Support response time',
         type: 'internal',
@@ -60,7 +60,7 @@ describe('validateFactor — FACTOR-001 (shape / id grammar)', () => {
         expect(codes({ ...validExternal(), id: 'factor-1' })).toContain('FACTOR-001');
     });
     it('flags a wrong notation tag and a non-canon zone', () => {
-        expect(codes({ ...validExternal(), notation: 'driver' })).toContain('FACTOR-001');
+        expect(codes({ ...validExternal(), notation: 'factor' })).toContain('FACTOR-001');
         expect(codes({ ...validExternal(), zone: 'sandbox' })).toContain('FACTOR-001');
     });
     it('flags a missing valid_to key (distinct from a null value)', () => {

package/dist/factor/types.d.ts

@@ -4,7 +4,7 @@ export type FactorType = 'external' | 'internal';
 export declare const FACTOR_PESTLE_CATEGORIES: readonly ["political", "economic", "social", "technological", "legal", "environmental"];
 export type FactorPestleCategory = typeof FACTOR_PESTLE_CATEGORIES[number];
 export interface Factor {
-    notation: 'factor';
+    notation: 'driver';
     id: string;
     name: string;
     type?: FactorType;

package/dist/factor/validate.js

@@ -27,8 +27,8 @@ export function validateFactor(input, options = {}) {
     if (!isCanonicalIdOfType(f.id, 'FACTOR')) {
         errors.push({ code: 'FACTOR-001', message: `id "${String(f.id)}" must match FACTOR-[<middle>-]<INTEGER>.`, path: 'id' });
     }
-    if (f.notation !== 'factor') {
-        errors.push({ code: 'FACTOR-001', message: 'notation must be the fixed value "factor".', path: 'notation' });
+    if (f.notation !== 'driver') {
+        errors.push({ code: 'FACTOR-001', message: 'notation must be the fixed value "driver".', path: 'notation' });
     }
     if (f.zone !== undefined && f.zone !== 'canon') {
         errors.push({ code: 'FACTOR-001', message: 'zone must be "canon" for a FACTOR.', path: 'zone' });

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

@@ -31,7 +31,7 @@ describe('buildChainTable — worked example (FGCA)', () => {
     };
     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(t.columns).toEqual(['driver', 'goal', 'change', 'activity']);
         expect(asGrid(t)).toEqual([
             ['F1×3', 'G1', 'C1', 'A1'],
             ['·', 'G2×2', 'C2×2', 'A2'],
@@ -59,7 +59,7 @@ describe('buildChainTable — FGA (no Change column)', () => {
     };
     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(t.columns).toEqual(['driver', 'goal', 'activity']);
         expect(asGrid(t)).toEqual([
             ['F1×2', 'G1×2', 'A1'],
             ['·', '·', 'A2'],

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

@@ -39,15 +39,15 @@ describe("buildFGCALayout — all columns visible", () => {
     });
     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 === "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("factor_") && e.target.startsWith("goal_"));
+        const fgEdges = edges.filter((e) => e.source.startsWith("driver_") && e.target.startsWith("goal_"));
         expect(fgEdges).toHaveLength(2);
-        expect(fgEdges.find((e) => e.source === "factor_1" && e.target === "goal_10")).toBeTruthy();
+        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_"));
@@ -66,7 +66,7 @@ describe("buildFGCALayout — all columns visible", () => {
         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");
+        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", () => {
@@ -74,14 +74,14 @@ describe("buildFGCALayout — all columns visible", () => {
         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"));
+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 factor nodes", () => {
-        expect(nodes.filter((n) => n.type === "fgcaFactor")).toHaveLength(0);
+    it("produces no driver nodes", () => {
+        expect(nodes.filter((n) => n.type === "fgcaDriver")).toHaveLength(0);
     });
-    it("produces no Factor→Goal edges", () => {
-        expect(edges.filter((e) => e.source.startsWith("factor_"))).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);
@@ -116,7 +116,7 @@ describe("buildFGCALayout — only one column visible", () => {
 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 f = nodes.find((n) => n.type === "fgcaDriver");
         const g = nodes.find((n) => n.type === "fgcaGoal");
         expect(f.position.x).toBeLessThan(g.position.x);
     });

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

@@ -18,7 +18,7 @@ const doc = {
 describe('layoutFGCAPreview', () => {
     it('lays out all four columns in order (FGCA)', () => {
         const layout = layoutFGCAPreview(doc);
-        expect(layout.columns.map(c => c.col)).toEqual(['factor', 'goal', 'change', 'activity']);
+        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);
@@ -31,7 +31,7 @@ describe('layoutFGCAPreview', () => {
     });
     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(['factor', 'goal', 'activity']);
+        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
@@ -57,7 +57,7 @@ describe('layoutFGCAPreview', () => {
     });
     it('larger rowGap increases the gap between stacked nodes', () => {
         const gapOf = (rowGap) => {
-            const factors = layoutFGCAPreview(doc, { rowGap }).nodes.filter(n => n.col === 'factor');
+            const factors = layoutFGCAPreview(doc, { rowGap }).nodes.filter(n => n.col === 'driver');
             return factors[1].y - factors[0].y;
         };
         expect(gapOf(120)).toBeGreaterThan(gapOf(20));
@@ -71,14 +71,14 @@ describe('layoutFGCAPreview', () => {
             // 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(['factor_1', 'goal_10', 'change_20', 'activity_30']));
+            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(['factor_2', 'goal_11', 'activity_31']));
+            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 === 'factor_1')).toBe(false);
+            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", () => {
@@ -95,7 +95,7 @@ describe('layoutFGCAPreview', () => {
                 ],
             };
             const layout = layoutFGCAPreview(leveled, { scope: { mode: 'level', maxLevel: 0 } });
-            expect(idsOf(layout)).toEqual(new Set(['factor_1', 'goal_10', 'activity_30']));
+            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' } });

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

@@ -6,8 +6,8 @@ import { resolveFGCA, isFGCAViewDoc } from '../resolver.js';
 import { parseCanonicalFGCA } from '../parse-canonical.js';
 // ── Inline canon element store (mirrors strategy-2026 data split into per-element form) ─
 const ELEMENTS = [
-    { notation: 'factor', id: 'FACTOR-1', name: 'Competitive market pressure', type: 'external' },
-    { notation: 'factor', id: 'FACTOR-2', name: 'Digital adoption acceleration', type: 'external' },
+    { notation: 'driver', id: 'FACTOR-1', name: 'Competitive market pressure', type: 'external' },
+    { notation: 'driver', id: 'FACTOR-2', name: 'Digital adoption acceleration', type: 'external' },
     { notation: 'goal', id: 'GOAL-1', name: 'Grow revenue by 20%', factors: ['FACTOR-1', 'FACTOR-2'] },
     { notation: 'goal', id: 'GOAL-2', name: 'Reduce operational costs', factors: ['FACTOR-2'] },
     { notation: 'goal', id: 'GOAL-3', name: 'Improve customer retention', factors: ['FACTOR-1'] },

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

@@ -1,5 +1,5 @@
 import type { FGCAPreviewDoc } from './preview-layout.js';
-export type ChainColumn = 'factor' | 'goal' | 'change' | 'activity';
+export type ChainColumn = 'driver' | 'goal' | 'change' | 'activity';
 export interface ChainCell {
     /** Column-qualified identity (e.g. "goal:3") — stable, unique across columns. */
     key: string;

package/dist/fgca/chain-table.js

@@ -1,6 +1,6 @@
 // Chain-table model for the FGCA / FGA previews (vkgeorgia/strategy#137).
 //
-// The tree/chain preview (`layoutFGCAPreview`) shows Factor → Goal → Change →
+// The tree/chain preview (`layoutFGCAPreview`) shows Driver → Goal → Change →
 // Activity as columns of nodes joined by edges. This module produces the
 // *tabular* alternative: the same chain flattened into rows, with shared
 // parents collapsed into vertically-merged (rowspan) cells.
@@ -40,8 +40,8 @@ function sameCell(a, b) {
 export function buildChainTable(doc, options = {}) {
     const { hideChanges = false } = options;
     const columns = hideChanges
-        ? ['factor', 'goal', 'activity']
-        : ['factor', 'goal', 'change', 'activity'];
+        ? ['driver', 'goal', 'activity']
+        : ['driver', 'goal', 'change', 'activity'];
     const changes = doc.changes ?? [];
     const factorIds = new Set(doc.factors.map(f => f.id));
     const activityById = new Map(doc.activities.map(a => [a.id, a]));
@@ -101,7 +101,7 @@ export function buildChainTable(doc, options = {}) {
     };
     // Phase 1 — factor-rooted paths.
     for (const f of doc.factors) {
-        const factorCell = cellOf('factor', f.id, f.name);
+        const factorCell = cellOf('driver', f.id, f.name);
         const goalsOfFactor = doc.goals.filter(g => (g.factor ?? []).some(ref => ref.id === f.id));
         if (goalsOfFactor.length === 0) {
             paths.push(pad([factorCell]));

package/dist/fgca/index.d.ts

@@ -7,10 +7,10 @@ export type { ChainTable, ChainTableCell, ChainColumn, ChainCell, ChainTableOpti
 export { validateFGCADoc } from "./validate";
 export type { FGCADoc, FGCAValidationResult, FGCAValidationError, FGCAValidationWarning } from "./validate";
 export { ALL_FGCA_COLUMNS, FGCA_COLUMN_LABELS, } from "./types";
-export type { FactorItem, GoalItem, BdnChangeWithActivities, ActivityItem, ActivityTypeItem, DiagramStyle, FGCAColumn, } from "./types";
+export type { DriverItem, GoalItem, BdnChangeWithActivities, ActivityItem, ActivityTypeItem, DiagramStyle, FGCAColumn, } from "./types";
 export { resolveFGCA, isFGCAViewDoc } from './resolver.js';
 export type { FGCAViewConfig, FGCACanonSources } from './resolver.js';
-export { default as FGCAFactorNode } from "./nodes/FGCAFactorNode";
+export { default as FGCADriverNode } from "./nodes/FGCAFactorNode";
 export { default as FGCAGoalNode } from "./nodes/FGCAGoalNode";
 export { default as FGCAChangeNode } from "./nodes/FGCAChangeNode";
 export { default as FGCAActivityNode } from "./nodes/FGCAActivityNode";

package/dist/fgca/index.js

@@ -4,7 +4,7 @@ export { buildChainTable } from "./chain-table";
 export { validateFGCADoc } from "./validate";
 export { ALL_FGCA_COLUMNS, FGCA_COLUMN_LABELS, } from "./types";
 export { resolveFGCA, isFGCAViewDoc } from './resolver.js';
-export { default as FGCAFactorNode } from "./nodes/FGCAFactorNode";
+export { default as FGCADriverNode } from "./nodes/FGCAFactorNode";
 export { default as FGCAGoalNode } from "./nodes/FGCAGoalNode";
 export { default as FGCAChangeNode } from "./nodes/FGCAChangeNode";
 export { default as FGCAActivityNode } from "./nodes/FGCAActivityNode";

package/dist/fgca/layout.d.ts

@@ -1,5 +1,5 @@
 import type { Node, Edge } from "reactflow";
-import type { FactorItem, GoalItem, BdnChangeWithActivities, ActivityItem, ActivityTypeItem, DiagramStyle, FGCAColumn } from "./types";
+import type { DriverItem, GoalItem, BdnChangeWithActivities, ActivityItem, ActivityTypeItem, DiagramStyle, FGCAColumn } from "./types";
 export declare const NODE_WIDTH = 250;
 export declare const NODE_HEIGHT = 80;
 export declare const COLUMN_GAP = 180;
@@ -7,7 +7,7 @@ export declare const ROW_GAP = 24;
 /** Default background colours per column. */
 export declare const COLUMN_BG: Record<FGCAColumn, string>;
 export interface FGCALayoutInput {
-    factors: FactorItem[];
+    factors: DriverItem[];
     goals: GoalItem[];
     changes: BdnChangeWithActivities[];
     activities: ActivityItem[];

package/dist/fgca/layout.js

@@ -6,7 +6,7 @@ export const COLUMN_GAP = 180;
 export const ROW_GAP = 24;
 /** Default background colours per column. */
 export const COLUMN_BG = {
-    factor: "#fef3c7",
+    driver: "#fef3c7",
     goal: "#e0e7ff",
     change: "#dbeafe",
     activity: "#d4edda",
@@ -27,12 +27,12 @@ export function buildFGCALayout({ factors, goals, changes, activities, visibleCo
     const goalIds = new Set(goals.map((g) => g.id));
     const edgeStyle = { strokeWidth: edgeWidth, stroke: edgeColor };
     const baseNodeStyle = { borderColor: nodeBorderColor, borderWidth: nodeBorderWidth, borderStyle: "solid" };
-    if (visibleColumns.has("factor")) {
+    if (visibleColumns.has("driver")) {
         factors.forEach((f, i) => {
             nodes.push({
-                id: `factor_${f.id}`,
-                type: "fgcaFactor",
-                position: { x: colX["factor"], y: i * (NODE_HEIGHT + ROW_GAP) },
+                id: `driver_${f.id}`,
+                type: "fgcaDriver",
+                position: { x: colX["driver"], y: i * (NODE_HEIGHT + ROW_GAP) },
                 data: { id: f.id, name: f.name, ...baseNodeStyle },
                 sourcePosition: Position.Right,
                 targetPosition: Position.Left,
@@ -88,13 +88,13 @@ export function buildFGCALayout({ factors, goals, changes, activities, visibleCo
             });
         });
     }
-    // Factor→Goal edges (via embedded factor[] on each goal)
-    if (visibleColumns.has("factor") && visibleColumns.has("goal")) {
+    // Driver→Goal edges (via embedded factor[] on each goal)
+    if (visibleColumns.has("driver") && visibleColumns.has("goal")) {
         goals.forEach((g) => {
             g.factor?.forEach((f) => {
                 edges.push({
-                    id: `edge_f${f.id}_g${g.id}`,
-                    source: `factor_${f.id}`,
+                    id: `edge_d${f.id}_g${g.id}`,
+                    source: `driver_${f.id}`,
                     target: `goal_${g.id}`,
                     markerEnd: { type: MarkerType.ArrowClosed },
                     type: "smoothstep",

package/dist/fgca/nodeTypes.d.ts

@@ -1,5 +1,5 @@
 export declare const FGCA_NODE_TYPES: {
-    readonly fgcaFactor: import("react").MemoExoticComponent<({ data, isConnectable }: import("./nodes/FGCAFactorNode").FGCAFactorNodeProps) => import("react/jsx-runtime").JSX.Element>;
+    readonly fgcaDriver: import("react").MemoExoticComponent<({ data, isConnectable }: import("./nodes/FGCAFactorNode").FGCADriverNodeProps) => import("react/jsx-runtime").JSX.Element>;
     readonly fgcaGoal: import("react").MemoExoticComponent<({ data, isConnectable }: import("./nodes/FGCAGoalNode").FGCAGoalNodeProps) => import("react/jsx-runtime").JSX.Element>;
     readonly fgcaChange: import("react").MemoExoticComponent<({ data, isConnectable }: import("./nodes/FGCAChangeNode").FGCAChangeNodeProps) => import("react/jsx-runtime").JSX.Element>;
     readonly fgcaActivity: import("react").MemoExoticComponent<({ data, isConnectable }: import("./nodes/FGCAActivityNode").FGCAActivityNodeProps) => import("react/jsx-runtime").JSX.Element>;

package/dist/fgca/nodeTypes.js

@@ -1,9 +1,9 @@
-import FGCAFactorNode from "./nodes/FGCAFactorNode";
+import FGCADriverNode from "./nodes/FGCAFactorNode";
 import FGCAGoalNode from "./nodes/FGCAGoalNode";
 import FGCAChangeNode from "./nodes/FGCAChangeNode";
 import FGCAActivityNode from "./nodes/FGCAActivityNode";
 export const FGCA_NODE_TYPES = {
-    fgcaFactor: FGCAFactorNode,
+    fgcaDriver: FGCADriverNode,
     fgcaGoal: FGCAGoalNode,
     fgcaChange: FGCAChangeNode,
     fgcaActivity: FGCAActivityNode,

package/dist/fgca/nodes/FGCAFactorNode.d.ts

@@ -1,5 +1,5 @@
 import React from "react";
-export interface FGCAFactorNodeProps {
+export interface FGCADriverNodeProps {
     data: {
         id: number;
         name: string;
@@ -8,5 +8,5 @@ export interface FGCAFactorNodeProps {
     };
     isConnectable?: boolean;
 }
-declare const FGCAFactorNode: React.MemoExoticComponent<({ data, isConnectable }: FGCAFactorNodeProps) => import("react/jsx-runtime").JSX.Element>;
-export default FGCAFactorNode;
+declare const FGCADriverNode: React.MemoExoticComponent<({ data, isConnectable }: FGCADriverNodeProps) => import("react/jsx-runtime").JSX.Element>;
+export default FGCADriverNode;

package/dist/fgca/nodes/FGCAFactorNode.js

@@ -3,8 +3,8 @@ import { memo } from "react";
 import { Handle, Position } from "reactflow";
 const NODE_WIDTH = 250;
 const NODE_HEIGHT = 80;
-const FGCAFactorNode = memo(({ data, isConnectable }) => (_jsxs("div", { style: {
-        background: "var(--ts-layer-factor)",
+const FGCADriverNode = memo(({ data, isConnectable }) => (_jsxs("div", { style: {
+        background: "var(--ts-layer-driver)",
         width: NODE_WIDTH,
         height: NODE_HEIGHT,
         padding: "6px 8px",
@@ -30,6 +30,6 @@ const FGCAFactorNode = memo(({ data, isConnectable }) => (_jsxs("div", { style:
                 wordBreak: "break-word",
                 padding: "0 4px",
                 width: "100%",
-            }, title: data.name, children: data.name }), _jsxs("div", { style: { fontSize: "10px", color: "var(--ts-text-secondary)", marginTop: 2 }, children: ["F-", String(data.id).padStart(4, "0")] })] })));
-FGCAFactorNode.displayName = "FGCAFactorNode";
-export default FGCAFactorNode;
+            }, title: data.name, children: data.name }), _jsxs("div", { style: { fontSize: "10px", color: "var(--ts-text-secondary)", marginTop: 2 }, children: ["D-", String(data.id).padStart(4, "0")] })] })));
+FGCADriverNode.displayName = "FGCADriverNode";
+export default FGCADriverNode;

package/dist/fgca/parse-canonical.js

@@ -27,10 +27,12 @@
 // is fixed per layer; middle segments are optional; the terminal is a
 // positive integer with no leading zeros.
 const FACTOR_ID_RE = /^FACTOR(-[A-Z0-9][A-Z0-9_]*)*-\d+$/;
+const DRIVER_ID_RE = /^DRIVER(-[A-Z0-9][A-Z0-9_]*)*-\d+$/;
+const FACTOR_OR_DRIVER_ID_RE = /^(FACTOR|DRIVER)(-[A-Z0-9][A-Z0-9_]*)*-\d+$/;
 const GOAL_ID_RE = /^GOAL(-[A-Z0-9][A-Z0-9_]*)*-\d+$/;
 const CHANGE_ID_RE = /^CHANGE(-[A-Z0-9][A-Z0-9_]*)*-\d+$/;
 const ACTIVITY_ID_RE = /^ACTIVITY(-[A-Z0-9][A-Z0-9_]*)*-\d+$/;
-const FGCA_DOC_ID_RE = /^FGCA(-[A-Z0-9][A-Z0-9_]*)*-\d+$/;
+const FGCA_DOC_ID_RE = /^(FGCA|DGCA)(-[A-Z0-9][A-Z0-9_]*)*-\d+$/;
 const CONSTRAINT_ID_RE = /^CONSTRAINT(-[A-Z0-9][A-Z0-9_]*)*-\d+$/;
 function isNonEmptyString(v) {
     return typeof v === 'string' && v.trim().length > 0;
@@ -55,18 +57,21 @@ export function parseCanonicalFGCA(input) {
         };
     }
     const raw = input;
-    if ('notation' in raw && raw['notation'] !== 'fgca') {
+    if ('notation' in raw && raw['notation'] !== 'fgca' && raw['notation'] !== 'dgca') {
         return {
             valid: false,
             errors: [
                 {
                     code: 'FGCA-001',
-                    message: `notation must be "fgca", got "${String(raw['notation'])}"`,
+                    message: `notation must be "dgca" (or legacy "fgca"), got "${String(raw['notation'])}"`,
                 },
             ],
             warnings,
         };
     }
+    if ('notation' in raw && raw['notation'] === 'fgca') {
+        warnings.push({ code: 'FGCA-001', message: 'notation "fgca" is deprecated — rename to "dgca"' });
+    }
     // FGCA-002 — document id (optional in v1.4 per the canonical spec? — spec
     // says required; absence is FGCA-002).
     if (raw['id'] !== undefined) {
@@ -137,7 +142,7 @@ export function parseCanonicalFGCA(input) {
         }
         return { id, name: isNonEmptyString(name) ? name : '' };
     }
-    factors.forEach((el, i) => checkLayerElement(el, `factors[${i}]`, FACTOR_ID_RE, factorIds));
+    factors.forEach((el, i) => checkLayerElement(el, `factors[${i}]`, FACTOR_OR_DRIVER_ID_RE, factorIds));
     goals.forEach((el, i) => checkLayerElement(el, `goals[${i}]`, GOAL_ID_RE, goalIds));
     changes.forEach((el, i) => checkLayerElement(el, `changes[${i}]`, CHANGE_ID_RE, changeIds));
     activities.forEach((el, i) => checkLayerElement(el, `activities[${i}]`, ACTIVITY_ID_RE, activityIds));
@@ -188,7 +193,7 @@ export function parseCanonicalFGCA(input) {
         name: String(el['name'] ?? ''),
     }));
     const internalGoals = goals.map((el, i) => {
-        const refIds = checkRefArray(el, 'factors', factorIds, FACTOR_ID_RE, 'FGCA-008', `goals[${i}]`);
+        const refIds = checkRefArray(el, 'factors', factorIds, FACTOR_OR_DRIVER_ID_RE, 'FGCA-008', `goals[${i}]`);
         return {
             id: intId(String(el['id'])),
             name: String(el['name'] ?? ''),
@@ -261,7 +266,7 @@ export function parseCanonicalFGCA(input) {
     if (errors.length > 0)
         return { valid: false, errors, warnings };
     const parsed = {
-        notation: 'fgca',
+        notation: raw['notation'] ?? 'dgca',
         spec_version: typeof raw['spec_version'] === 'string' ? raw['spec_version'] : undefined,
         factors: internalFactors,
         goals: internalGoals,
@@ -270,7 +275,7 @@ export function parseCanonicalFGCA(input) {
     };
     return { valid: true, errors, warnings, parsed };
 }
-const FGA_DOC_ID_RE = /^FGA(-[A-Z0-9][A-Z0-9_]*)*-\d+$/;
+const FGA_DOC_ID_RE = /^(FGA|DGA)(-[A-Z0-9][A-Z0-9_]*)*-\d+$/;
 /**
  * Canonical-form FGA parser + validator.
  *
@@ -293,10 +298,10 @@ export function parseCanonicalFGA(input) {
         return { valid: false, errors: [{ code: 'FGA-001', message: 'document root is not an object' }], warnings: [] };
     }
     const raw = input;
-    if ('notation' in raw && raw['notation'] !== 'fga') {
+    if ('notation' in raw && raw['notation'] !== 'fga' && raw['notation'] !== 'dga') {
         return {
             valid: false,
-            errors: [{ code: 'FGA-001', message: `notation must be "fga", got "${String(raw['notation'])}"` }],
+            errors: [{ code: 'FGA-001', message: `notation must be "dga" (or legacy "fga"), got "${String(raw['notation'])}"` }],
             warnings: [],
         };
     }
@@ -314,7 +319,7 @@ export function parseCanonicalFGA(input) {
     // changes. Per-layer / per-ref checks all reuse the FGCA implementation;
     // codes are remapped on the way out. FGCA-009 / 010 / 014 (changes-related)
     // are unreachable here because `changes` is empty.
-    const synth = { ...raw, notation: 'fgca', id: 'FGCA-FROM-FGA-1', changes: [] };
+    const synth = { ...raw, notation: 'dgca', id: 'DGCA-FROM-DGA-1', changes: [] };
     const r = parseCanonicalFGCA(synth);
     const remap = {
         'FGCA-001': 'FGA-001',

package/dist/fgca/preview-layout.d.ts

@@ -1,5 +1,5 @@
 import type { Scope } from '../scope.js';
-export type FGCAPreviewColumn = 'factor' | 'goal' | 'change' | 'activity';
+export type FGCAPreviewColumn = 'driver' | 'goal' | 'change' | 'activity';
 export interface FGCAPreviewFactor {
     id: number | string;
     name: string;

package/dist/fgca/preview-layout.js

@@ -52,11 +52,11 @@ export function layoutFGCAPreview(inputDoc, options = {}) {
     const doc = selectScopedFGCA(inputDoc, scope);
     const colStride = FGCA_NODE_W + colGap;
     const cols = hideChanges
-        ? ['factor', 'goal', 'activity']
-        : ['factor', 'goal', 'change', 'activity'];
+        ? ['driver', 'goal', 'activity']
+        : ['driver', 'goal', 'change', 'activity'];
     const changes = doc.changes ?? [];
     const colItems = {
-        factor: doc.factors.map(f => ({ id: `factor_${f.id}`, label: f.name })),
+        driver: doc.factors.map(f => ({ id: `driver_${f.id}`, label: f.name })),
         goal: doc.goals.map(g => ({ id: `goal_${g.id}`, label: g.name })),
         change: changes.map(c => ({ id: `change_${c.id}`, label: c.name })),
         activity: doc.activities.map(a => ({ id: `activity_${a.id}`, label: a.name })),
@@ -86,7 +86,7 @@ export function layoutFGCAPreview(inputDoc, options = {}) {
     }
     for (const g of doc.goals) {
         for (const f of (g.factor ?? []))
-            addEdge(`factor_${f.id}`, `goal_${g.id}`);
+            addEdge(`driver_${f.id}`, `goal_${g.id}`);
     }
     if (hideChanges) {
         const connectedViaChange = new Set();

package/dist/fgca/resolver.js

@@ -61,7 +61,9 @@ export function resolveFGCA(viewDoc, sources) {
     const factorsConf = isObject(vc['factors']) ? vc['factors'] : {};
     const changesConf = isObject(vc['changes']) ? vc['changes'] : {};
     const activitiesConf = isObject(vc['activities']) ? vc['activities'] : {};
-    const factorElems = collectByNotation(sources.elements, 'factor');
+    const factorElemsLegacy = collectByNotation(sources.elements, 'factor');
+    const factorElemsNew = collectByNotation(sources.elements, 'driver');
+    const factorElems = new Map([...factorElemsLegacy, ...factorElemsNew]);
     const goalElems = collectByNotation(sources.elements, 'goal');
     const changeElems = collectByNotation(sources.elements, 'change');
     const activityElems = collectByNotation(sources.elements, 'activity');

package/dist/fgca/types.d.ts

@@ -1,30 +1,30 @@
-export interface FactorItem {
-    id: number;
+export interface DriverItem {
+    id: number | string;
     name: string;
 }
 export interface GoalItem {
-    id: number;
+    id: number | string;
     name: string;
     level?: number;
     /** Goals may carry embedded factor links returned by the API. */
     factor?: Array<{
-        id: number;
+        id: number | string;
     }>;
 }
 export interface BdnChangeWithActivities {
-    id: number;
+    id: number | string;
     name: string;
-    goal_id: number;
-    activity_ids: number[];
+    goal_id: number | string;
+    activity_ids: Array<number | string>;
 }
 export interface ActivityItem {
-    id: number;
+    id: number | string;
     name: string;
-    goal_id?: number | null;
+    goal_id?: number | string | null;
     activity_type_id?: number;
 }
 export interface ActivityTypeItem {
-    id: number;
+    id: number | string;
     name?: string;
 }
 export interface DiagramStyle {
@@ -34,6 +34,6 @@ export interface DiagramStyle {
     edgeWidth?: number;
 }
 /** The four columns of the FGCA diagram. */
-export type FGCAColumn = "factor" | "goal" | "change" | "activity";
+export type FGCAColumn = "driver" | "goal" | "change" | "activity";
 export declare const ALL_FGCA_COLUMNS: FGCAColumn[];
 export declare const FGCA_COLUMN_LABELS: Record<FGCAColumn, string>;

package/dist/fgca/types.js

@@ -1,6 +1,6 @@
-export const ALL_FGCA_COLUMNS = ["factor", "goal", "change", "activity"];
+export const ALL_FGCA_COLUMNS = ["driver", "goal", "change", "activity"];
 export const FGCA_COLUMN_LABELS = {
-    factor: "F",
+    driver: "D",
     goal: "G",
     change: "C",
     activity: "A",

package/dist/fgca/validate.d.ts

@@ -1,4 +1,4 @@
-import type { FactorItem, GoalItem, BdnChangeWithActivities, ActivityItem } from './types.js';
+import type { DriverItem, GoalItem, BdnChangeWithActivities, ActivityItem } from './types.js';
 import type { ValidationError, ValidationWarning, ValidationResult } from '../validation-types.js';
 export type FGCAValidationError = ValidationError;
 export type FGCAValidationWarning = ValidationWarning;
@@ -6,7 +6,7 @@ export type FGCAValidationResult = ValidationResult;
 export interface FGCADoc {
     notation: string;
     spec_version?: string;
-    factors: FactorItem[];
+    factors: DriverItem[];
     goals: GoalItem[];
     changes: BdnChangeWithActivities[];
     activities: ActivityItem[];