@transitrix/diagrams 1.8.6 → 1.8.8

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

@@ -1,162 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { layoutActivityCard, ARCHIMATE_CLASS } from '../layout.js';
-import type { ResolvedActivityCard } from '../types.js';
-
-const RESOLVED: ResolvedActivityCard = {
-  cardId: 'ACTIVITY_CARD-EU-PROGRAMME-1',
-  cardDescription: 'Summary',
-  project: {
-    id: 'ACTIVITY-EU-PROGRAMME-1',
-    name: 'EU MDR conformity programme',
-    activity_type: 'programme',
-    status: 'in_progress',
-    valid_from: '2026-04-01',
-    start_date: '2026-04-15',
-    end_date: '2027-03-15',
-  },
-  milestones: [
-    { id: 'MILESTONE-CERT-1', name: 'Cert', date: '2027-01-31', deliversChanges: ['CHANGE-EU-COMPLIANCE-1'] },
-  ],
-  motivation: {
-    drivers: [{ id: 'FACTOR-EU-MDR-1', name: 'EU MDR regulation' }],
-    goals: [{ id: 'GOAL-EU-MARKET-1', name: 'Access EU market', driverIds: ['FACTOR-EU-MDR-1'] }],
-    changes: [{ id: 'CHANGE-EU-COMPLIANCE-1', name: 'Achieve MDR compliance', goalIds: ['GOAL-EU-MARKET-1'] }],
-  },
-  assessments: [
-    { id: 'ASSESSMENT-MDR-1', name: 'NB capacity constrained', driverId: 'FACTOR-EU-MDR-1', observed_at: '2026-03-01' },
-  ],
-  childActivities: [
-    { id: 'ACTIVITY-EU-CHILD-1', name: 'Notified-body engagement', start_date: '2026-05-01', end_date: '2026-12-01', owner: 'UNIT-REGULATORY' },
-  ],
-  goalNames: ['Access EU market'],
-  stakeholders: [
-    { id: 'STAKEHOLDER-OPS-1', name: 'Operations', role: 'owner' },
-    { id: 'STAKEHOLDER-CEO-1', name: 'CEO', role: 'sponsor' },
-  ],
-  notes: 'Pre-audit scheduled for October 2026.',
-};
-
-describe('layoutActivityCard', () => {
-  it('produces positive bounds', () => {
-    const l = layoutActivityCard(RESOLVED);
-    expect(l.bounds.width).toBeGreaterThan(0);
-    expect(l.bounds.height).toBeGreaterThan(0);
-  });
-
-  it('title row carries the project name', () => {
-    const l = layoutActivityCard(RESOLVED);
-    expect(l.titleRow.name).toBe('EU MDR conformity programme');
-  });
-
-  it('renders activity type and status badges when present', () => {
-    const l = layoutActivityCard(RESOLVED);
-    expect(l.activityTypeBadge?.label).toBe('programme');
-    expect(l.statusBadge?.label).toBe('in progress');
-  });
-
-  it('badges are absent when project fields are unset', () => {
-    const l = layoutActivityCard({ ...RESOLVED, project: { id: 'A', name: 'n' } });
-    expect(l.activityTypeBadge).toBeUndefined();
-    expect(l.statusBadge).toBeUndefined();
-  });
-
-  it('three date fields with correct labels and values', () => {
-    const l = layoutActivityCard(RESOLVED);
-    expect(l.dateFields).toHaveLength(3);
-    expect(l.dateFields[0]).toMatchObject({ label: 'Initiation', value: '2026-04-01' });
-    expect(l.dateFields[1]).toMatchObject({ label: 'Planned start', value: '2026-04-15' });
-    expect(l.dateFields[2]).toMatchObject({ label: 'Planned end', value: '2027-03-15' });
-  });
-
-  it('renders "—" for absent dates', () => {
-    const l = layoutActivityCard({ ...RESOLVED, project: { id: 'A', name: 'n' } });
-    expect(l.dateFields.map((d) => d.value)).toEqual(['—', '—', '—']);
-  });
-
-  it('four stakeholder role slots always rendered', () => {
-    const l = layoutActivityCard(RESOLVED);
-    expect(l.stakeholderRoleSlots).toHaveLength(4);
-    expect(l.stakeholderRoleSlots.map((s) => s.role)).toEqual(['Initiator', 'Owner', 'Sponsor', 'PM']);
-    expect(l.stakeholderRoleSlots[0].name).toBe('—');       // no initiator
-    expect(l.stakeholderRoleSlots[1].name).toBe('Operations'); // owner
-    expect(l.stakeholderRoleSlots[2].name).toBe('CEO');        // sponsor
-    expect(l.stakeholderRoleSlots[3].name).toBe('—');       // no PM
-  });
-
-  it('description row present when cardDescription is set', () => {
-    const l = layoutActivityCard(RESOLVED);
-    expect(l.descriptionRow?.label).toBe('Description');
-    expect(l.descriptionRow?.valueLines.join(' ')).toContain('Summary');
-  });
-
-  it('description row absent when cardDescription is empty', () => {
-    const l = layoutActivityCard({ ...RESOLVED, cardDescription: undefined });
-    expect(l.descriptionRow).toBeUndefined();
-  });
-
-  it('three chain sections in order: drivers, goals, changes', () => {
-    const l = layoutActivityCard(RESOLVED);
-    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 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(goals.nodes.map((n) => n.id)).toEqual(['GOAL-EU-MARKET-1']);
-    expect(changes.nodes.map((n) => n.id)).toEqual(['CHANGE-EU-COMPLIANCE-1']);
-  });
-
-  it('empty chain sections have isEmpty=true', () => {
-    const l = layoutActivityCard({
-      ...RESOLVED,
-      motivation: { drivers: [], goals: [], changes: [] },
-      assessments: [],
-    });
-    expect(l.chainSections.every((s) => s.isEmpty)).toBe(true);
-  });
-
-  it('builds driver→goal and goal→change edges', () => {
-    const l = layoutActivityCard(RESOLVED);
-    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('milestone ArchiMate class is set', () => {
-    const l = layoutActivityCard(RESOLVED);
-    expect(l.milestones).toHaveLength(1);
-    expect(l.milestones[0].archimateClass).toBe(ARCHIMATE_CLASS.MILESTONE);
-  });
-
-  it('child activity ArchiMate class is set', () => {
-    const l = layoutActivityCard(RESOLVED);
-    expect(l.childActivities[0].archimateClass).toBe(ARCHIMATE_CLASS.ACTIVITY);
-  });
-
-  it('footer row present when notes is set', () => {
-    const l = layoutActivityCard(RESOLVED);
-    expect(l.footerRow?.label).toBe('Notes');
-    expect(l.footerRow?.valueLines.join(' ')).toContain('Pre-audit');
-  });
-
-  it('footer row absent when notes is empty', () => {
-    const l = layoutActivityCard({ ...RESOLVED, notes: undefined });
-    expect(l.footerRow).toBeUndefined();
-  });
-
-  it('handles an empty card without throwing', () => {
-    const l = layoutActivityCard({
-      cardId: 'ACTIVITY_CARD-X-1',
-      project: { id: 'ACTIVITY-X-1', name: 'Empty' },
-      milestones: [],
-      motivation: { drivers: [], goals: [], changes: [] },
-      assessments: [],
-      childActivities: [],
-    });
-    expect(l.milestones).toHaveLength(0);
-    expect(l.bounds.height).toBeGreaterThan(0);
-  });
-});

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

@@ -1,357 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { resolveActivityCard } from '../resolver.js';
-import type { ActivityCardDoc } from '../types.js';
-
-const CARD: ActivityCardDoc = {
-  notation: 'activity-card',
-  spec_version: '0.1',
-  activity_card: {
-    id: 'ACTIVITY_CARD-EU-PROGRAMME-1',
-    project: 'ACTIVITY-EU-PROGRAMME-1',
-    description: 'Executive summary.',
-    milestones: [
-      { id: 'MILESTONE-CERT-1', name: 'Cert', date: '2027-01-31', delivers_changes: ['CHANGE-EU-COMPLIANCE-1'] },
-    ],
-  },
-};
-
-// ── Canon element store (one element per object) ─────────────────────────────
-const PROJECT = {
-  notation: 'activity',
-  id: 'ACTIVITY-EU-PROGRAMME-1',
-  name: 'EU MDR conformity programme',
-  valid_from: '2026-04-01',
-  valid_to: null,
-  start_date: '2026-04-15',
-  end_date: '2027-03-15',
-  delivers_changes: ['CHANGE-EU-COMPLIANCE-1'],
-};
-const CHILD = {
-  notation: 'activity',
-  id: 'ACTIVITY-EU-CHILD-1',
-  name: 'Notified-body engagement',
-  parent: 'ACTIVITY-EU-PROGRAMME-1',
-  start_date: '2026-05-01',
-  end_date: '2026-12-01',
-  owner: 'ACTOR-REGULATORY-1',
-};
-const UNRELATED = {
-  notation: 'activity',
-  id: 'ACTIVITY-UNRELATED-1',
-  name: 'Other',
-  parent: 'ACTIVITY-SOMETHING-ELSE-1',
-};
-const FACTOR = { notation: 'driver', id: 'FACTOR-EU-MDR-1', name: 'EU MDR regulation' };
-const GOAL = { notation: 'goal', id: 'GOAL-EU-MARKET-1', name: 'Access EU market', factors: ['FACTOR-EU-MDR-1'] };
-const CHANGE = {
-  notation: 'change',
-  id: 'CHANGE-EU-COMPLIANCE-1',
-  name: 'Achieve MDR compliance',
-  goals: ['GOAL-EU-MARKET-1'],
-};
-
-const ASSESSMENT = {
-  notation: 'assessment',
-  id: 'ASSESSMENT-EU-MDR-WINDOW-1',
-  name: 'Notified-body capacity constrained through 2026',
-  assesses: 'FACTOR-EU-MDR-1',
-  description: 'Bottleneck in notified-body capacity narrows the available certification window.',
-  observed_at: '2026-03-01',
-};
-
-const STAKEHOLDER = {
-  notation: 'stakeholder',
-  id: 'STAKEHOLDER-OPS-1',
-  name: 'Operations',
-  type: 'internal',
-  interest: 'high',
-  influence: 'medium',
-};
-
-// ── Canon relation store ─────────────────────────────────────────────────────
-// The project's goal link is a first-class `activity_goal` relation, not an
-// inline `goals:` field on the activity element.
-const REL_GOAL = {
-  notation: 'relation',
-  id: 'REL-EU-PROGRAMME-GOAL-1',
-  type: 'activity_goal',
-  from: 'ACTIVITY-EU-PROGRAMME-1',
-  to: 'GOAL-EU-MARKET-1',
-  valid_from: '2026-04-01',
-  valid_to: null,
-};
-const REL_STAKEHOLDER = {
-  notation: 'relation',
-  id: 'REL-EU-PROGRAMME-STAKE-OPS-1',
-  type: 'activity_stakeholder',
-  from: 'ACTIVITY-EU-PROGRAMME-1',
-  to: 'STAKEHOLDER-OPS-1',
-  role: 'sponsor',
-  valid_from: '2026-04-01',
-  valid_to: null,
-};
-
-const elements = [PROJECT, CHILD, UNRELATED, FACTOR, GOAL, CHANGE, STAKEHOLDER, ASSESSMENT];
-const relations = [REL_GOAL, REL_STAKEHOLDER];
-const sources = { elements, relations };
-
-describe('resolveActivityCard', () => {
-  it('resolves a full card from elements + relations', () => {
-    const r = resolveActivityCard(CARD, sources);
-    expect(r.valid, JSON.stringify(r.errors)).toBe(true);
-    const c = r.resolved!;
-    expect(c.project.name).toBe('EU MDR conformity programme');
-    expect(c.project.valid_from).toBe('2026-04-01');
-    expect(c.project.start_date).toBe('2026-04-15');
-    expect(c.milestones).toHaveLength(1);
-    expect(c.motivation.drivers.map((d) => d.id)).toEqual(['FACTOR-EU-MDR-1']);
-    expect(c.motivation.goals.map((g) => g.id)).toEqual(['GOAL-EU-MARKET-1']);
-    expect(c.motivation.changes.map((ch) => ch.id)).toEqual(['CHANGE-EU-COMPLIANCE-1']);
-    // only the activity whose parent = the project
-    expect(c.childActivities.map((a) => a.id)).toEqual(['ACTIVITY-EU-CHILD-1']);
-    // project goal text field = the directly-served goal name
-    expect(c.goalNames).toEqual(['Access EU market']);
-    // assessments resolved for in-scope drivers
-    expect(c.assessments).toEqual([
-      {
-        id: 'ASSESSMENT-EU-MDR-WINDOW-1',
-        name: 'Notified-body capacity constrained through 2026',
-        driverId: 'FACTOR-EU-MDR-1',
-        description: 'Bottleneck in notified-body capacity narrows the available certification window.',
-        observed_at: '2026-03-01',
-      },
-    ]);
-    // stakeholders resolved from the activity_stakeholder relation (with role)
-    expect(c.stakeholders).toEqual([
-      { id: 'STAKEHOLDER-OPS-1', name: 'Operations', type: 'internal', interest: 'high', influence: 'medium', role: 'sponsor' },
-    ]);
-  });
-
-  it('returns empty assessments when no assessment elements are in canon', () => {
-    const r = resolveActivityCard(CARD, {
-      elements: [PROJECT, CHILD, FACTOR, GOAL, CHANGE],
-      relations,
-    });
-    expect(r.valid).toBe(true);
-    expect(r.resolved!.assessments).toEqual([]);
-  });
-
-  it('omits assessments whose assesses driver is not in the motivation chain', () => {
-    const unrelatedAssessment = {
-      notation: 'assessment',
-      id: 'ASSESSMENT-UNRELATED-1',
-      name: 'Something unrelated',
-      assesses: 'FACTOR-UNRELATED-99',
-      observed_at: '2026-01-01',
-    };
-    const r = resolveActivityCard(CARD, {
-      elements: [PROJECT, CHILD, FACTOR, GOAL, CHANGE, unrelatedAssessment],
-      relations,
-    });
-    expect(r.valid).toBe(true);
-    expect(r.resolved!.assessments).toEqual([]);
-  });
-
-  it('sorts assessments by observed_at ascending', () => {
-    const a1 = { notation: 'assessment', id: 'ASSESSMENT-A-1', name: 'Later', assesses: 'FACTOR-EU-MDR-1', observed_at: '2026-06-01' };
-    const a2 = { notation: 'assessment', id: 'ASSESSMENT-A-2', name: 'Earlier', assesses: 'FACTOR-EU-MDR-1', observed_at: '2026-01-01' };
-    const r = resolveActivityCard(CARD, {
-      elements: [PROJECT, CHILD, FACTOR, GOAL, CHANGE, a1, a2],
-      relations,
-    });
-    expect(r.resolved!.assessments.map((a) => a.id)).toEqual(['ASSESSMENT-A-2', 'ASSESSMENT-A-1']);
-  });
-
-  it('resolves stakeholder role from the activity_stakeholder relation', () => {
-    const relWithRole = { ...REL_STAKEHOLDER, role: 'project_manager' };
-    const r = resolveActivityCard(CARD, { elements, relations: [REL_GOAL, relWithRole] });
-    expect(r.valid).toBe(true);
-    const sh = r.resolved?.stakeholders?.at(0);
-    expect(sh?.role).toBe('project_manager');
-  });
-
-  it('resolves stakeholder without role when relation has no role field', () => {
-    const relNoRole = { ...REL_STAKEHOLDER, role: undefined };
-    const r = resolveActivityCard(CARD, { elements, relations: [REL_GOAL, relNoRole] });
-    expect(r.valid).toBe(true);
-    const sh = r.resolved?.stakeholders?.at(0);
-    expect(sh).toBeDefined();
-    expect(sh?.role).toBeUndefined();
-  });
-
-  it('passes notes from card YAML through to the resolved card', () => {
-    const cardWithNotes = {
-      ...CARD,
-      activity_card: { ...CARD.activity_card, notes: 'Pre-audit scheduled for Q4.' },
-    };
-    const r = resolveActivityCard(cardWithNotes as ActivityCardDoc, sources);
-    expect(r.valid).toBe(true);
-    expect(r.resolved!.notes).toBe('Pre-audit scheduled for Q4.');
-  });
-
-  it('notes is undefined when not set in card YAML', () => {
-    const r = resolveActivityCard(CARD, sources);
-    expect(r.resolved!.notes).toBeUndefined();
-  });
-
-  it('resolves no stakeholders (empty list) when none are linked', () => {
-    const r = resolveActivityCard(CARD, { elements, relations: [REL_GOAL] });
-    expect(r.valid).toBe(true);
-    expect(r.resolved!.stakeholders).toEqual([]);
-    expect(r.warnings.some((w) => w.code === 'PC-001')).toBe(false);
-  });
-
-  it('ignores an ended (valid_to set) activity_stakeholder relation', () => {
-    const ended = { ...REL_STAKEHOLDER, valid_to: '2026-12-31' };
-    const r = resolveActivityCard(CARD, { elements, relations: [REL_GOAL, ended] });
-    expect(r.resolved!.stakeholders).toEqual([]);
-  });
-
-  it('warns but still lists a stakeholder whose element is missing from canon', () => {
-    const r = resolveActivityCard(CARD, {
-      elements: [PROJECT, CHILD, FACTOR, GOAL, CHANGE],
-      relations: [REL_GOAL, REL_STAKEHOLDER],
-    });
-    expect(r.valid).toBe(true);
-    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, {
-      elements: [projectWithInline, CHILD, FACTOR, GOAL, CHANGE],
-      relations: [],
-    });
-    expect(r.valid).toBe(true);
-    expect(r.resolved!.motivation.goals.map((g) => g.id)).toEqual(['GOAL-EU-MARKET-1']);
-  });
-
-  it('PC-001 when the project activity element is absent', () => {
-    const r = resolveActivityCard(CARD, { elements: [FACTOR, GOAL, CHANGE], relations });
-    expect(r.valid).toBe(false);
-    expect(r.errors.some((e) => e.code === 'PC-001')).toBe(true);
-  });
-
-  it('PC-001 diagnostic discloses paths searched and actionable hint (#344)', () => {
-    const r = resolveActivityCard(CARD, { elements: [FACTOR, GOAL, CHANGE], relations });
-    const pc001 = r.errors.find((e) => e.code === 'PC-001');
-    expect(pc001).toBeDefined();
-    // Must disclose both searched paths (§7 PC-001)
-    expect(pc001!.message).toContain('canon/elements/**');
-    expect(pc001!.message).toContain('canon/views/activities/**');
-    // Must include actionable hint with expected file pattern (§7 PC-001)
-    expect(pc001!.message).toContain('notation: action');
-    expect(pc001!.message).toContain(`id: "${CARD.activity_card.project}"`);
-  });
-
-  it('resolves without PC-001 when project activity lives in a deep canon/elements subfolder (#344)', () => {
-    // Regression: the resolver must accept elements regardless of which subfolder
-    // they were loaded from (e.g. canon/elements/05_implementation/activities/).
-    // The resolver is filesystem-free, so we simulate the deep-path scenario by
-    // including the PROJECT element in the elements pool — just as loadCanon does
-    // after walking canon/elements/** recursively.
-    const r = resolveActivityCard(CARD, sources);
-    expect(r.valid, JSON.stringify(r.errors)).toBe(true);
-    expect(r.errors.some((e) => e.code === 'PC-001')).toBe(false);
-  });
-
-  it('resolves activity_type and status from the Activity element', () => {
-    const r = resolveActivityCard(CARD, {
-      elements: [{ ...PROJECT, activity_type: 'programme', status: 'on_track' }, CHILD, FACTOR, GOAL, CHANGE],
-      relations,
-    });
-    expect(r.valid).toBe(true);
-    expect(r.resolved!.project.activity_type).toBe('programme');
-    expect(r.resolved!.project.status).toBe('on_track');
-  });
-
-  it('accepts any activity_type value without error (card works at all levels)', () => {
-    for (const t of ['programme', 'project', 'workstream', 'task', 'initiative']) {
-      const r = resolveActivityCard(CARD, {
-        elements: [{ ...PROJECT, activity_type: t }, CHILD, FACTOR, GOAL, CHANGE],
-        relations,
-      });
-      expect(r.errors.some((e) => e.code === 'PC-002'), `should not error for type "${t}"`).toBe(false);
-    }
-  });
-
-  it('PC-003 when a milestone change is not in the project changes', () => {
-    const card: ActivityCardDoc = {
-      ...CARD,
-      activity_card: {
-        ...CARD.activity_card,
-        milestones: [{ id: 'MILESTONE-X-1', name: 'x', date: '2027-01-01', delivers_changes: ['CHANGE-NOT-THERE-1'] }],
-      },
-    };
-    const r = resolveActivityCard(card, sources);
-    expect(r.errors.some((e) => e.code === 'PC-003')).toBe(true);
-  });
-
-  it('PC-004 warns when a milestone falls outside the lifecycle window', () => {
-    const r = resolveActivityCard(CARD, {
-      elements: [{ ...PROJECT, valid_to: '2026-12-31' }, CHILD, FACTOR, GOAL, CHANGE],
-      relations,
-    });
-    expect(r.valid).toBe(true);
-    expect(r.warnings.some((w) => w.code === 'PC-004')).toBe(true);
-  });
-
-  it('LIFECYCLE-001 when valid_from is missing', () => {
-    const r = resolveActivityCard(CARD, {
-      elements: [{ ...PROJECT, valid_from: undefined }, CHILD, FACTOR, GOAL, CHANGE],
-      relations,
-    });
-    expect(r.errors.some((e) => e.code === 'LIFECYCLE-001')).toBe(true);
-  });
-
-  it('LIFECYCLE-003 when valid_to precedes valid_from', () => {
-    const r = resolveActivityCard(CARD, {
-      elements: [{ ...PROJECT, valid_to: '2025-01-01' }, CHILD, FACTOR, GOAL, CHANGE],
-      relations,
-    });
-    expect(r.errors.some((e) => e.code === 'LIFECYCLE-003')).toBe(true);
-  });
-
-  it('warns and omits when a change element is not found in canon', () => {
-    const r = resolveActivityCard(CARD, { elements: [PROJECT, CHILD, FACTOR, GOAL], relations });
-    expect(r.valid).toBe(true);
-    expect(r.resolved!.motivation.changes).toHaveLength(0);
-    expect(r.warnings.some((w) => w.code === 'PC-001')).toBe(true);
-  });
-
-  it('does not crash on malformed element/relation docs', () => {
-    const r = resolveActivityCard(CARD, {
-      elements: [null, 'x', PROJECT, 42, { notation: 'goal', id: null }],
-      relations: [null, 'x', { notation: 'relation' }],
-    });
-    expect(r.valid).toBe(true);
-  });
-});

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

@@ -1,167 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { validateActivityCard } from '../validate.js';
-
-const VALID = {
-  notation: 'action-card',
-  spec_version: '0.1',
-  action_card: {
-    id: 'ACTIVITY_CARD-EU-PROGRAMME-1',
-    project: 'ACTIVITY-EU-PROGRAMME-1',
-    description: 'Executive summary.',
-    milestones: [
-      {
-        id: 'MILESTONE-EU-CONFORMITY-CERT-1',
-        name: 'Certification obtained',
-        date: '2027-01-31',
-        delivers_changes: ['CHANGE-EU-COMPLIANCE-1'],
-      },
-    ],
-  },
-};
-
-describe('validateActivityCard', () => {
-  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(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({
-      notation: 'action-card',
-      action_card: {
-        id: 'ACTION_CARD-EU-PROGRAMME-1',
-        project: 'ACTION-EU-PROGRAMME-1',
-      },
-    });
-    expect(r.valid).toBe(true);
-    expect(r.warnings.some(w => w.code === 'DEPRECATED_NOTATION')).toBe(false);
-  });
-
-  it('accepts action_card block with legacy ACTIVITY_CARD id prefix', () => {
-    const r = validateActivityCard({
-      notation: 'action-card',
-      action_card: {
-        id: 'ACTIVITY_CARD-EU-PROGRAMME-1',
-        project: 'ACTION-EU-PROGRAMME-1',
-      },
-    });
-    expect(r.valid).toBe(true);
-  });
-
-  it('rejects non-object input', () => {
-    expect(validateActivityCard('x').valid).toBe(false);
-    expect(validateActivityCard(null).valid).toBe(false);
-  });
-
-  it('HDR-001 on missing notation', () => {
-    const { notation: _drop, ...rest } = VALID;
-    const r = validateActivityCard(rest);
-    expect(r.valid).toBe(false);
-    expect(r.errors.some((e) => e.code === 'HDR-001')).toBe(true);
-  });
-
-  it('HDR-002 on wrong notation', () => {
-    const r = validateActivityCard({ ...VALID, notation: 'activities' });
-    expect(r.errors.some((e) => e.code === 'HDR-002')).toBe(true);
-  });
-
-  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, 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,
-      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,
-      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,
-      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);
-  });
-
-  it('AC-004 on malformed milestone id', () => {
-    const r = validateActivityCard({
-      ...VALID,
-      action_card: {
-        ...VALID.action_card,
-        milestones: [{ id: 'MS-1', name: 'x', date: '2027-01-01' }],
-      },
-    });
-    expect(r.errors.some((e) => e.code === 'AC-004')).toBe(true);
-  });
-
-  it('AC-004 on duplicate milestone id', () => {
-    const m = { id: 'MILESTONE-X-1', name: 'x', date: '2027-01-01' };
-    const r = validateActivityCard({
-      ...VALID,
-      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,
-      action_card: {
-        ...VALID.action_card,
-        milestones: [{ id: 'MILESTONE-X-1', name: 'x', date: '31/01/2027' }],
-      },
-    });
-    expect(r.errors.some((e) => e.code === 'AC-005')).toBe(true);
-  });
-
-  it('AC-006 on malformed delivers_changes entry', () => {
-    const r = validateActivityCard({
-      ...VALID,
-      action_card: {
-        ...VALID.action_card,
-        milestones: [{ id: 'MILESTONE-X-1', name: 'x', date: '2027-01-01', delivers_changes: ['GOAL-1'] }],
-      },
-    });
-    expect(r.errors.some((e) => e.code === 'AC-006')).toBe(true);
-  });
-
-  it('accepts a card with no milestones', () => {
-    const r = validateActivityCard({
-      ...VALID,
-      action_card: { id: 'ACTIVITY_CARD-X-1', project: 'ACTIVITY-X-1' },
-    });
-    expect(r.valid).toBe(true);
-  });
-});