@transitrix/diagrams 1.3.0 → 1.4.0

package/src/activities/__tests__/validate.test.ts

@@ -4,43 +4,41 @@ 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', () => {
@@ -69,8 +67,8 @@ 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);
@@ -78,8 +76,8 @@ describe('validateActivities', () => {
 
   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);
@@ -87,8 +85,8 @@ describe('validateActivities', () => {
 
   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);
@@ -96,8 +94,8 @@ describe('validateActivities', () => {
 
   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 },
       ],
@@ -108,8 +106,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);
@@ -123,8 +121,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'] },
       ],
@@ -135,8 +133,8 @@ 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);
@@ -144,8 +142,8 @@ describe('validateActivities', () => {
 
   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' },
       ],
     });
@@ -155,8 +153,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' },
       ],
     });
@@ -165,8 +163,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' },
       ],
     });
@@ -176,8 +174,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' },
       ],
     });
@@ -191,8 +189,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' },
       ],
     });
@@ -202,8 +200,8 @@ 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);
@@ -211,16 +209,16 @@ describe('validateActivities', () => {
 
   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' } as any],
+      notation: 'action',
+      actions: [{ id: 'A-001', name: 'Task', duration: 1, goal: 'GOAL-001' } as any],
     });
     expect(r.valid).toBe(false);
     expect(r.errors.some(e => e.code === 'ACT-010')).toBe(true);
@@ -228,8 +226,8 @@ describe('validateActivities', () => {
 
   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' } as any,
       ],
@@ -240,8 +238,8 @@ describe('validateActivities', () => {
 
   it('ACT-010 — rejects singular "tag:" field', () => {
     const r = validateActivities({
-      notation: 'activities',
-      activities: [{ id: 'A-001', name: 'Task', duration: 1, tag: 'q3' } as any],
+      notation: 'action',
+      actions: [{ id: 'A-001', name: 'Task', duration: 1, tag: 'q3' } as any],
     });
     expect(r.valid).toBe(false);
     expect(r.errors.some(e => e.code === 'ACT-010')).toBe(true);
@@ -249,8 +247,8 @@ describe('validateActivities', () => {
 
   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);
@@ -258,8 +256,8 @@ describe('validateActivities', () => {
 
   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'] },
@@ -272,9 +270,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'] },
@@ -333,8 +331,8 @@ describe('validateActivities', () => {
 
   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' },
       ],
     });
@@ -344,8 +342,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' },
       ],
     });
@@ -356,8 +354,8 @@ describe('validateActivities', () => {
 
   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' },
       ],
@@ -368,8 +366,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' },
       ],
@@ -379,8 +377,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' },
       ],
@@ -390,8 +388,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' },
       ],
@@ -413,26 +411,31 @@ 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/src/activities/validate.ts

@@ -19,27 +19,20 @@ export function validateActivities(input: unknown): ActivityValidationResult {
 
   const raw = input as Record<string, unknown>;
 
-  // 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/src/activity-card/__tests__/example.test.ts

@@ -15,7 +15,7 @@ import type { ActivityCardDoc } from '../types.js';
 
 const dir = path.resolve(
   path.dirname(fileURLToPath(import.meta.url)),
-  '../../../../../tests/fixtures/notation-corpus/activity-card',
+  '../../../../../tests/fixtures/notation-corpus/action-card',
 );
 const load = (f: string): unknown => yaml.load(readFileSync(path.join(dir, f), 'utf-8'));
 
@@ -33,7 +33,7 @@ function loadYamlTree(root: string): unknown[] {
 
 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'));
 

package/src/activity-card/__tests__/validate.test.ts

@@ -2,9 +2,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.',
@@ -20,11 +20,23 @@ 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)', () => {
@@ -67,21 +79,21 @@ describe('validateActivityCard', () => {
     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);
   });
@@ -89,7 +101,7 @@ describe('validateActivityCard', () => {
   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);
   });
@@ -97,7 +109,7 @@ describe('validateActivityCard', () => {
   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);
@@ -106,8 +118,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' }],
       },
     });
@@ -118,7 +130,7 @@ 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);
   });
@@ -126,8 +138,8 @@ describe('validateActivityCard', () => {
   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' }],
       },
     });
@@ -137,8 +149,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'] }],
       },
     });
@@ -148,7 +160,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/src/activity-card/validate.ts

@@ -49,21 +49,15 @@ export function validateActivityCard(input: unknown): ValidationResult {
   // ── Header (CONTRACT.md §2) ────────────────────────────────────────────────
   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/src/actor/__tests__/validate.test.ts

@@ -103,4 +103,12 @@ 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/src/actor/types.ts

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

package/src/applications/types.ts

@@ -2,11 +2,19 @@ export type ApplicationType = 'application' | 'integration' | 'platform' | 'data
 export type ApplicationStatus = 'Draft' | 'Active' | 'Deprecated' | 'Decommissioning';
 export type IntegrationDirection = 'inbound' | 'outbound' | 'bidirectional';
 
+export type IntegrationSensitivity = 'public' | 'internal' | 'confidential' | 'restricted';
+export type IntegrationDirectionality = 'producer' | 'consumer' | 'request_reply' | 'bidirectional_stream';
+
 export interface ApplicationIntegration {
   target?: string;
+  source?: string;
   direction?: IntegrationDirection;
   protocol?: string;
   description?: string;
+  interface_semantics?: boolean;
+  payload_class?: string;
+  sensitivity?: IntegrationSensitivity;
+  directionality?: IntegrationDirectionality;
 }
 
 export interface Application {