@transitrix/diagrams 1.0.1 → 1.2.0

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

@@ -25,7 +25,7 @@ const doc: FGCAPreviewDoc = {
 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);
@@ -40,7 +40,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
@@ -70,7 +70,7 @@ describe('layoutFGCAPreview', () => {
 
   it('larger rowGap increases the gap between stacked nodes', () => {
     const gapOf = (rowGap: number) => {
-      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));
@@ -86,15 +86,15 @@ 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);
     });
 
@@ -112,7 +112,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", () => {

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

@@ -8,8 +8,8 @@ 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/src/fgca/__tests__/validate.test.ts

@@ -56,11 +56,11 @@ describe('validateFGCADoc', () => {
     expect(result.errors.some(e => e.path === 'changes')).toBe(true);
   });
 
-  it('errors when activities array is missing', () => {
+  it('errors when actions array is missing', () => {
     const { activities: _, ...without } = VALID_DOC;
     const result = validateFGCADoc({ ...without, notation: 'fgca' });
     expect(result.valid).toBe(false);
-    expect(result.errors.some(e => e.path === 'activities')).toBe(true);
+    expect(result.errors.some(e => e.path === 'actions')).toBe(true);
   });
 
   it('errors on empty factor name', () => {

package/src/fgca/chain-table.ts

@@ -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.
@@ -23,7 +23,7 @@
 
 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. */
@@ -76,8 +76,8 @@ function sameCell(a: ChainCell | null, b: ChainCell | null): boolean {
 export function buildChainTable(doc: FGCAPreviewDoc, options: ChainTableOptions = {}): ChainTable {
   const { hideChanges = false } = options;
   const columns: ChainColumn[] = 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));
@@ -146,7 +146,7 @@ export function buildChainTable(doc: FGCAPreviewDoc, options: ChainTableOptions
 
   // 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/src/fgca/index.ts

@@ -28,7 +28,7 @@ export {
   FGCA_COLUMN_LABELS,
 } from "./types";
 export type {
-  FactorItem,
+  DriverItem,
   GoalItem,
   BdnChangeWithActivities,
   ActivityItem,
@@ -38,10 +38,10 @@ export type {
 } 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";
 
 /** ReactFlow nodeTypes map — pass directly to <ReactFlow nodeTypes={FGCA_NODE_TYPES} /> */
-export { FGCA_NODE_TYPES } from "./nodeTypes";
+export { FGCA_NODE_TYPES } from "./nodeTypes";

package/src/fgca/layout.ts

@@ -1,7 +1,7 @@
 import type { Node, Edge } from "reactflow";
 import { Position, MarkerType } from "reactflow";
 import type {
-  FactorItem,
+  DriverItem,
   GoalItem,
   BdnChangeWithActivities,
   ActivityItem,
@@ -18,14 +18,14 @@ export const ROW_GAP = 24;
 
 /** Default background colours per column. */
 export const COLUMN_BG: Record<FGCAColumn, string> = {
-  factor: "#fef3c7",
+  driver: "#fef3c7",
   goal: "#e0e7ff",
   change: "#dbeafe",
   activity: "#d4edda",
 };
 
 export interface FGCALayoutInput {
-  factors: FactorItem[];
+  factors: DriverItem[];
   goals: GoalItem[];
   changes: BdnChangeWithActivities[];
   activities: ActivityItem[];
@@ -66,12 +66,12 @@ export function buildFGCALayout({
   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,
@@ -132,13 +132,13 @@ export function buildFGCALayout({
     });
   }
 
-  // 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/src/fgca/nodeTypes.ts

@@ -1,11 +1,11 @@
-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,
-} as const;
+} as const;

package/src/fgca/nodes/FGCAFactorNode.tsx

@@ -4,7 +4,7 @@ import { Handle, Position } from "reactflow";
 const NODE_WIDTH = 250;
 const NODE_HEIGHT = 80;
 
-export interface FGCAFactorNodeProps {
+export interface FGCADriverNodeProps {
   data: {
     id: number;
     name: string;
@@ -14,10 +14,10 @@ export interface FGCAFactorNodeProps {
   isConnectable?: boolean;
 }
 
-const FGCAFactorNode = memo(({ data, isConnectable }: FGCAFactorNodeProps) => (
+const FGCADriverNode = memo(({ data, isConnectable }: FGCADriverNodeProps) => (
   <div
     style={{
-      background: "var(--ts-layer-factor)",
+      background: "var(--ts-layer-driver)",
       width: NODE_WIDTH,
       height: NODE_HEIGHT,
       padding: "6px 8px",
@@ -54,11 +54,11 @@ const FGCAFactorNode = memo(({ data, isConnectable }: FGCAFactorNodeProps) => (
       {data.name}
     </div>
     <div style={{ fontSize: "10px", color: "var(--ts-text-secondary)", marginTop: 2 }}>
-      F-{String(data.id).padStart(4, "0")}
+      D-{String(data.id).padStart(4, "0")}
     </div>
   </div>
 ));
 
-FGCAFactorNode.displayName = "FGCAFactorNode";
+FGCADriverNode.displayName = "FGCADriverNode";
 
-export default FGCAFactorNode;
+export default FGCADriverNode;

package/src/fgca/parse-canonical.ts

@@ -27,7 +27,7 @@
 import type {
   ActivityItem,
   BdnChangeWithActivities,
-  FactorItem,
+  DriverItem,
   GoalItem,
 } from './types.js';
 import type { FGCADoc } from './validate.js';
@@ -46,10 +46,12 @@ export interface CanonicalFGCAResult extends ValidationResult {
 // 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: unknown): v is string {
@@ -84,18 +86,21 @@ export function parseCanonicalFGCA(input: unknown): CanonicalFGCAResult {
 
   const raw = input as Record<string, unknown>;
 
-  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).
@@ -117,12 +122,16 @@ export function parseCanonicalFGCA(input: unknown): CanonicalFGCAResult {
   const factorsRaw = asObjectArray(raw['factors']);
   const goalsRaw = asObjectArray(raw['goals']);
   const changesRaw = asObjectArray(raw['changes']);
-  const activitiesRaw = asObjectArray(raw['activities']);
+  // Accept canonical `actions:` or deprecated `activities:`; warn on the latter.
+  const activitiesRaw = asObjectArray(raw['actions']) ?? asObjectArray(raw['activities']);
+  if ('activities' in raw && !('actions' in raw)) {
+    warnings.push({ code: 'FGCA-001', message: '"activities" key is deprecated — rename to "actions"' });
+  }
 
   if (factorsRaw === null) errors.push({ code: 'FGCA-004', message: 'factors must be an array', path: 'factors' });
   if (goalsRaw === null) errors.push({ code: 'FGCA-004', message: 'goals must be an array', path: 'goals' });
   if (changesRaw === null) errors.push({ code: 'FGCA-004', message: 'changes must be an array', path: 'changes' });
-  if (activitiesRaw === null) errors.push({ code: 'FGCA-004', message: 'activities must be an array', path: 'activities' });
+  if (activitiesRaw === null) errors.push({ code: 'FGCA-004', message: 'actions must be an array', path: 'actions' });
 
   if (errors.length > 0) return { valid: false, errors, warnings };
 
@@ -173,7 +182,7 @@ export function parseCanonicalFGCA(input: unknown): CanonicalFGCAResult {
     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));
@@ -229,13 +238,13 @@ export function parseCanonicalFGCA(input: unknown): CanonicalFGCAResult {
   }
 
   // Layer entries (internal form).
-  const internalFactors: FactorItem[] = factors.map((el) => ({
+  const internalFactors: DriverItem[] = factors.map((el) => ({
     id: intId(String(el!['id'])),
     name: String(el!['name'] ?? ''),
   }));
 
   const internalGoals: GoalItem[] = 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'] ?? ''),
@@ -283,11 +292,13 @@ export function parseCanonicalFGCA(input: unknown): CanonicalFGCAResult {
   });
 
   const internalActivities: ActivityItem[] = activities.map((el, i) => {
-    const goalRefs = checkRefArray(el!, 'goals', goalIds, GOAL_ID_RE, 'FGCA-011', `activities[${i}]`);
+    const goalRefs = checkRefArray(el!, 'goals', goalIds, GOAL_ID_RE, 'FGCA-011', `actions[${i}]`);
+    const typeVal = typeof el!['type'] === 'string' ? el!['type'] : undefined;
     return {
       id: intId(String(el!['id'])),
       name: String(el!['name'] ?? ''),
       goal_id: goalRefs.length > 0 ? intId(goalRefs[0]) : null,
+      ...(typeVal !== undefined ? { type: typeVal } : {}),
     };
   });
 
@@ -313,7 +324,7 @@ export function parseCanonicalFGCA(input: unknown): CanonicalFGCAResult {
   if (errors.length > 0) return { valid: false, errors, warnings };
 
   const parsed: FGCADoc = {
-    notation: 'fgca',
+    notation: (raw['notation'] as string) ?? 'dgca',
     spec_version: typeof raw['spec_version'] === 'string' ? (raw['spec_version'] as string) : undefined,
     factors: internalFactors,
     goals: internalGoals,
@@ -324,7 +335,7 @@ export function parseCanonicalFGCA(input: unknown): CanonicalFGCAResult {
   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+$/;
 
 /** On success, the internal-form FGCADoc derived from canonical FGA input. */
 export interface CanonicalFGAResult extends ValidationResult {
@@ -353,10 +364,10 @@ export function parseCanonicalFGA(input: unknown): CanonicalFGAResult {
     return { valid: false, errors: [{ code: 'FGA-001', message: 'document root is not an object' }], warnings: [] };
   }
   const raw = input as Record<string, unknown>;
-  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: [],
     };
   }
@@ -375,7 +386,7 @@ export function parseCanonicalFGA(input: unknown): CanonicalFGAResult {
   // 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: Record<string, string> = {
     'FGCA-001': 'FGA-001',

package/src/fgca/preview-layout.ts

@@ -9,7 +9,7 @@
 
 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;
@@ -144,11 +144,11 @@ export function layoutFGCAPreview(
 
   const colStride = FGCA_NODE_W + colGap;
   const cols: FGCAPreviewColumn[] = hideChanges
-    ? ['factor', 'goal', 'activity']
-    : ['factor', 'goal', 'change', 'activity'];
+    ? ['driver', 'goal', 'activity']
+    : ['driver', 'goal', 'change', 'activity'];
   const changes = doc.changes ?? [];
   const colItems: Record<FGCAPreviewColumn, Array<{ id: string; label: string }>> = {
-    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 })),
@@ -180,7 +180,7 @@ export function layoutFGCAPreview(
   }
 
   for (const g of doc.goals) {
-    for (const f of (g.factor ?? [])) addEdge(`factor_${f.id}`, `goal_${g.id}`);
+    for (const f of (g.factor ?? [])) addEdge(`driver_${f.id}`, `goal_${g.id}`);
   }
   if (hideChanges) {
     const connectedViaChange = new Set<number | string>();

package/src/fgca/resolver.ts

@@ -86,7 +86,9 @@ export function resolveFGCA(
   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/src/fgca/types.ts

@@ -1,32 +1,34 @@
-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 }>;
+  factor?: Array<{ 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;
+  /** Canonical values: initiative | programme | project | work_package. Unknown values pass through without error. */
+  type?: string;
 }
 
 export interface ActivityTypeItem {
-  id: number;
+  id: number | string;
   name?: string;
 }
 
@@ -38,12 +40,12 @@ export interface DiagramStyle {
 }
 
 /** The four columns of the FGCA diagram. */
-export type FGCAColumn = "factor" | "goal" | "change" | "activity";
+export type FGCAColumn = "driver" | "goal" | "change" | "activity";
 
-export const ALL_FGCA_COLUMNS: FGCAColumn[] = ["factor", "goal", "change", "activity"];
+export const ALL_FGCA_COLUMNS: FGCAColumn[] = ["driver", "goal", "change", "activity"];
 
 export const FGCA_COLUMN_LABELS: Record<FGCAColumn, string> = {
-  factor: "F",
+  driver: "D",
   goal: "G",
   change: "C",
   activity: "A",

package/src/fgca/validate.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,
@@ -15,7 +15,7 @@ export type FGCAValidationResult = ValidationResult;
 export interface FGCADoc {
   notation: string;
   spec_version?: string;
-  factors: FactorItem[];
+  factors: DriverItem[];
   goals: GoalItem[];
   changes: BdnChangeWithActivities[];
   activities: ActivityItem[];
@@ -35,31 +35,42 @@ export function validateFGCADoc(input: unknown): FGCAValidationResult {
     errors.push({ code: 'MISSING_NOTATION', message: 'notation field is required' });
     return { valid: false, errors, warnings };
   }
-  if (raw.notation !== 'fgca') {
-    errors.push({ code: 'WRONG_NOTATION', message: `notation must be "fgca", got "${String(raw.notation)}"` });
+  if (raw.notation !== 'fgca' && raw.notation !== 'dgca') {
+    errors.push({ code: 'WRONG_NOTATION', message: `notation must be "dgca" (or legacy "fgca"), got "${String(raw.notation)}"` });
     return { valid: false, errors, warnings };
   }
+  if (raw.notation === 'fgca') {
+    warnings.push({ code: 'DEPRECATED_NOTATION', message: 'notation "fgca" is deprecated — rename to "dgca"' });
+  }
 
   if (!Array.isArray(raw.factors)) errors.push({ code: 'SCHEMA_INVALID', message: 'factors must be an array', path: 'factors' });
   if (!Array.isArray(raw.goals)) errors.push({ code: 'SCHEMA_INVALID', message: 'goals must be an array', path: 'goals' });
   if (!Array.isArray(raw.changes)) errors.push({ code: 'SCHEMA_INVALID', message: 'changes must be an array', path: 'changes' });
-  if (!Array.isArray(raw.activities)) errors.push({ code: 'SCHEMA_INVALID', message: 'activities must be an array', path: 'activities' });
+  // Accept canonical `actions:` or deprecated `activities:`; warn on the latter.
+  const hasActions = Array.isArray(raw.actions);
+  const hasActivities = Array.isArray(raw.activities);
+  if (!hasActions && !hasActivities) {
+    errors.push({ code: 'SCHEMA_INVALID', message: 'actions must be an array', path: 'actions' });
+  } else if ('activities' in raw) {
+    warnings.push({ code: 'DEPRECATED_NOTATION', message: '"activities" key is deprecated — rename to "actions"' });
+  }
   if (errors.length > 0) return { valid: false, errors, warnings };
 
+  const actionsArr = (hasActions ? raw.actions : raw.activities) as unknown[];
   const doc = raw as unknown as FGCADoc;
-  const collectIds = (arr: unknown[]): Set<number> => {
-    const out = new Set<number>();
+  const collectIds = (arr: unknown[]): Set<number | string> => {
+    const out = new Set<number | string>();
     for (const el of arr) {
       if (el && typeof el === 'object') {
         const id = (el as { id?: unknown }).id;
-        if (typeof id === 'number') out.add(id);
+        if (typeof id === 'number' || typeof id === 'string') out.add(id);
       }
     }
     return out;
   };
   const factorIds = collectIds(doc.factors as unknown as unknown[]);
   const goalIds = collectIds(doc.goals as unknown as unknown[]);
-  const activityIds = collectIds(doc.activities as unknown as unknown[]);
+  const activityIds = collectIds(actionsArr);
 
   for (let i = 0; i < doc.factors.length; i++) {
     const f = doc.factors[i] as unknown;
@@ -68,7 +79,7 @@ export function validateFGCADoc(input: unknown): FGCAValidationResult {
       continue;
     }
     const factor = f as { id?: unknown; name?: unknown };
-    if (typeof factor.id !== 'number') errors.push({ code: 'SCHEMA_INVALID', message: 'factor id must be a number', path: `factors[${i}]` });
+    if (typeof factor.id !== 'number' && typeof factor.id !== 'string') errors.push({ code: 'SCHEMA_INVALID', message: 'factor id must be a number or string', path: `factors[${i}]` });
     if (typeof factor.name !== 'string' || !factor.name.trim()) errors.push({ code: 'EMPTY_NAME', message: `Factor ${String(factor.id)} has empty name`, path: `factors[${i}]` });
   }
 
@@ -79,13 +90,13 @@ export function validateFGCADoc(input: unknown): FGCAValidationResult {
       continue;
     }
     const goal = g as { id?: unknown; name?: unknown; factor?: unknown };
-    if (typeof goal.id !== 'number') errors.push({ code: 'SCHEMA_INVALID', message: 'goal id must be a number', path: `goals[${i}]` });
+    if (typeof goal.id !== 'number' && typeof goal.id !== 'string') errors.push({ code: 'SCHEMA_INVALID', message: 'goal id must be a number or string', path: `goals[${i}]` });
     if (typeof goal.name !== 'string' || !goal.name.trim()) errors.push({ code: 'EMPTY_NAME', message: `Goal ${String(goal.id)} has empty name`, path: `goals[${i}]` });
     const factorRefs = Array.isArray(goal.factor) ? (goal.factor as unknown[]) : [];
     for (const fr of factorRefs) {
       if (!fr || typeof fr !== 'object') continue;
       const fid = (fr as { id?: unknown }).id;
-      if (typeof fid === 'number' && !factorIds.has(fid)) {
+      if ((typeof fid === 'number' || typeof fid === 'string') && !factorIds.has(fid)) {
         warnings.push({ code: 'BROKEN_REF', message: `Goal ${String(goal.id)} references missing factor ${fid}`, path: `goals[${i}].factor` });
       }
     }
@@ -98,28 +109,28 @@ export function validateFGCADoc(input: unknown): FGCAValidationResult {
       continue;
     }
     const change = c as { id?: unknown; name?: unknown; goal_id?: unknown; activity_ids?: unknown };
-    if (typeof change.id !== 'number') errors.push({ code: 'SCHEMA_INVALID', message: 'change id must be a number', path: `changes[${i}]` });
+    if (typeof change.id !== 'number' && typeof change.id !== 'string') errors.push({ code: 'SCHEMA_INVALID', message: 'change id must be a number or string', path: `changes[${i}]` });
     if (typeof change.name !== 'string' || !change.name.trim()) errors.push({ code: 'EMPTY_NAME', message: `Change ${String(change.id)} has empty name`, path: `changes[${i}]` });
-    if (typeof change.goal_id === 'number' && !goalIds.has(change.goal_id)) {
+    if ((typeof change.goal_id === 'number' || typeof change.goal_id === 'string') && !goalIds.has(change.goal_id)) {
       warnings.push({ code: 'BROKEN_REF', message: `Change ${String(change.id)} references missing goal ${change.goal_id}`, path: `changes[${i}].goal_id` });
     }
     const aids = Array.isArray(change.activity_ids) ? (change.activity_ids as unknown[]) : [];
     for (const aid of aids) {
-      if (typeof aid === 'number' && !activityIds.has(aid)) {
+      if ((typeof aid === 'number' || typeof aid === 'string') && !activityIds.has(aid)) {
         warnings.push({ code: 'BROKEN_REF', message: `Change ${String(change.id)} references missing activity ${aid}`, path: `changes[${i}].activity_ids` });
       }
     }
   }
 
-  for (let i = 0; i < doc.activities.length; i++) {
-    const a = doc.activities[i] as unknown;
+  for (let i = 0; i < actionsArr.length; i++) {
+    const a = actionsArr[i];
     if (!a || typeof a !== 'object') {
-      errors.push({ code: 'SCHEMA_INVALID', message: 'activity entry must be an object', path: `activities[${i}]` });
+      errors.push({ code: 'SCHEMA_INVALID', message: 'action entry must be an object', path: `actions[${i}]` });
       continue;
     }
-    const activity = a as { id?: unknown; name?: unknown };
-    if (typeof activity.id !== 'number') errors.push({ code: 'SCHEMA_INVALID', message: 'activity id must be a number', path: `activities[${i}]` });
-    if (typeof activity.name !== 'string' || !activity.name.trim()) errors.push({ code: 'EMPTY_NAME', message: `Activity ${String(activity.id)} has empty name`, path: `activities[${i}]` });
+    const action = a as { id?: unknown; name?: unknown };
+    if (typeof action.id !== 'number' && typeof action.id !== 'string') errors.push({ code: 'SCHEMA_INVALID', message: 'action id must be a number or string', path: `actions[${i}]` });
+    if (typeof action.name !== 'string' || !action.name.trim()) errors.push({ code: 'EMPTY_NAME', message: `Action ${String(action.id)} has empty name`, path: `actions[${i}]` });
   }
 
   return { valid: errors.length === 0, errors, warnings };

package/src/process-blueprint/index.ts

@@ -1,5 +1,6 @@
 export type {
   AspectCategory,
+  RowId,
   Stage,
   AspectEntry,
   LaneConfig,