@transitrix/diagrams 1.3.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);

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

@@ -1,9 +1,9 @@
 import { describe, it, expect } from 'vitest';
 import { validateActivityCard } from '../validate.js';
 const VALID = {
-    notation: 'activity-card',
+    notation: 'action-card',
     spec_version: '0.1',
-    activity_card: {
+    action_card: {
         id: 'ACTIVITY_CARD-EU-PROGRAMME-1',
         project: 'ACTIVITY-EU-PROGRAMME-1',
         description: 'Executive summary.',
@@ -18,11 +18,22 @@ const VALID = {
     },
 };
 describe('validateActivityCard', () => {
-    it('accepts a well-formed card (deprecated notation: activity-card)', () => {
+    it('accepts a well-formed card (notation: action-card)', () => {
         const r = validateActivityCard(VALID);
         expect(r.valid).toBe(true);
         expect(r.errors).toHaveLength(0);
-        expect(r.warnings.some(w => w.code === 'DEPRECATED_NOTATION')).toBe(true);
+        expect(r.warnings.some(w => w.code === 'DEPRECATED_NOTATION')).toBe(false);
+    });
+    it('rejects deprecated notation: activity-card', () => {
+        const r = validateActivityCard({
+            notation: 'activity-card',
+            activity_card: {
+                id: 'ACTIVITY_CARD-EU-PROGRAMME-1',
+                project: 'ACTIVITY-EU-PROGRAMME-1',
+            },
+        });
+        expect(r.valid).toBe(false);
+        expect(r.errors.some(e => e.code === 'HDR-002')).toBe(true);
     });
     it('accepts notation: action-card with action_card block (canonical)', () => {
         const r = validateActivityCard({
@@ -59,33 +70,33 @@ describe('validateActivityCard', () => {
         const r = validateActivityCard({ ...VALID, notation: 'activities' });
         expect(r.errors.some((e) => e.code === 'HDR-002')).toBe(true);
     });
-    it('AC-001 on missing activity_card block', () => {
-        const r = validateActivityCard({ notation: 'activity-card' });
+    it('AC-001 on missing action_card block', () => {
+        const r = validateActivityCard({ notation: 'action-card' });
         expect(r.valid).toBe(false);
         expect(r.errors.some((e) => e.code === 'AC-001')).toBe(true);
     });
     it('AC-002 on malformed card id', () => {
-        const r = validateActivityCard({ ...VALID, activity_card: { ...VALID.activity_card, id: 'CARD-1' } });
+        const r = validateActivityCard({ ...VALID, action_card: { ...VALID.action_card, id: 'CARD-1' } });
         expect(r.errors.some((e) => e.code === 'AC-002')).toBe(true);
     });
     it('PC-001 on missing project', () => {
         const r = validateActivityCard({
             ...VALID,
-            activity_card: { ...VALID.activity_card, project: undefined },
+            action_card: { ...VALID.action_card, project: undefined },
         });
         expect(r.errors.some((e) => e.code === 'PC-001')).toBe(true);
     });
     it('PC-001 on malformed project id', () => {
         const r = validateActivityCard({
             ...VALID,
-            activity_card: { ...VALID.activity_card, project: 'GOAL-1' },
+            action_card: { ...VALID.action_card, project: 'GOAL-1' },
         });
         expect(r.errors.some((e) => e.code === 'PC-001')).toBe(true);
     });
     it('AC-003 on milestone missing required fields', () => {
         const r = validateActivityCard({
             ...VALID,
-            activity_card: { ...VALID.activity_card, milestones: [{ id: 'MILESTONE-X-1' }] },
+            action_card: { ...VALID.action_card, milestones: [{ id: 'MILESTONE-X-1' }] },
         });
         expect(r.valid).toBe(false);
         expect(r.errors.some((e) => e.code === 'AC-003')).toBe(true);
@@ -93,8 +104,8 @@ describe('validateActivityCard', () => {
     it('AC-004 on malformed milestone id', () => {
         const r = validateActivityCard({
             ...VALID,
-            activity_card: {
-                ...VALID.activity_card,
+            action_card: {
+                ...VALID.action_card,
                 milestones: [{ id: 'MS-1', name: 'x', date: '2027-01-01' }],
             },
         });
@@ -104,15 +115,15 @@ describe('validateActivityCard', () => {
         const m = { id: 'MILESTONE-X-1', name: 'x', date: '2027-01-01' };
         const r = validateActivityCard({
             ...VALID,
-            activity_card: { ...VALID.activity_card, milestones: [m, { ...m }] },
+            action_card: { ...VALID.action_card, milestones: [m, { ...m }] },
         });
         expect(r.errors.some((e) => e.code === 'AC-004' && /Duplicate/.test(e.message))).toBe(true);
     });
     it('AC-005 on bad milestone date format', () => {
         const r = validateActivityCard({
             ...VALID,
-            activity_card: {
-                ...VALID.activity_card,
+            action_card: {
+                ...VALID.action_card,
                 milestones: [{ id: 'MILESTONE-X-1', name: 'x', date: '31/01/2027' }],
             },
         });
@@ -121,8 +132,8 @@ describe('validateActivityCard', () => {
     it('AC-006 on malformed delivers_changes entry', () => {
         const r = validateActivityCard({
             ...VALID,
-            activity_card: {
-                ...VALID.activity_card,
+            action_card: {
+                ...VALID.action_card,
                 milestones: [{ id: 'MILESTONE-X-1', name: 'x', date: '2027-01-01', delivers_changes: ['GOAL-1'] }],
             },
         });
@@ -131,7 +142,7 @@ describe('validateActivityCard', () => {
     it('accepts a card with no milestones', () => {
         const r = validateActivityCard({
             ...VALID,
-            activity_card: { id: 'ACTIVITY_CARD-X-1', project: 'ACTIVITY-X-1' },
+            action_card: { id: 'ACTIVITY_CARD-X-1', project: 'ACTIVITY-X-1' },
         });
         expect(r.valid).toBe(true);
     });

package/dist/activity-card/validate.js

@@ -40,21 +40,14 @@ export function validateActivityCard(input) {
     if (!('notation' in raw)) {
         errors.push({ code: 'HDR-001', message: 'notation field is required' });
     }
-    else if (raw['notation'] !== 'action-card' && raw['notation'] !== 'activity-card') {
+    else if (raw['notation'] !== 'action-card') {
         errors.push({
             code: 'HDR-002',
             message: `notation must be "action-card", got "${String(raw['notation'])}"`,
         });
     }
-    else if (raw['notation'] === 'activity-card') {
-        warnings.push({ code: 'DEPRECATED_NOTATION', message: 'notation: "activity-card" is deprecated — migrate to notation: "action-card"' });
-    }
-    // ── action_card / activity_card block ───────────────────────────────────────
-    // "action_card:" is canonical; "activity_card:" is accepted for compat.
-    const rawBlock = raw['action_card'] ?? raw['activity_card'];
-    if (raw['activity_card'] !== undefined && raw['action_card'] === undefined) {
-        warnings.push({ code: 'DEPRECATED_FIELD', message: 'Root key "activity_card:" is deprecated — rename to "action_card:"' });
-    }
+    // ── action_card block ────────────────────────────────────────────────────────
+    const rawBlock = raw['action_card'];
     const block = rawBlock;
     if (!block || typeof block !== 'object' || Array.isArray(block)) {
         errors.push({ code: 'AC-001', message: 'Missing required root key: action_card (object)' });

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

@@ -86,4 +86,10 @@ describe('validateActor — ACTOR-003 (engagement fields forbidden inline)', ()
     it('flags inline owner', () => {
         expect(codes({ ...valid(), owner: 'ACTOR-OPS-1' })).toContain('ACTOR-003');
     });
+    it('flags inline located_at (location belongs in a REL file)', () => {
+        expect(codes({ ...valid(), located_at: 'LOCATION-TBILISI-1' })).toContain('ACTOR-003');
+    });
+    it('flags inline unit_located_at (location belongs in a REL file)', () => {
+        expect(codes({ ...valid(), unit_located_at: 'LOCATION-TBILISI-1' })).toContain('ACTOR-003');
+    });
 });

package/dist/actor/types.d.ts

@@ -6,7 +6,7 @@ export type ActorType = typeof ACTOR_TYPES[number];
  * inline on an ACTOR file (§7.10, ACTOR-003). They belong in time-aware REL
  * records, never on the identity primitive.
  */
-export declare const ACTOR_FORBIDDEN_INLINE_FIELDS: readonly ["employment", "candidacy", "alumni_membership", "community_membership", "contracting", "unit_parent", "roles", "owner"];
+export declare const ACTOR_FORBIDDEN_INLINE_FIELDS: readonly ["employment", "candidacy", "alumni_membership", "community_membership", "contracting", "unit_parent", "located_at", "unit_located_at", "roles", "owner"];
 export interface Actor {
     notation: 'actor';
     id: string;

package/dist/actor/types.js

@@ -13,6 +13,8 @@ export const ACTOR_FORBIDDEN_INLINE_FIELDS = [
     'community_membership',
     'contracting',
     'unit_parent',
+    'located_at',
+    'unit_located_at',
     'roles',
     'owner',
 ];