@transitrix/diagrams 1.2.0 → 1.4.0

package/dist/fgca/__tests__/parse-canonical.test.js

@@ -4,7 +4,7 @@ import * as path from 'node:path';
 import yaml from 'js-yaml';
 import { parseCanonicalFGCA, parseCanonicalFGA } from '../parse-canonical.js';
 const VALID = {
-    notation: 'fgca',
+    notation: 'dgca',
     spec_version: '0.1',
     id: 'FGCA-SAMPLE-1',
     name: 'Sample FGCA chain',
@@ -17,7 +17,7 @@ const VALID = {
     changes: [
         { id: 'CHANGE-1', name: 'Transformation', goals: ['GOAL-1'] },
     ],
-    activities: [
+    actions: [
         { id: 'ACTIVITY-1', name: 'Workstream', changes: ['CHANGE-1'] },
     ],
 };
@@ -96,7 +96,7 @@ describe('parseCanonicalFGCA', () => {
     it('FGCA-010: rejects activity.changes[] referencing undefined change', () => {
         const r = parseCanonicalFGCA({
             ...VALID,
-            activities: [{ id: 'ACTIVITY-1', name: 'A', changes: ['CHANGE-99'] }],
+            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);
@@ -120,7 +120,7 @@ describe('parseCanonicalFGCA', () => {
         const r = parseCanonicalFGCA({
             ...VALID,
             changes: [{ id: 'CHANGE-1', name: 'C', goals: ['GOAL-1'] }],
-            activities: [
+            actions: [
                 { id: 'ACTIVITY-1', name: 'A1', changes: ['CHANGE-1'] },
                 { id: 'ACTIVITY-2', name: 'A2', changes: ['CHANGE-1'] },
             ],
@@ -143,19 +143,32 @@ describe('parseCanonicalFGCA — edge-driving fields populated', () => {
         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: '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'] }],
-        activities: [{ id: 'ACTIVITY-1', name: 'Workstream', goals: ['GOAL-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);
@@ -192,12 +205,12 @@ describe('parseCanonicalFGA', () => {
     });
 });
 describe('parseCanonicalFGCA — example file regression', () => {
-    const EXAMPLES_DIR = path.resolve(process.cwd(), '..', '..', 'tests', 'fixtures', 'notation-corpus', 'fgca');
+    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/fgca/${file}`, () => {
+        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);
@@ -207,18 +220,18 @@ describe('parseCanonicalFGCA — example file regression', () => {
     }
 });
 describe('parseCanonicalFGA — example file regression', () => {
-    const EXAMPLES_DIR = path.resolve(process.cwd(), '..', '..', 'tests', 'fixtures', 'notation-corpus', 'fga');
+    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/fga/${file} and resolves every activity to a goal`, () => {
+        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)).toBe(true);
+            expect(r.parsed.activities.every((a) => a.goal_id != null && a.goal_id !== 0 && a.goal_id !== '')).toBe(true);
         });
     }
 });

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

@@ -22,7 +22,7 @@ const ELEMENTS = [
 ];
 const SOURCES = { elements: ELEMENTS, relations: [] };
 const VIEW_DOC = {
-    notation: 'fgca',
+    notation: 'dgca',
     id: 'FGCA-STRAT-1',
     name: 'Strategy 2026 — FGCA chain',
     spec_version: '0.1',
@@ -40,7 +40,7 @@ describe('isFGCAViewDoc', () => {
     });
     it('returns false for an inline doc with factors/goals arrays', () => {
         expect(isFGCAViewDoc({
-            notation: 'fgca', id: 'FGCA-1', name: 'x',
+            notation: 'dgca', id: 'FGCA-1', name: 'x',
             factors: [], goals: [], changes: [], activities: [],
         })).toBe(false);
     });
@@ -56,7 +56,7 @@ describe('resolveFGCA — goals.filter=all', () => {
         const doc = resolveFGCA(VIEW_DOC, SOURCES);
         expect(doc['goals'].length).toBe(3);
         expect(doc['changes'].length).toBe(3);
-        expect(doc['activities'].length).toBe(5);
+        expect(doc['actions'].length).toBe(5);
     });
     it('derives factors from all goal.factors[] refs', () => {
         const doc = resolveFGCA(VIEW_DOC, SOURCES);
@@ -77,7 +77,7 @@ describe('resolveFGCA — goals.filter=all', () => {
     });
     it('carries view doc metadata (id, name, spec_version)', () => {
         const doc = resolveFGCA(VIEW_DOC, SOURCES);
-        expect(doc['notation']).toBe('fgca');
+        expect(doc['notation']).toBe('dgca');
         expect(doc['id']).toBe('FGCA-STRAT-1');
         expect(doc['name']).toBe('Strategy 2026 — FGCA chain');
         expect(doc['spec_version']).toBe('0.1');
@@ -95,7 +95,7 @@ describe('resolveFGCA — goals.filter=ids', () => {
         expect(goalIds).toEqual(['GOAL-1']);
         const changeIds = doc['changes'].map((c) => c.id);
         expect(changeIds).toEqual(['CHANGE-1']);
-        const actIds = doc['activities'].map((a) => a.id).sort();
+        const actIds = doc['actions'].map((a) => a.id).sort();
         expect(actIds).toEqual(['ACTIVITY-1', 'ACTIVITY-2']);
         const r = parseCanonicalFGCA(doc);
         expect(r.valid).toBe(true);
@@ -138,7 +138,7 @@ describe('resolveFGCA — empty sources', () => {
         expect(doc['goals'].length).toBe(0);
         expect(doc['factors'].length).toBe(0);
         expect(doc['changes'].length).toBe(0);
-        expect(doc['activities'].length).toBe(0);
+        expect(doc['actions'].length).toBe(0);
     });
     it('returns empty arrays for a non-object viewDoc', () => {
         const doc = resolveFGCA(null, SOURCES);
@@ -147,7 +147,7 @@ describe('resolveFGCA — empty sources', () => {
 });
 // ── File-based regression — resolver + canon fixture + parseCanonicalFGCA ─────
 describe('resolveFGCA — file-based regression against canon fixture', () => {
-    const CANON_ROOT = path.resolve(process.cwd(), '..', '..', 'tests', 'fixtures', 'notation-corpus', 'fgca', 'canon');
+    const CANON_ROOT = path.resolve(process.cwd(), '..', '..', 'tests', 'fixtures', 'notation-corpus', 'dgca', 'canon');
     const VIEW_DIR = path.join(CANON_ROOT, 'views');
     const ELEM_DIR = path.join(CANON_ROOT, 'elements');
     function loadYamlsUnder(dir) {

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

@@ -1,11 +1,11 @@
 import { describe, it, expect } from 'vitest';
 import { validateFGCADoc } from '../validate.js';
 const VALID_DOC = {
-    notation: 'fgca',
+    notation: 'dgca',
     factors: [{ id: 1, name: 'Market pressure' }],
     goals: [{ id: 1, name: 'Grow revenue', factor: [{ id: 1 }] }],
     changes: [{ id: 1, name: 'Launch product', goal_id: 1, activity_ids: [1] }],
-    activities: [{ id: 1, name: 'Market research', goal_id: 1 }],
+    actions: [{ id: 1, name: 'Market research', goal_id: 1 }],
 };
 describe('validateFGCADoc', () => {
     it('accepts a valid document', () => {
@@ -31,25 +31,25 @@ describe('validateFGCADoc', () => {
     });
     it('errors when factors array is missing', () => {
         const { factors: _, ...without } = VALID_DOC;
-        const result = validateFGCADoc({ ...without, notation: 'fgca' });
+        const result = validateFGCADoc({ ...without, notation: 'dgca' });
         expect(result.valid).toBe(false);
         expect(result.errors.some(e => e.path === 'factors')).toBe(true);
     });
     it('errors when goals array is missing', () => {
         const { goals: _, ...without } = VALID_DOC;
-        const result = validateFGCADoc({ ...without, notation: 'fgca' });
+        const result = validateFGCADoc({ ...without, notation: 'dgca' });
         expect(result.valid).toBe(false);
         expect(result.errors.some(e => e.path === 'goals')).toBe(true);
     });
     it('errors when changes array is missing', () => {
         const { changes: _, ...without } = VALID_DOC;
-        const result = validateFGCADoc({ ...without, notation: 'fgca' });
+        const result = validateFGCADoc({ ...without, notation: 'dgca' });
         expect(result.valid).toBe(false);
         expect(result.errors.some(e => e.path === 'changes')).toBe(true);
     });
     it('errors when actions array is missing', () => {
-        const { activities: _, ...without } = VALID_DOC;
-        const result = validateFGCADoc({ ...without, notation: 'fgca' });
+        const { actions: _, ...without } = VALID_DOC;
+        const result = validateFGCADoc({ ...without, notation: 'dgca' });
         expect(result.valid).toBe(false);
         expect(result.errors.some(e => e.path === 'actions')).toBe(true);
     });
@@ -89,11 +89,11 @@ describe('validateFGCADoc', () => {
     });
     it('accepts a document with empty arrays', () => {
         const result = validateFGCADoc({
-            notation: 'fgca',
+            notation: 'dgca',
             factors: [],
             goals: [],
             changes: [],
-            activities: [],
+            actions: [],
         });
         expect(result.valid).toBe(true);
     });
@@ -117,8 +117,8 @@ describe('validateFGCADoc', () => {
         expect(r.valid).toBe(false);
         expect(r.errors.some(e => e.code === 'SCHEMA_INVALID')).toBe(true);
     });
-    it('[blocker] tolerates a null element in activities[] without throwing', () => {
-        const r = validateFGCADoc({ ...VALID_DOC, activities: [null] });
+    it('[blocker] tolerates a null element in actions[] without throwing', () => {
+        const r = validateFGCADoc({ ...VALID_DOC, actions: [null] });
         expect(r.valid).toBe(false);
         expect(r.errors.some(e => e.code === 'SCHEMA_INVALID')).toBe(true);
     });

package/dist/fgca/parse-canonical.js

@@ -57,21 +57,18 @@ export function parseCanonicalFGCA(input) {
         };
     }
     const raw = input;
-    if ('notation' in raw && raw['notation'] !== 'fgca' && raw['notation'] !== 'dgca') {
+    if ('notation' in raw && raw['notation'] !== 'dgca') {
         return {
             valid: false,
             errors: [
                 {
                     code: 'FGCA-001',
-                    message: `notation must be "dgca" (or legacy "fgca"), got "${String(raw['notation'])}"`,
+                    message: `notation must be "dgca", 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) {
@@ -91,10 +88,9 @@ export function parseCanonicalFGCA(input) {
     const factorsRaw = asObjectArray(raw['factors']);
     const goalsRaw = asObjectArray(raw['goals']);
     const changesRaw = asObjectArray(raw['changes']);
-    // 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"' });
+    const activitiesRaw = asObjectArray(raw['actions']);
+    if (activitiesRaw === null && 'activities' in raw) {
+        errors.push({ code: 'FGCA-004', message: '"activities" key is not accepted — rename to "actions"', path: 'actions' });
     }
     if (factorsRaw === null)
         errors.push({ code: 'FGCA-004', message: 'factors must be an array', path: 'factors' });
@@ -179,29 +175,19 @@ export function parseCanonicalFGCA(input) {
         }
         return out;
     }
-    // Build internal id-maps (canonical string ID → internal sequential number).
-    const idMap = { toInternal: new Map() };
-    const allCanonicalIds = [...factorIds, ...goalIds, ...changeIds, ...activityIds];
-    allCanonicalIds.forEach((id, i) => idMap.toInternal.set(id, i + 1));
-    function intId(canonical) {
-        const n = idMap.toInternal.get(canonical);
-        if (n === undefined) {
-            // Shouldn't happen — we built the map from the same sets.
-            throw new Error(`internal: canonical id "${canonical}" not mapped`);
-        }
-        return n;
-    }
-    // Layer entries (internal form).
+    // Layer entries (internal form). Canonical string IDs are passed through
+    // directly — no conversion to sequential numbers. The layout and renderer
+    // treat IDs as opaque keys and also display them verbatim to the user.
     const internalFactors = factors.map((el) => ({
-        id: intId(String(el['id'])),
+        id: String(el['id']),
         name: String(el['name'] ?? ''),
     }));
     const internalGoals = goals.map((el, i) => {
         const refIds = checkRefArray(el, 'factors', factorIds, FACTOR_OR_DRIVER_ID_RE, 'FGCA-008', `goals[${i}]`);
         return {
-            id: intId(String(el['id'])),
+            id: String(el['id']),
             name: String(el['name'] ?? ''),
-            factor: refIds.map((r) => ({ id: intId(r) })),
+            factor: refIds.map((r) => ({ id: r })),
         };
     });
     // Build a reverse mapping: which changes does each activity reference (via
@@ -234,19 +220,19 @@ export function parseCanonicalFGCA(input) {
         const canonicalChangeId = String(el['id']);
         const linkedActivityIds = activitiesForChange.get(canonicalChangeId) ?? [];
         return {
-            id: intId(canonicalChangeId),
+            id: canonicalChangeId,
             name: String(el['name'] ?? ''),
-            goal_id: goalRefs.length > 0 ? intId(goalRefs[0]) : 0,
-            activity_ids: linkedActivityIds.map((aid) => intId(aid)),
+            goal_id: goalRefs.length > 0 ? goalRefs[0] : '',
+            activity_ids: linkedActivityIds,
         };
     });
     const internalActivities = activities.map((el, 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'])),
+            id: String(el['id']),
             name: String(el['name'] ?? ''),
-            goal_id: goalRefs.length > 0 ? intId(goalRefs[0]) : null,
+            goal_id: goalRefs.length > 0 ? goalRefs[0] : null,
             ...(typeVal !== undefined ? { type: typeVal } : {}),
         };
     });
@@ -304,10 +290,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' && raw['notation'] !== 'dga') {
+    if ('notation' in raw && raw['notation'] !== 'dga') {
         return {
             valid: false,
-            errors: [{ code: 'FGA-001', message: `notation must be "dga" (or legacy "fga"), got "${String(raw['notation'])}"` }],
+            errors: [{ code: 'FGA-001', message: `notation must be "dga", got "${String(raw['notation'])}"` }],
             warnings: [],
         };
     }

package/dist/fgca/preview-layout.js

@@ -61,18 +61,67 @@ export function layoutFGCAPreview(inputDoc, options = {}) {
         change: changes.map(c => ({ id: `change_${c.id}`, label: c.name })),
         activity: doc.activities.map(a => ({ id: `activity_${a.id}`, label: a.name })),
     };
+    // Build predecessor map: for each node, which node IDs in the previous column
+    // connect to it from the left. Used for barycenter crossing minimization.
+    const predecessors = new Map();
+    for (const g of doc.goals) {
+        predecessors.set(`goal_${g.id}`, (g.factor ?? []).map(f => `driver_${f.id}`));
+    }
+    if (!hideChanges) {
+        for (const c of changes) {
+            predecessors.set(`change_${c.id}`, [`goal_${c.goal_id}`]);
+        }
+        const coveredActs = new Set(changes.flatMap(c => c.activity_ids.map(String)));
+        for (const a of doc.activities) {
+            const preds = changes
+                .filter(c => c.activity_ids.map(String).includes(String(a.id)))
+                .map(c => `change_${c.id}`);
+            if (a.goal_id != null && !coveredActs.has(String(a.id)))
+                preds.push(`goal_${a.goal_id}`);
+            predecessors.set(`activity_${a.id}`, preds);
+        }
+    }
+    else {
+        const connectedViaChange = new Set();
+        for (const c of changes) {
+            for (const aid of c.activity_ids) {
+                predecessors.set(`activity_${aid}`, [`goal_${c.goal_id}`]);
+                connectedViaChange.add(String(aid));
+            }
+        }
+        for (const a of doc.activities) {
+            if (a.goal_id != null && !connectedViaChange.has(String(a.id))) {
+                predecessors.set(`activity_${a.id}`, [`goal_${a.goal_id}`]);
+            }
+        }
+    }
+    // Sort a column's items by the barycenter of their predecessors' y-centres.
+    // Nodes with no predecessors sort last (Infinity barycenter) so they don't
+    // displace connected nodes.
+    function barycentricSort(items, yCenters) {
+        return [...items].sort((a, b) => {
+            const pA = (predecessors.get(a.id) ?? []).map(p => yCenters.get(p) ?? 0).filter(v => v > 0);
+            const pB = (predecessors.get(b.id) ?? []).map(p => yCenters.get(p) ?? 0).filter(v => v > 0);
+            const bcA = pA.length > 0 ? pA.reduce((s, v) => s + v, 0) / pA.length : Infinity;
+            const bcB = pB.length > 0 ? pB.reduce((s, v) => s + v, 0) / pB.length : Infinity;
+            return bcA - bcB;
+        });
+    }
     const nodeMap = new Map();
     const nodes = [];
     const columns = [];
+    const yCenters = new Map(); // nodeId → y + FGCA_NODE_H / 2
     for (let ci = 0; ci < cols.length; ci++) {
         const col = cols[ci];
         const x = FGCA_PAD + ci * colStride;
         columns.push({ col, x });
+        const items = ci === 0 ? colItems[col] : barycentricSort(colItems[col], yCenters);
         let y = FGCA_PAD + FGCA_HEADER_H + rowGap;
-        for (const item of colItems[col]) {
+        for (const item of items) {
             const node = { id: item.id, x, y, label: item.label, col };
             nodes.push(node);
             nodeMap.set(item.id, node);
+            yCenters.set(item.id, y + FGCA_NODE_H / 2);
             y += FGCA_NODE_H + rowGap;
         }
     }

package/dist/fgca/resolver.d.ts

@@ -3,7 +3,7 @@
  * view_config projection and a canon element/relation store (VP-3).
  *
  * Output shape matches the flat form that `parseCanonicalFGCA` expects:
- * top-level `factors[]`, `goals[]`, `changes[]`, `activities[]` with typed
+ * top-level `factors[]`, `goals[]`, `changes[]`, `actions[]` with typed
  * string IDs.  Filesystem-free — callable from unit tests without vscode.
  */
 export interface FGCAViewConfig {
@@ -43,7 +43,7 @@ export declare function isFGCAViewDoc(parsed: unknown): boolean;
  * to pass to `parseCanonicalFGCA`.
  *
  * Cross-reference fields (`goal.factors[]`, `change.goals[]`,
- * `activity.changes[]`) are carried from the canon elements unchanged; the
+ * `action.changes[]`) are carried from the canon elements unchanged; the
  * resolver decides which elements to include, not how they are shaped.
  */
 export declare function resolveFGCA(viewDoc: unknown, sources: FGCACanonSources): Record<string, unknown>;

package/dist/fgca/resolver.js

@@ -3,7 +3,7 @@
  * view_config projection and a canon element/relation store (VP-3).
  *
  * Output shape matches the flat form that `parseCanonicalFGCA` expects:
- * top-level `factors[]`, `goals[]`, `changes[]`, `activities[]` with typed
+ * top-level `factors[]`, `goals[]`, `changes[]`, `actions[]` with typed
  * string IDs.  Filesystem-free — callable from unit tests without vscode.
  */
 function isObject(v) {
@@ -49,12 +49,12 @@ export function isFGCAViewDoc(parsed) {
  * to pass to `parseCanonicalFGCA`.
  *
  * Cross-reference fields (`goal.factors[]`, `change.goals[]`,
- * `activity.changes[]`) are carried from the canon elements unchanged; the
+ * `action.changes[]`) are carried from the canon elements unchanged; the
  * resolver decides which elements to include, not how they are shaped.
  */
 export function resolveFGCA(viewDoc, sources) {
     if (!isObject(viewDoc)) {
-        return { notation: 'fgca', factors: [], goals: [], changes: [], activities: [] };
+        return { notation: 'dgca', factors: [], goals: [], changes: [], actions: [] };
     }
     const vc = isObject(viewDoc['view_config']) ? viewDoc['view_config'] : {};
     const goalsConf = isObject(vc['goals']) ? vc['goals'] : {};
@@ -114,13 +114,13 @@ export function resolveFGCA(viewDoc, sources) {
             strArray(a['goals']).some((gid) => selectedGoalIds.has(gid)));
     }
     return {
-        notation: 'fgca',
+        notation: 'dgca',
         id: viewDoc['id'],
         name: viewDoc['name'],
         spec_version: viewDoc['spec_version'],
         factors: selectedFactors,
         goals: selectedGoals,
         changes: selectedChanges,
-        activities: selectedActivities,
+        actions: selectedActivities,
     };
 }

package/dist/fgca/validate.js

@@ -9,31 +9,22 @@ export function validateFGCADoc(input) {
         errors.push({ code: 'MISSING_NOTATION', message: 'notation field is required' });
         return { valid: false, errors, warnings };
     }
-    if (raw.notation !== 'fgca' && raw.notation !== 'dgca') {
-        errors.push({ code: 'WRONG_NOTATION', message: `notation must be "dgca" (or legacy "fgca"), got "${String(raw.notation)}"` });
+    if (raw.notation !== 'dgca') {
+        errors.push({ code: 'WRONG_NOTATION', message: `notation must be "dgca", 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' });
-    // 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) {
+    if (!Array.isArray(raw.actions)) {
         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);
+    const actionsArr = raw.actions;
     const doc = raw;
     const collectIds = (arr) => {
         const out = new Set();

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 export * from "./activities/index";
 export * from "./activity-card/index";
 export * from "./actor/index";
+export * from "./business-service/index";
 export * from "./geometry";
 export * from "./applications/index";
 export * from "./assertion/index";
@@ -13,6 +14,9 @@ export * from "./confidence/index";
 export * from "./factor/index";
 export * from "./fgca/index";
 export * from "./goals/index";
+export * from "./integration/index";
+export * from "./location/index";
+export * from "./node/index";
 export * from "./process-blueprint/index";
 export * from "./process-map/index";
 export * from "./products/index";
@@ -21,6 +25,7 @@ export * from "./requirement/index";
 export * from "./scenarios/index";
 export * from "./stakeholder/index";
 export * from "./target-state/index";
+export * from "./technology-service/index";
 export { SCHEMA_VERSION } from "./schema-version";
 export * from "./theme/index";
 export * from "./typed-id";

package/dist/index.js

@@ -1,6 +1,7 @@
 export * from "./activities/index";
 export * from "./activity-card/index";
 export * from "./actor/index";
+export * from "./business-service/index";
 export * from "./geometry";
 export * from "./applications/index";
 export * from "./assertion/index";
@@ -13,6 +14,9 @@ export * from "./confidence/index";
 export * from "./factor/index";
 export * from "./fgca/index";
 export * from "./goals/index";
+export * from "./integration/index";
+export * from "./location/index";
+export * from "./node/index";
 export * from "./process-blueprint/index";
 export * from "./process-map/index";
 export * from "./products/index";
@@ -21,6 +25,7 @@ export * from "./requirement/index";
 export * from "./scenarios/index";
 export * from "./stakeholder/index";
 export * from "./target-state/index";
+export * from "./technology-service/index";
 export { SCHEMA_VERSION } from "./schema-version";
 export * from "./theme/index";
 export * from "./typed-id";

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

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