@transitrix/diagrams 1.2.0 → 1.4.0

package/dist/__tests__/yaml-normalize.test.js

@@ -54,8 +54,8 @@ describe('coerceDatesToIsoStrings', () => {
 describe('coerceDatesToIsoStrings — js-yaml integration', () => {
     it('quoted ISO dates are preserved untouched', () => {
         const text = [
-            'notation: activities',
-            'activities:',
+            'notation: action',
+            'actions:',
             '  - id: "A-001"',
             '    name: "Quoted dates"',
             '    duration: 3',
@@ -65,15 +65,15 @@ describe('coerceDatesToIsoStrings — js-yaml integration', () => {
         ].join('\n');
         const parsed = yaml.load(text);
         coerceDatesToIsoStrings(parsed);
-        expect(parsed.activities[0].start_date).toBe('2026-06-01');
-        expect(parsed.activities[0].end_date).toBe('2026-06-03');
+        expect(parsed.actions[0].start_date).toBe('2026-06-01');
+        expect(parsed.actions[0].end_date).toBe('2026-06-03');
         const v = validateActivities(parsed);
         expect(v.valid).toBe(true);
     });
     it('bare ISO dates are coerced to ISO strings and pass validation', () => {
         const text = [
-            'notation: activities',
-            'activities:',
+            'notation: action',
+            'actions:',
             '  - id: "A-001"',
             '    name: "Bare dates"',
             '    duration: 3',
@@ -85,10 +85,10 @@ describe('coerceDatesToIsoStrings — js-yaml integration', () => {
         // Without coercion, js-yaml returns Date instances and the validator
         // would emit ACT-008 because typeof !== 'string'. Sanity-check that
         // assumption before normalisation.
-        expect(parsed.activities[0].start_date).toBeInstanceOf(Date);
+        expect(parsed.actions[0].start_date).toBeInstanceOf(Date);
         coerceDatesToIsoStrings(parsed);
-        expect(parsed.activities[0].start_date).toBe('2026-06-01');
-        expect(parsed.activities[0].end_date).toBe('2026-06-03');
+        expect(parsed.actions[0].start_date).toBe('2026-06-01');
+        expect(parsed.actions[0].end_date).toBe('2026-06-03');
         const v = validateActivities(parsed);
         expect(v.valid).toBe(true);
     });

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

@@ -3,39 +3,37 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 import yaml from 'js-yaml';
 import { validateActivities } from '../validate.js';
-const EXAMPLES_DIR = path.resolve(process.cwd(), '..', '..', 'tests', 'fixtures', 'notation-corpus', 'activities');
+const EXAMPLES_DIR = path.resolve(process.cwd(), '..', '..', 'tests', 'fixtures', 'notation-corpus', 'action');
 const minimalValid = {
-    notation: 'activities',
-    activities: [
+    notation: 'action',
+    actions: [
         { id: 'A-001', name: 'Start', duration: 3 },
         { id: 'A-002', name: 'End', duration: 2, predecessors: ['A-001'] },
     ],
 };
 describe('validateActivities', () => {
-    it('ACT-001 — accepts notation: activities (deprecated)', () => {
+    it('ACT-001 — accepts notation: action (canonical)', () => {
         const r = validateActivities(minimalValid);
         expect(r.valid).toBe(true);
-        // deprecated notation emits a warning, not an error
-        expect(r.warnings.some(w => w.code === 'DEPRECATED_NOTATION')).toBe(true);
+        expect(r.warnings.some(w => w.code === 'DEPRECATED_NOTATION')).toBe(false);
     });
-    it('ACT-001 — accepts notation: action (canonical)', () => {
+    it('ACT-001 — rejects notation: activities (no longer accepted)', () => {
         const r = validateActivities({
-            notation: 'action',
-            actions: [
-                { id: 'ACTION-001', name: 'Start', duration: 3 },
-                { id: 'ACTION-002', name: 'End', duration: 2, predecessors: ['ACTION-001'] },
+            notation: 'activities',
+            activities: [
+                { id: 'A-001', name: 'Start', duration: 3 },
             ],
         });
-        expect(r.valid).toBe(true);
-        expect(r.warnings.some(w => w.code === 'DEPRECATED_NOTATION')).toBe(false);
+        expect(r.valid).toBe(false);
+        expect(r.errors.some(e => e.code === 'ACT-001')).toBe(true);
     });
-    it('ACT-001 — accepts notation: action with deprecated activities: key (emits field warning)', () => {
+    it('ACT-001 — rejects activities: root key (only actions: accepted)', () => {
         const r = validateActivities({
             notation: 'action',
             activities: [{ id: 'ACTION-001', name: 'Foo', duration: 1 }],
         });
-        expect(r.valid).toBe(true);
-        expect(r.warnings.some(w => w.code === 'DEPRECATED_FIELD')).toBe(true);
+        expect(r.valid).toBe(false);
+        expect(r.errors.some(e => e.code === 'SCHEMA_INVALID')).toBe(true);
     });
     it('ACT-001 — normalises action_type to activity_type for downstream layout', () => {
         const input = {
@@ -60,32 +58,32 @@ describe('validateActivities', () => {
     });
     it('ACT-002 — rejects activity with missing id', () => {
         const r = validateActivities({
-            notation: 'activities',
-            activities: [{ name: 'No ID', duration: 1 }],
+            notation: 'action',
+            actions: [{ name: 'No ID', duration: 1 }],
         });
         expect(r.valid).toBe(false);
         expect(r.errors.some(e => e.code === 'ACT-002')).toBe(true);
     });
     it('ACT-002 — rejects activity with empty id', () => {
         const r = validateActivities({
-            notation: 'activities',
-            activities: [{ id: '  ', name: 'Empty ID', duration: 1 }],
+            notation: 'action',
+            actions: [{ id: '  ', name: 'Empty ID', duration: 1 }],
         });
         expect(r.valid).toBe(false);
         expect(r.errors.some(e => e.code === 'ACT-002')).toBe(true);
     });
     it('ACT-003 — rejects activity with missing name', () => {
         const r = validateActivities({
-            notation: 'activities',
-            activities: [{ id: 'A-001', duration: 1 }],
+            notation: 'action',
+            actions: [{ id: 'A-001', duration: 1 }],
         });
         expect(r.valid).toBe(false);
         expect(r.errors.some(e => e.code === 'ACT-003')).toBe(true);
     });
     it('ACT-004 — rejects duplicate ids', () => {
         const r = validateActivities({
-            notation: 'activities',
-            activities: [
+            notation: 'action',
+            actions: [
                 { id: 'A-001', name: 'First', duration: 1 },
                 { id: 'A-001', name: 'Duplicate', duration: 2 },
             ],
@@ -95,8 +93,8 @@ describe('validateActivities', () => {
     });
     it('ACT-005 — rejects unknown predecessor reference', () => {
         const r = validateActivities({
-            notation: 'activities',
-            activities: [{ id: 'A-001', name: 'Task', duration: 1, predecessors: ['MISSING'] }],
+            notation: 'action',
+            actions: [{ id: 'A-001', name: 'Task', duration: 1, predecessors: ['MISSING'] }],
         });
         expect(r.valid).toBe(false);
         expect(r.errors.some(e => e.code === 'ACT-005')).toBe(true);
@@ -108,8 +106,8 @@ describe('validateActivities', () => {
     });
     it('ACT-006 — rejects cyclic dependency', () => {
         const r = validateActivities({
-            notation: 'activities',
-            activities: [
+            notation: 'action',
+            actions: [
                 { id: 'A-001', name: 'Task A', duration: 1, predecessors: ['A-002'] },
                 { id: 'A-002', name: 'Task B', duration: 1, predecessors: ['A-001'] },
             ],
@@ -119,16 +117,16 @@ describe('validateActivities', () => {
     });
     it('ACT-007 — rejects self-loop', () => {
         const r = validateActivities({
-            notation: 'activities',
-            activities: [{ id: 'A-001', name: 'Task', duration: 1, predecessors: ['A-001'] }],
+            notation: 'action',
+            actions: [{ id: 'A-001', name: 'Task', duration: 1, predecessors: ['A-001'] }],
         });
         expect(r.valid).toBe(false);
         expect(r.errors.some(e => e.code === 'ACT-007')).toBe(true);
     });
     it('ACT-008 — rejects end_date before start_date', () => {
         const r = validateActivities({
-            notation: 'activities',
-            activities: [
+            notation: 'action',
+            actions: [
                 { id: 'A-001', name: 'Task', duration: 5, start_date: '2026-06-10', end_date: '2026-06-01' },
             ],
         });
@@ -137,8 +135,8 @@ describe('validateActivities', () => {
     });
     it('ACT-008 — accepts end_date equal to start_date', () => {
         const r = validateActivities({
-            notation: 'activities',
-            activities: [
+            notation: 'action',
+            actions: [
                 { id: 'A-001', name: 'Task', duration: 0, start_date: '2026-06-01', end_date: '2026-06-01' },
             ],
         });
@@ -146,8 +144,8 @@ describe('validateActivities', () => {
     });
     it('ACT-008 — rejects non-ISO start_date format', () => {
         const r = validateActivities({
-            notation: 'activities',
-            activities: [
+            notation: 'action',
+            actions: [
                 { id: 'A-001', name: 'Task', duration: 5, start_date: 'June 1 2026' },
             ],
         });
@@ -156,8 +154,8 @@ describe('validateActivities', () => {
     });
     it('ACT-008 — rejects non-ISO end_date format', () => {
         const r = validateActivities({
-            notation: 'activities',
-            activities: [
+            notation: 'action',
+            actions: [
                 { id: 'A-001', name: 'Task', duration: 5, end_date: '2026/06/30' },
             ],
         });
@@ -170,8 +168,8 @@ describe('validateActivities', () => {
         // on top would be misleading because the lexicographic compare is
         // meaningless on non-ISO strings.
         const r = validateActivities({
-            notation: 'activities',
-            activities: [
+            notation: 'action',
+            actions: [
                 { id: 'A-001', name: 'Task', duration: 5, start_date: 'tomorrow', end_date: 'yesterday' },
             ],
         });
@@ -180,31 +178,31 @@ describe('validateActivities', () => {
     });
     it('ACT-009 — rejects negative duration', () => {
         const r = validateActivities({
-            notation: 'activities',
-            activities: [{ id: 'A-001', name: 'Task', duration: -1 }],
+            notation: 'action',
+            actions: [{ id: 'A-001', name: 'Task', duration: -1 }],
         });
         expect(r.valid).toBe(false);
         expect(r.errors.some(e => e.code === 'ACT-009')).toBe(true);
     });
     it('ACT-009 — accepts zero duration', () => {
         const r = validateActivities({
-            notation: 'activities',
-            activities: [{ id: 'A-001', name: 'Milestone', duration: 0 }],
+            notation: 'action',
+            actions: [{ id: 'A-001', name: 'Milestone', duration: 0 }],
         });
         expect(r.errors.some(e => e.code === 'ACT-009')).toBe(false);
     });
     it('ACT-010 — rejects singular "goal:" field', () => {
         const r = validateActivities({
-            notation: 'activities',
-            activities: [{ id: 'A-001', name: 'Task', duration: 1, goal: 'GOAL-001' }],
+            notation: 'action',
+            actions: [{ id: 'A-001', name: 'Task', duration: 1, goal: 'GOAL-001' }],
         });
         expect(r.valid).toBe(false);
         expect(r.errors.some(e => e.code === 'ACT-010')).toBe(true);
     });
     it('ACT-010 — rejects singular "predecessor:" field', () => {
         const r = validateActivities({
-            notation: 'activities',
-            activities: [
+            notation: 'action',
+            actions: [
                 { id: 'A-001', name: 'First', duration: 1 },
                 { id: 'A-002', name: 'Task', duration: 1, predecessor: 'A-001' },
             ],
@@ -214,24 +212,24 @@ describe('validateActivities', () => {
     });
     it('ACT-010 — rejects singular "tag:" field', () => {
         const r = validateActivities({
-            notation: 'activities',
-            activities: [{ id: 'A-001', name: 'Task', duration: 1, tag: 'q3' }],
+            notation: 'action',
+            actions: [{ id: 'A-001', name: 'Task', duration: 1, tag: 'q3' }],
         });
         expect(r.valid).toBe(false);
         expect(r.errors.some(e => e.code === 'ACT-010')).toBe(true);
     });
     it('ACT-011 — warns when duration is absent', () => {
         const r = validateActivities({
-            notation: 'activities',
-            activities: [{ id: 'A-001', name: 'No duration' }],
+            notation: 'action',
+            actions: [{ id: 'A-001', name: 'No duration' }],
         });
         expect(r.valid).toBe(true);
         expect(r.warnings.some(w => w.code === 'ACT-011')).toBe(true);
     });
     it('ACT-013 — warns on structurally orphan activity', () => {
         const r = validateActivities({
-            notation: 'activities',
-            activities: [
+            notation: 'action',
+            actions: [
                 { id: 'A-001', name: 'Connected', duration: 1 },
                 { id: 'A-002', name: 'Orphan', duration: 1 },
                 { id: 'A-003', name: 'End', duration: 1, predecessors: ['A-001'] },
@@ -243,9 +241,9 @@ describe('validateActivities', () => {
     });
     it('full valid example passes with no errors', () => {
         const r = validateActivities({
-            notation: 'activities',
+            notation: 'action',
             title: 'Test Project',
-            activities: [
+            actions: [
                 { id: 'A', name: 'Start', duration: 3 },
                 { id: 'B', name: 'Middle', duration: 5, predecessors: ['A'] },
                 { id: 'C', name: 'End', duration: 2, predecessors: ['B'] },
@@ -296,8 +294,8 @@ describe('validateActivities', () => {
     // ── Milestone date equality (ACT-016) ─────────────────────────────────────
     it('ACT-016 — rejects milestone with mismatched start/end dates', () => {
         const r = validateActivities({
-            notation: 'activities',
-            activities: [
+            notation: 'action',
+            actions: [
                 { id: 'M-1', name: 'Launch', duration: 0, start_date: '2026-06-01', end_date: '2026-06-02' },
             ],
         });
@@ -306,8 +304,8 @@ describe('validateActivities', () => {
     });
     it('ACT-016 — accepts milestone with equal start/end dates', () => {
         const r = validateActivities({
-            notation: 'activities',
-            activities: [
+            notation: 'action',
+            actions: [
                 { id: 'M-1', name: 'Launch', duration: 0, start_date: '2026-06-01', end_date: '2026-06-01' },
             ],
         });
@@ -316,8 +314,8 @@ describe('validateActivities', () => {
     // ── Phase warnings (ACT-017, ACT-018) ─────────────────────────────────────
     it('ACT-017 — warns when a referenced-as-parent activity carries its own duration', () => {
         const r = validateActivities({
-            notation: 'activities',
-            activities: [
+            notation: 'action',
+            actions: [
                 { id: 'PHASE-1', name: 'Design', duration: 5 },
                 { id: 'A-1', name: 'Child', duration: 3, parent: 'PHASE-1' },
             ],
@@ -327,8 +325,8 @@ describe('validateActivities', () => {
     });
     it('ACT-017 — no warning when phase omits duration/dates and rolls up from children', () => {
         const r = validateActivities({
-            notation: 'activities',
-            activities: [
+            notation: 'action',
+            actions: [
                 { id: 'PHASE-1', name: 'Design' },
                 { id: 'A-1', name: 'Child', duration: 3, parent: 'PHASE-1' },
             ],
@@ -337,8 +335,8 @@ describe('validateActivities', () => {
     });
     it('ACT-018 — warns when an activity with no duration is not referenced as parent', () => {
         const r = validateActivities({
-            notation: 'activities',
-            activities: [
+            notation: 'action',
+            actions: [
                 { id: 'A-1', name: 'Has duration', duration: 3 },
                 { id: 'P-EMPTY', name: 'Looks like phase but no children' },
             ],
@@ -347,8 +345,8 @@ describe('validateActivities', () => {
     });
     it('ACT-018 — no warning when the no-duration activity has at least one child', () => {
         const r = validateActivities({
-            notation: 'activities',
-            activities: [
+            notation: 'action',
+            actions: [
                 { id: 'PHASE-1', name: 'Phase' },
                 { id: 'A-1', name: 'Child', duration: 3, parent: 'PHASE-1' },
             ],
@@ -366,24 +364,29 @@ describe('validateActivities', () => {
     });
     it('ACT-019 — no warning when every activity has pinned dates', () => {
         const r = validateActivities({
-            notation: 'activities',
-            activities: [
+            notation: 'action',
+            actions: [
                 { id: 'A-1', name: 'A', duration: 3, start_date: '2026-06-01', end_date: '2026-06-04' },
             ],
         });
         expect(r.warnings.some(w => w.code === 'ACT-019')).toBe(false);
     });
-    it('[blocker] tolerates a null element in activities[] without throwing', () => {
-        const r = validateActivities({ ...minimalValid, activities: [null] });
+    it('[blocker] tolerates a null element in actions[] without throwing', () => {
+        // Do NOT spread minimalValid here: validateActivities mutates its input
+        // to normalise raw.activities, so a previously-called test that passed
+        // minimalValid directly would have set minimalValid.activities. Spreading
+        // that mutated object would cause the actions:[null] override to be masked
+        // by the pre-existing activities array.
+        const r = validateActivities({ notation: 'action', actions: [null] });
         expect(r.valid).toBe(false);
         expect(r.errors.some(e => e.code === 'SCHEMA_INVALID')).toBe(true);
     });
 });
-describe('activities examples (regression)', () => {
+describe('action examples (regression)', () => {
     const files = fs.readdirSync(EXAMPLES_DIR).filter(f => f.endsWith('.yaml'));
     expect(files.length).toBeGreaterThan(0);
     for (const file of files) {
-        it(`validates tests/fixtures/notation-corpus/activities/${file}`, () => {
+        it(`validates tests/fixtures/notation-corpus/action/${file}`, () => {
             const text = fs.readFileSync(path.join(EXAMPLES_DIR, file), 'utf8');
             const parsed = yaml.load(text);
             const r = validateActivities(parsed);

package/dist/activities/validate.js

@@ -7,26 +7,19 @@ export function validateActivities(input) {
         return { valid: false, errors: [{ code: 'ACT-001', message: 'Input must be an object' }], warnings };
     }
     const raw = input;
-    // ACT-001: notation must be "action" (canonical) or "activities" (deprecated)
+    // ACT-001: notation must be "action"
     if (raw.notation === undefined) {
         errors.push({ code: 'ACT-001', message: 'notation field is required' });
         return { valid: false, errors, warnings };
     }
-    if (raw.notation !== 'action' && raw.notation !== 'activities') {
+    if (raw.notation !== 'action') {
         errors.push({ code: 'ACT-001', message: `notation must be "action", got "${String(raw.notation)}"` });
         return { valid: false, errors, warnings };
     }
-    if (raw.notation === 'activities') {
-        warnings.push({ code: 'DEPRECATED_NOTATION', message: 'notation: "activities" is deprecated — migrate to notation: "action"' });
-    }
-    // Accept "actions:" (canonical) or "activities:" (deprecated)
-    const rawArray = Array.isArray(raw.actions) ? raw.actions : (Array.isArray(raw.activities) ? raw.activities : undefined);
-    if (Array.isArray(raw.activities) && !Array.isArray(raw.actions)) {
-        warnings.push({ code: 'DEPRECATED_FIELD', message: 'Root key "activities:" is deprecated — rename to "actions:"' });
-    }
+    // Only "actions:" root key is accepted.
+    const rawArray = Array.isArray(raw.actions) ? raw.actions : undefined;
     if (!rawArray) {
-        const canonKey = raw.notation === 'action' ? 'actions' : 'activities';
-        errors.push({ code: 'SCHEMA_INVALID', message: `${canonKey} must be an array`, path: canonKey });
+        errors.push({ code: 'SCHEMA_INVALID', message: 'actions must be an array', path: 'actions' });
         return { valid: false, errors, warnings };
     }
     // Normalise onto raw.activities for the rest of this function (avoids touching downstream code)

package/dist/activity-card/__tests__/example.test.js

@@ -10,7 +10,7 @@ import yaml from 'js-yaml';
 import { validateActivityCard } from '../validate.js';
 import { resolveActivityCard } from '../resolver.js';
 import { layoutActivityCard } from '../layout.js';
-const dir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../../../../tests/fixtures/notation-corpus/activity-card');
+const dir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../../../../tests/fixtures/notation-corpus/action-card');
 const load = (f) => yaml.load(readFileSync(path.join(dir, f), 'utf-8'));
 /** Recursively load every `*.yaml` doc under a canon subtree (mirrors the
  *  extension's element/relation walk). */
@@ -27,7 +27,7 @@ function loadYamlTree(root) {
 }
 describe('activity-card worked example (eu-programme)', () => {
     it('validates, resolves, and lays out the success-signal card', () => {
-        const card = load('eu-programme.activity-card.transitrix.yaml');
+        const card = load('eu-programme.action-card.transitrix.yaml');
         const elements = loadYamlTree(path.join(dir, 'canon', 'elements'));
         const relations = loadYamlTree(path.join(dir, 'canon', 'relations'));
         const v = validateActivityCard(card);
@@ -61,13 +61,11 @@ describe('activity-card worked example (eu-programme)', () => {
         // Description row
         expect(layout.descriptionRow?.label).toBe('Description');
         // Chain sections
-        expect(layout.chainSections.map((s) => s.type)).toEqual(['drivers', 'assessments', 'goals', 'changes']);
+        expect(layout.chainSections.map((s) => s.type)).toEqual(['drivers', 'goals', 'changes']);
         const driversSection = layout.chainSections.find((s) => s.type === 'drivers');
         const goalsSection = layout.chainSections.find((s) => s.type === 'goals');
-        const assessmentsSection = layout.chainSections.find((s) => s.type === 'assessments');
         expect(driversSection.nodes.map((n) => n.id)).toContain('FACTOR-EU-MDR-1');
         expect(goalsSection.nodes.map((n) => n.id)).toContain('GOAL-EU-MARKET-1');
-        expect(assessmentsSection.isEmpty).toBe(true); // no assessment in this fixture
         // Chain edges
         expect(layout.chainEdges).toContainEqual({ sourceId: 'FACTOR-EU-MDR-1', targetId: 'GOAL-EU-MARKET-1' });
         expect(layout.chainEdges).toContainEqual({ sourceId: 'GOAL-EU-MARKET-1', targetId: 'CHANGE-EU-COMPLIANCE-1' });

package/dist/activity-card/__tests__/layout.test.js

@@ -82,19 +82,16 @@ describe('layoutActivityCard', () => {
         const l = layoutActivityCard({ ...RESOLVED, cardDescription: undefined });
         expect(l.descriptionRow).toBeUndefined();
     });
-    it('four chain sections in order: drivers, assessments, goals, changes', () => {
+    it('three chain sections in order: drivers, goals, changes', () => {
         const l = layoutActivityCard(RESOLVED);
-        expect(l.chainSections.map((s) => s.type)).toEqual(['drivers', 'assessments', 'goals', 'changes']);
+        expect(l.chainSections.map((s) => s.type)).toEqual(['drivers', 'goals', 'changes']);
     });
     it('chain sections carry the resolved nodes', () => {
         const l = layoutActivityCard(RESOLVED);
         const drivers = l.chainSections.find((s) => s.type === 'drivers');
-        const assessments = l.chainSections.find((s) => s.type === 'assessments');
         const goals = l.chainSections.find((s) => s.type === 'goals');
         const changes = l.chainSections.find((s) => s.type === 'changes');
         expect(drivers.nodes.map((n) => n.id)).toEqual(['FACTOR-EU-MDR-1']);
-        expect(assessments.nodes.map((n) => n.id)).toEqual(['ASSESSMENT-MDR-1']);
-        expect(assessments.nodes[0].meta).toBe('2026-03-01');
         expect(goals.nodes.map((n) => n.id)).toEqual(['GOAL-EU-MARKET-1']);
         expect(changes.nodes.map((n) => n.id)).toEqual(['CHANGE-EU-COMPLIANCE-1']);
     });
@@ -111,10 +108,6 @@ describe('layoutActivityCard', () => {
         expect(l.chainEdges).toContainEqual({ sourceId: 'FACTOR-EU-MDR-1', targetId: 'GOAL-EU-MARKET-1' });
         expect(l.chainEdges).toContainEqual({ sourceId: 'GOAL-EU-MARKET-1', targetId: 'CHANGE-EU-COMPLIANCE-1' });
     });
-    it('builds driver→assessment edge when assessment is linked', () => {
-        const l = layoutActivityCard(RESOLVED);
-        expect(l.chainEdges).toContainEqual({ sourceId: 'FACTOR-EU-MDR-1', targetId: 'ASSESSMENT-MDR-1' });
-    });
     it('milestone ArchiMate class is set', () => {
         const l = layoutActivityCard(RESOLVED);
         expect(l.milestones).toHaveLength(1);

package/dist/activity-card/__tests__/resolver.test.js

@@ -198,6 +198,31 @@ describe('resolveActivityCard', () => {
         expect(r.resolved.stakeholders).toEqual([{ id: 'STAKEHOLDER-OPS-1', name: 'STAKEHOLDER-OPS-1', role: 'sponsor' }]);
         expect(r.warnings.some((w) => w.code === 'PC-001')).toBe(true);
     });
+    it('resolves stakeholders from inline stakeholders: [] on the Action element', () => {
+        const projectWithInlineStakeholders = { ...PROJECT, stakeholders: ['STAKEHOLDER-OPS-1'] };
+        const r = resolveActivityCard(CARD, {
+            elements: [projectWithInlineStakeholders, CHILD, FACTOR, GOAL, CHANGE, STAKEHOLDER],
+            relations: [REL_GOAL],
+        });
+        expect(r.valid).toBe(true);
+        const sh = r.resolved.stakeholders;
+        expect(sh).toHaveLength(1);
+        expect(sh[0].id).toBe('STAKEHOLDER-OPS-1');
+        expect(sh[0].name).toBe('Operations');
+        expect(sh[0].role).toBeUndefined();
+    });
+    it('REL stakeholder takes precedence over inline duplicate (carries role)', () => {
+        const projectWithInlineStakeholders = { ...PROJECT, stakeholders: ['STAKEHOLDER-OPS-1'] };
+        const r = resolveActivityCard(CARD, {
+            elements: [projectWithInlineStakeholders, CHILD, FACTOR, GOAL, CHANGE, STAKEHOLDER],
+            relations: [REL_GOAL, REL_STAKEHOLDER],
+        });
+        expect(r.valid).toBe(true);
+        const sh = r.resolved.stakeholders;
+        // deduplicated — REL entry wins, inline duplicate is dropped
+        expect(sh).toHaveLength(1);
+        expect(sh[0].role).toBe('sponsor');
+    });
     it('falls back to the inline goals field when no activity_goal relation exists', () => {
         const projectWithInline = { ...PROJECT, goals: ['GOAL-EU-MARKET-1'] };
         const r = resolveActivityCard(CARD, {