@transitrix/diagrams 1.0.1 → 1.2.0

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

@@ -12,9 +12,40 @@ const minimalValid = {
     ],
 };
 describe('validateActivities', () => {
-    it('ACT-001 — accepts valid notation field', () => {
+    it('ACT-001 — accepts notation: activities (deprecated)', () => {
         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);
+    });
+    it('ACT-001 — accepts notation: action (canonical)', () => {
+        const r = validateActivities({
+            notation: 'action',
+            actions: [
+                { id: 'ACTION-001', name: 'Start', duration: 3 },
+                { id: 'ACTION-002', name: 'End', duration: 2, predecessors: ['ACTION-001'] },
+            ],
+        });
+        expect(r.valid).toBe(true);
+        expect(r.warnings.some(w => w.code === 'DEPRECATED_NOTATION')).toBe(false);
+    });
+    it('ACT-001 — accepts notation: action with deprecated activities: key (emits field warning)', () => {
+        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);
+    });
+    it('ACT-001 — normalises action_type to activity_type for downstream layout', () => {
+        const input = {
+            notation: 'action',
+            actions: [{ id: 'ACTION-001', name: 'Foo', duration: 1, action_type: 'project' }],
+        };
+        const r = validateActivities(input);
+        expect(r.valid).toBe(true);
+        const entry = input.actions[0];
+        expect(entry['activity_type']).toBe('project');
     });
     it('ACT-001 — rejects missing notation', () => {
         const r = validateActivities({ activities: [] });

package/dist/activities/cpm.js

@@ -2,6 +2,15 @@ export function computeCpm(activities) {
     const result = new Map();
     if (activities.length === 0)
         return result;
+    // When no activity carries any duration data, critical path is indeterminate —
+    // return all non-critical so the diagram renders in default grey.
+    const hasDuration = activities.some((a) => (a.duration !== undefined && a.duration !== null) || (a.duration_days !== undefined && a.duration_days !== null));
+    if (!hasDuration) {
+        for (const a of activities) {
+            result.set(a.id, { es: 0, ef: 0, ls: 0, lf: 0, slack: 0, isCritical: false });
+        }
+        return result;
+    }
     // Build successor map and in-degree for topological sort
     const successors = new Map();
     const predecessors = new Map();
@@ -41,7 +50,7 @@ export function computeCpm(activities) {
     const ef = new Map();
     for (const id of topoOrder) {
         const a = actById.get(id);
-        const dur = a.duration ?? 0;
+        const dur = a.duration ?? a.duration_days ?? 0;
         const maxPredEf = Math.max(0, ...(predecessors.get(id) ?? []).map(p => ef.get(p) ?? 0));
         es.set(id, maxPredEf);
         ef.set(id, maxPredEf + dur);
@@ -53,7 +62,7 @@ export function computeCpm(activities) {
     const lf = new Map();
     for (const id of [...topoOrder].reverse()) {
         const a = actById.get(id);
-        const dur = a.duration ?? 0;
+        const dur = a.duration ?? a.duration_days ?? 0;
         const succs = successors.get(id) ?? [];
         const minSuccLs = succs.length === 0 ? projectFinish : Math.min(...succs.map(s => ls.get(s) ?? projectFinish));
         lf.set(id, minSuccLs);

package/dist/activities/gantt.js

@@ -86,7 +86,10 @@ function detectMode(doc, leaves) {
     if (allPinned)
         return 'pinned';
     const hasProjectStart = typeof doc.project?.start_date === 'string' && doc.project.start_date.length > 0;
-    const allHaveDuration = leaves.every((a) => typeof a.duration === 'number' && Number.isFinite(a.duration) && a.duration >= 0);
+    const allHaveDuration = leaves.every((a) => {
+        const d = a.duration ?? a.duration_days;
+        return typeof d === 'number' && Number.isFinite(d) && d >= 0;
+    });
     if (hasProjectStart && allHaveDuration)
         return 'computed';
     return null;
@@ -111,7 +114,7 @@ export function computeGanttLayout(doc) {
         for (const a of leaves) {
             const startDate = a.start_date;
             const endDate = a.end_date;
-            const isMilestone = a.duration === 0 || startDate === endDate;
+            const isMilestone = (a.duration ?? a.duration_days) === 0 || startDate === endDate;
             const bar = {
                 id: a.id,
                 name: a.name,
@@ -134,7 +137,7 @@ export function computeGanttLayout(doc) {
         for (const a of leaves) {
             const c = cpm.get(a.id);
             const es = c?.es ?? 0;
-            const dur = a.duration ?? 0;
+            const dur = a.duration ?? a.duration_days ?? 0;
             const startDate = nthWorkingDay(projectStart, es, calendar);
             const endDate = dur === 0
                 ? startDate

package/dist/activities/types.d.ts

@@ -6,6 +6,7 @@ export interface Activity {
     id: string;
     name: string;
     duration?: number;
+    duration_days?: number;
     activity_type?: string;
     goals?: string[];
     scenario?: string;

package/dist/activities/validate.js

@@ -7,19 +7,31 @@ 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 equal "activities"
+    // ACT-001: notation must be "action" (canonical) or "activities" (deprecated)
     if (raw.notation === undefined) {
         errors.push({ code: 'ACT-001', message: 'notation field is required' });
         return { valid: false, errors, warnings };
     }
-    if (raw.notation !== 'activities') {
-        errors.push({ code: 'ACT-001', message: `notation must be "activities", got "${String(raw.notation)}"` });
+    if (raw.notation !== 'action' && raw.notation !== 'activities') {
+        errors.push({ code: 'ACT-001', message: `notation must be "action", got "${String(raw.notation)}"` });
         return { valid: false, errors, warnings };
     }
-    if (!Array.isArray(raw.activities)) {
-        errors.push({ code: 'SCHEMA_INVALID', message: 'activities must be an array', path: 'activities' });
+    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:"' });
+    }
+    if (!rawArray) {
+        const canonKey = raw.notation === 'action' ? 'actions' : 'activities';
+        errors.push({ code: 'SCHEMA_INVALID', message: `${canonKey} must be an array`, path: canonKey });
         return { valid: false, errors, warnings };
     }
+    // Normalise onto raw.activities for the rest of this function (avoids touching downstream code)
+    if (!Array.isArray(raw.activities))
+        raw.activities = raw.actions;
     // ACT-014 / ACT-015: project.calendar validation (run before per-activity loop;
     // surfaces clearly even when activities also have issues).
     if (raw.project && typeof raw.project === 'object') {
@@ -85,6 +97,10 @@ export function validateActivities(input) {
             continue;
         }
         const act = a;
+        // Normalise action_type → activity_type (canonical rename; old name kept for compat)
+        if (act['action_type'] !== undefined && act['activity_type'] === undefined) {
+            act['activity_type'] = act['action_type'];
+        }
         // ACT-010: reject single-value forms
         if ('goal' in act) {
             errors.push({ code: 'ACT-010', message: `Use "goals: []" array form instead of "goal:" (activity at index ${i})`, path });
@@ -113,7 +129,7 @@ export function validateActivities(input) {
             idSet.add(id);
         }
         // ACT-009: non-negative numeric fields
-        const numericFields = ['duration', 'labor_cost', 'resources_cost', 'effort', 'score', 'sort'];
+        const numericFields = ['duration', 'duration_days', 'labor_cost', 'resources_cost', 'effort', 'score', 'sort'];
         for (const field of numericFields) {
             const val = act[field];
             if (val !== undefined && val !== null) {
@@ -122,8 +138,8 @@ export function validateActivities(input) {
                 }
             }
         }
-        // ACT-011: warn if no duration
-        if (act.duration === undefined || act.duration === null) {
+        // ACT-011: warn if no duration (duration_days is accepted as an alias)
+        if ((act.duration === undefined || act.duration === null) && (act.duration_days === undefined || act.duration_days === null)) {
             warnings.push({ code: 'ACT-011', message: `Activity "${id}" has no duration — cannot participate in CPM analysis`, path });
         }
     }

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

@@ -38,7 +38,7 @@ const UNRELATED = {
     name: 'Other',
     parent: 'ACTIVITY-SOMETHING-ELSE-1',
 };
-const FACTOR = { notation: 'factor', id: 'FACTOR-EU-MDR-1', name: 'EU MDR regulation' };
+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',
@@ -212,6 +212,27 @@ describe('resolveActivityCard', () => {
         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],

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

@@ -18,10 +18,32 @@ const VALID = {
     },
 };
 describe('validateActivityCard', () => {
-    it('accepts a well-formed card', () => {
+    it('accepts a well-formed card (deprecated notation: activity-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);
+    });
+    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);

package/dist/activity-card/resolver.js

@@ -81,9 +81,9 @@ function collectByNotation(docs, notation) {
     return out;
 }
 /**
- * GOAL ids reached by an *active* `activity_goal` relation originating at
- * `fromId`. A relation with a non-null `valid_to` has ended (the activity was
- * re-aimed) and is excluded — the card shows the currently-served goals.
+ * GOAL ids reached by an *active* `action_goal` (or legacy `activity_goal`)
+ * relation originating at `fromId`. A relation with a non-null `valid_to` has
+ * ended (the activity was re-aimed) and is excluded.
  */
 function activeActivityGoals(relations, fromId) {
     const out = [];
@@ -92,7 +92,8 @@ function activeActivityGoals(relations, fromId) {
             continue;
         if (str(doc['notation']) !== 'relation')
             continue;
-        if (str(doc['type']) !== 'activity_goal')
+        const type = str(doc['type']);
+        if (type !== 'action_goal' && type !== 'activity_goal')
             continue;
         if (str(doc['from']) !== fromId)
             continue;
@@ -108,11 +109,8 @@ function activeActivityGoals(relations, fromId) {
     return out;
 }
 /**
- * STAKEHOLDER ids + roles reached by an *active* `activity_stakeholder`
- * relation originating at `fromId`. A relation with a non-null `valid_to` has
- * ended and is excluded, so the card shows the project's currently-engaged
- * stakeholders. The optional `role` field on the relation carries the
- * project-role (initiator | owner | sponsor | project_manager).
+ * STAKEHOLDER ids + roles reached by an *active* `action_stakeholder` (or
+ * legacy `activity_stakeholder`) relation originating at `fromId`.
  */
 function activeActivityStakeholders(relations, fromId) {
     const out = [];
@@ -121,7 +119,8 @@ function activeActivityStakeholders(relations, fromId) {
             continue;
         if (str(doc['notation']) !== 'relation')
             continue;
-        if (str(doc['type']) !== 'activity_stakeholder')
+        const type = str(doc['type']);
+        if (type !== 'action_stakeholder' && type !== 'activity_stakeholder')
             continue;
         if (str(doc['from']) !== fromId)
             continue;
@@ -146,13 +145,20 @@ export function resolveActivityCard(doc, sources) {
         errors.push({ code: 'PC-001', message: 'activity_card.project is missing' });
         return { valid: false, errors, warnings };
     }
-    const activities = collectByNotation(sources.elements, 'activity');
-    const projectRec = activities.get(projectId);
-    // PC-001 — project must resolve to an admitted ACTIVITY element in canon.
+    // Look up by canonical `notation: action` first, then legacy `notation: activity`.
+    const actionElements = collectByNotation(sources.elements, 'action');
+    const activityElements = collectByNotation(sources.elements, 'activity');
+    const allActionElements = new Map([...activityElements, ...actionElements]); // action wins on duplicate id
+    const projectRec = allActionElements.get(projectId);
+    // PC-001 — project must resolve to an admitted ACTION (or legacy ACTIVITY)
+    // element after exhausting the canonical resolution scope (§6.1).
     if (!projectRec) {
         errors.push({
             code: 'PC-001',
-            message: `activity_card.project "${projectId}" does not resolve to an ACTIVITY element in the canon element store`,
+            message: `action_card.project "${projectId}" not found after searching ` +
+                `canon/elements/** and canon/views/activities/** — ` +
+                `add a YAML file with notation: action and id: "${projectId}" ` +
+                `(e.g. canon/elements/05_implementation/actions/${projectId}.yaml)`,
         });
         return { valid: false, errors, warnings };
     }
@@ -247,9 +253,10 @@ export function resolveActivityCard(doc, sources) {
         return { valid: false, errors, warnings };
     }
     // ── Motivation chain — expand against canon DRIVER / GOAL / CHANGE elements ──
-    // Note: YAML corpus still uses `notation: factor` and `goal.factors` field names;
-    // the YAML keys are stable. The resolved TypeScript API uses "driver/driverIds".
-    const driverElems = collectByNotation(sources.elements, 'factor');
+    // Canon elements use `notation: driver`; `notation: factor` accepted for backward compat.
+    const driverElemsLegacy = collectByNotation(sources.elements, 'factor');
+    const driverElemsNew = collectByNotation(sources.elements, 'driver');
+    const driverElems = new Map([...driverElemsLegacy, ...driverElemsNew]);
     const goalElems = collectByNotation(sources.elements, 'goal');
     const changeElems = collectByNotation(sources.elements, 'change');
     const changes = [];
@@ -322,14 +329,15 @@ export function resolveActivityCard(doc, sources) {
         return a.observed_at < b.observed_at ? -1 : a.observed_at > b.observed_at ? 1 : 0;
     });
     // ── Child activities — parent = project id ──────────────────────────────────
+    // Look in both `notation: action` and legacy `notation: activity` elements.
     const childActivities = [];
-    for (const [id, rec] of activities) {
+    for (const [id, rec] of allActionElements) {
         if (str(rec['parent']) !== projectId)
             continue;
         childActivities.push({
             id,
             name: str(rec['name']) ?? id,
-            activity_type: str(rec['activity_type']),
+            activity_type: str(rec['action_type']) ?? str(rec['activity_type']),
             start_date: str(rec['start_date']),
             end_date: str(rec['end_date']),
             owner: str(rec['owner']),
@@ -372,7 +380,7 @@ export function resolveActivityCard(doc, sources) {
         valid_to: validToOk ? validToRaw : undefined,
         start_date: str(projectRec['start_date']),
         end_date: str(projectRec['end_date']),
-        activity_type: str(projectRec['activity_type']),
+        activity_type: str(projectRec['action_type']) ?? str(projectRec['activity_type']),
         status: str(projectRec['status']),
     };
     const resolved = {

package/dist/activity-card/validate.js

@@ -21,8 +21,8 @@
 //   HDR-002  wrong `notation`             (CONTRACT.md §2)
 //   PC-001   `project` missing or malformed (the document-local half; the
 //            "does not resolve" half is emitted by the resolver)
-const ACTIVITY_CARD_ID_RE = /^ACTIVITY_CARD(-[A-Z0-9][A-Z0-9_]*)*-\d+$/;
-const ACTIVITY_ID_RE = /^ACTIVITY(-[A-Z0-9][A-Z0-9_]*)*-\d+$/;
+const ACTIVITY_CARD_ID_RE = /^(ACTIVITY_CARD|ACTION_CARD)(-[A-Z0-9][A-Z0-9_]*)*-\d+$/;
+const ACTIVITY_ID_RE = /^(ACTIVITY|ACTION)(-[A-Z0-9][A-Z0-9_]*)*-\d+$/;
 const MILESTONE_ID_RE = /^MILESTONE(-[A-Z0-9][A-Z0-9_]*)*-\d+$/;
 const CHANGE_ID_RE = /^CHANGE(-[A-Z0-9][A-Z0-9_]*)*-\d+$/;
 const DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
@@ -40,36 +40,47 @@ export function validateActivityCard(input) {
     if (!('notation' in raw)) {
         errors.push({ code: 'HDR-001', message: 'notation field is required' });
     }
-    else if (raw['notation'] !== 'activity-card') {
+    else if (raw['notation'] !== 'action-card' && raw['notation'] !== 'activity-card') {
         errors.push({
             code: 'HDR-002',
-            message: `notation must be "activity-card", got "${String(raw['notation'])}"`,
+            message: `notation must be "action-card", got "${String(raw['notation'])}"`,
         });
     }
-    // ── activity_card block ─────────────────────────────────────────────────────
-    const block = raw['activity_card'];
+    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:"' });
+    }
+    const block = rawBlock;
     if (!block || typeof block !== 'object' || Array.isArray(block)) {
-        errors.push({ code: 'AC-001', message: 'Missing required root key: activity_card (object)' });
+        errors.push({ code: 'AC-001', message: 'Missing required root key: action_card (object)' });
         return { valid: false, errors, warnings };
     }
+    // Normalise onto activity_card for downstream (resolver reads doc.activity_card)
+    if (raw['activity_card'] === undefined)
+        raw['activity_card'] = rawBlock;
     const card = block;
     if (!isNonEmptyString(card['id'])) {
-        errors.push({ code: 'AC-002', message: 'activity_card.id is required' });
+        errors.push({ code: 'AC-002', message: 'action_card.id is required' });
     }
     else if (!ACTIVITY_CARD_ID_RE.test(card['id'])) {
         errors.push({
             code: 'AC-002',
-            message: `activity_card.id "${card['id']}" must match ACTIVITY_CARD-[<middle>-]<INTEGER>`,
+            message: `action_card.id "${card['id']}" must match ACTION_CARD-[<middle>-]<INTEGER> (or legacy ACTIVITY_CARD-…)`,
         });
     }
     // PC-001 (document-local half): project present + well-formed.
     if (!isNonEmptyString(card['project'])) {
-        errors.push({ code: 'PC-001', message: 'activity_card.project is required (an ACTIVITY-… id)' });
+        errors.push({ code: 'PC-001', message: 'action_card.project is required (an ACTION-… id)' });
     }
     else if (!ACTIVITY_ID_RE.test(card['project'])) {
         errors.push({
             code: 'PC-001',
-            message: `activity_card.project "${card['project']}" is malformed; must match ACTIVITY-[<middle>-]<INTEGER>`,
+            message: `action_card.project "${card['project']}" is malformed; must match ACTION-[<middle>-]<INTEGER> (or legacy ACTIVITY-…)`,
         });
     }
     if (card['description'] !== undefined && typeof card['description'] !== 'string') {

package/dist/capability-map/index.d.ts

@@ -1,2 +1,6 @@
 export type { CapabilityType, CapabilityNode, CapabilityMapHeader, CapabilityMapFile, } from './types.js';
 export { validateCapabilityMap } from './validate.js';
+export type { CapabilityTreeNode, CapabilityTreeEdge, CapabilityTreeLevelCounts, CapabilityTreeLayout, } from './layout-tree.js';
+export { layoutCapabilityTree, TREE_NODE_WIDTH, TREE_NODE_HEIGHT, TREE_RANK_SEP, TREE_NODE_SEP } from './layout-tree.js';
+export type { RenderCapabilityTreeOptions } from './render-capability-tree.js';
+export { renderCapabilityTreeSvg } from './render-capability-tree.js';

package/dist/capability-map/index.js

@@ -1 +1,3 @@
 export { validateCapabilityMap } from './validate.js';
+export { layoutCapabilityTree, TREE_NODE_WIDTH, TREE_NODE_HEIGHT, TREE_RANK_SEP, TREE_NODE_SEP } from './layout-tree.js';
+export { renderCapabilityTreeSvg } from './render-capability-tree.js';

package/dist/capability-map/layout-tree.d.ts

@@ -0,0 +1,42 @@
+import type { CapabilityNode, CapabilityMapHeader } from './types.js';
+export declare const TREE_NODE_WIDTH = 250;
+export declare const TREE_NODE_HEIGHT = 64;
+/** Gap between sibling columns (node width + rank sep = 330px, matching DSM). */
+export declare const TREE_RANK_SEP = 80;
+/** Vertical gap between sibling nodes. */
+export declare const TREE_NODE_SEP = 24;
+export interface CapabilityTreeNode {
+    id: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    data: CapabilityNode;
+    depth: number;
+    hasChildren: boolean;
+    isCollapsed: boolean;
+}
+export interface CapabilityTreeEdge {
+    source: string;
+    target: string;
+}
+export interface CapabilityTreeLevelCounts {
+    /** Nodes at depth 0–2 (pink band). */
+    band0: number;
+    /** Nodes at depth 3–4 (yellow band). */
+    band1: number;
+    /** Nodes at depth 5+ (blue band). */
+    band2: number;
+}
+export interface CapabilityTreeLayout {
+    nodes: CapabilityTreeNode[];
+    edges: CapabilityTreeEdge[];
+    bounds: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    levelCounts: CapabilityTreeLevelCounts;
+}
+export declare function layoutCapabilityTree(map: CapabilityMapHeader, collapsedIds?: Set<string>): CapabilityTreeLayout;

package/dist/capability-map/layout-tree.js

@@ -0,0 +1,65 @@
+export const TREE_NODE_WIDTH = 250;
+export const TREE_NODE_HEIGHT = 64;
+/** Gap between sibling columns (node width + rank sep = 330px, matching DSM). */
+export const TREE_RANK_SEP = 80;
+/** Vertical gap between sibling nodes. */
+export const TREE_NODE_SEP = 24;
+export function layoutCapabilityTree(map, collapsedIds = new Set()) {
+    const nodes = [];
+    const edges = [];
+    const colNextY = new Map();
+    function getNextY(col) {
+        return colNextY.get(col) ?? 0;
+    }
+    function advanceY(col, delta) {
+        colNextY.set(col, (colNextY.get(col) ?? 0) + delta);
+    }
+    function placeNode(node, depth) {
+        const isCollapsed = collapsedIds.has(node.id);
+        const hasChildren = Boolean(node.children?.length);
+        const visibleChildren = !isCollapsed && node.children?.length ? node.children : [];
+        const x = depth * (TREE_NODE_WIDTH + TREE_RANK_SEP);
+        if (visibleChildren.length === 0) {
+            const y = getNextY(depth);
+            advanceY(depth, TREE_NODE_HEIGHT + TREE_NODE_SEP);
+            nodes.push({ id: node.id, x, y, width: TREE_NODE_WIDTH, height: TREE_NODE_HEIGHT, data: node, depth, hasChildren, isCollapsed });
+            return { top: y, bottom: y + TREE_NODE_HEIGHT };
+        }
+        const childSpans = [];
+        for (const child of visibleChildren) {
+            childSpans.push(placeNode(child, depth + 1));
+            edges.push({ source: node.id, target: child.id });
+        }
+        const spanTop = Math.min(...childSpans.map(s => s.top));
+        const spanBottom = Math.max(...childSpans.map(s => s.bottom));
+        const parentY = spanTop + (spanBottom - spanTop) / 2 - TREE_NODE_HEIGHT / 2;
+        const curColY = getNextY(depth);
+        const finalY = Math.max(parentY, curColY);
+        advanceY(depth, finalY - curColY + TREE_NODE_HEIGHT + TREE_NODE_SEP);
+        nodes.push({ id: node.id, x, y: finalY, width: TREE_NODE_WIDTH, height: TREE_NODE_HEIGHT, data: node, depth, hasChildren, isCollapsed });
+        return { top: Math.min(finalY, spanTop), bottom: Math.max(finalY + TREE_NODE_HEIGHT, spanBottom) };
+    }
+    for (const root of map.capabilities) {
+        placeNode(root, 0);
+        for (const [col, y] of colNextY) {
+            colNextY.set(col, y + TREE_NODE_SEP);
+        }
+    }
+    if (nodes.length === 0) {
+        return { nodes: [], edges: [], bounds: { x: 0, y: 0, width: 0, height: 0 }, levelCounts: { band0: 0, band1: 0, band2: 0 } };
+    }
+    const minX = Math.min(...nodes.map(n => n.x));
+    const minY = Math.min(...nodes.map(n => n.y));
+    const maxX = Math.max(...nodes.map(n => n.x + n.width));
+    const maxY = Math.max(...nodes.map(n => n.y + n.height));
+    const levelCounts = { band0: 0, band1: 0, band2: 0 };
+    for (const n of nodes) {
+        if (n.depth <= 2)
+            levelCounts.band0++;
+        else if (n.depth <= 4)
+            levelCounts.band1++;
+        else
+            levelCounts.band2++;
+    }
+    return { nodes, edges, bounds: { x: minX, y: minY, width: maxX - minX, height: maxY - minY }, levelCounts };
+}

package/dist/capability-map/render-capability-tree.d.ts

@@ -0,0 +1,15 @@
+import type { CapabilityMapHeader } from './types.js';
+export interface RenderCapabilityTreeOptions {
+    collapsedIds?: Set<string>;
+    curvature?: number;
+}
+/**
+ * Renders a capability-map as a left-to-right SVG node tree with DSM-matching
+ * visual design: depth-banded fills, maturity badges, and +/− collapse buttons.
+ *
+ * The SVG uses CSS classes (`tree-level-N`, `tree-maturity-N`, `tree-collapse-btn`)
+ * that must be resolved by the host's stylesheet (injected via `diagramClassCss()`
+ * in themes.ts). Collapse buttons carry `data-node-id` / `data-collapsed` attributes
+ * for the webview click handler.
+ */
+export declare function renderCapabilityTreeSvg(map: CapabilityMapHeader, opts?: RenderCapabilityTreeOptions): string;