@transitrix/diagrams 1.7.6 → 1.8.2

package/dist/__tests__/node-size-presets.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/node-size-presets.test.js

@@ -0,0 +1,30 @@
+import { describe, expect, it } from 'vitest';
+import { ACTION_NODE_SIZE, BLOCKS_LEAF_SIZE, CAPABILITY_MAP_NODE_SIZE, DGCA_NODE_SIZE, ENTITY_NODE_HEIGHT, ENTITY_NODE_SIZE, ENTITY_NODE_WIDTH, GOALS_NODE_SIZE, PROCESS_BLUEPRINT_SIZE, resolveGoalsNodeSize, } from '../node-size-presets.js';
+describe('node-size-presets', () => {
+    it('uses shared width and height tiers for entity nodes', () => {
+        expect(ENTITY_NODE_WIDTH).toEqual({ compact: 200, normal: 250, wide: 320 });
+        expect(ENTITY_NODE_HEIGHT).toEqual({ compact: 72, normal: 80, wide: 96 });
+        expect(ENTITY_NODE_SIZE.normal).toEqual({ width: 250, height: 80 });
+        expect(ENTITY_NODE_SIZE.compact).toEqual({ width: 200, height: 72 });
+        expect(ENTITY_NODE_SIZE.wide).toEqual({ width: 320, height: 96 });
+    });
+    it('exposes the same entity sizes for every box-based notation', () => {
+        for (const table of [GOALS_NODE_SIZE, DGCA_NODE_SIZE, BLOCKS_LEAF_SIZE, ACTION_NODE_SIZE]) {
+            expect(table).toBe(ENTITY_NODE_SIZE);
+            expect(table.normal).toEqual(ENTITY_NODE_SIZE.normal);
+        }
+        expect(CAPABILITY_MAP_NODE_SIZE.normal).toEqual({
+            nodeWidth: ENTITY_NODE_WIDTH.normal,
+            nodeHeight: ENTITY_NODE_HEIGHT.normal,
+        });
+    });
+    it('scales wide above normal and compact below', () => {
+        expect(resolveGoalsNodeSize('wide').height).toBeGreaterThan(resolveGoalsNodeSize('normal').height);
+        expect(resolveGoalsNodeSize('compact').height).toBeLessThan(resolveGoalsNodeSize('normal').height);
+        expect(resolveGoalsNodeSize('wide').width).toBeGreaterThan(resolveGoalsNodeSize('normal').width);
+    });
+    it('scales process blueprint from the same tier ratios', () => {
+        expect(PROCESS_BLUEPRINT_SIZE.wide.stageColumnWidth).toBeGreaterThan(PROCESS_BLUEPRINT_SIZE.normal.stageColumnWidth);
+        expect(PROCESS_BLUEPRINT_SIZE.compact.goalRowHeight).toBeLessThan(PROCESS_BLUEPRINT_SIZE.normal.goalRowHeight);
+    });
+});

package/dist/activities/layout.js

@@ -1,10 +1,10 @@
 import { computeCpm } from './cpm.js';
-const NODE_W = 200;
-const NODE_H = 80;
+const DEFAULT_NODE_W = 250;
+const DEFAULT_NODE_H = 80;
 const H_GAP = 80;
 const V_GAP = 24;
 export function layoutActivities(doc, options = {}) {
-    const { horizontalGap = H_GAP, verticalGap = V_GAP } = options;
+    const { horizontalGap = H_GAP, verticalGap = V_GAP, nodeWidth = DEFAULT_NODE_W, nodeHeight = DEFAULT_NODE_H, } = options;
     const activities = doc.activities;
     if (activities.length === 0) {
         return { nodes: [], edges: [], bounds: { x: 0, y: 0, width: 0, height: 0 } };
@@ -64,21 +64,21 @@ export function layoutActivities(doc, options = {}) {
     const colCount = Math.max(0, ...[...cols.keys()]) + 1;
     for (let c = 0; c < colCount; c++) {
         const list = cols.get(c) ?? [];
-        const x = c * (NODE_W + horizontalGap);
+        const x = c * (nodeWidth + horizontalGap);
         let y = 0;
         for (const a of list) {
             const node = {
                 id: a.id,
                 x,
                 y,
-                width: NODE_W,
-                height: NODE_H,
+                width: nodeWidth,
+                height: nodeHeight,
                 data: a,
                 cpm: cpm.get(a.id),
             };
             nodes.push(node);
             nodeMap.set(a.id, node);
-            y += NODE_H + verticalGap;
+            y += nodeHeight + verticalGap;
         }
     }
     // Build edges

package/dist/activities/types.d.ts

@@ -86,6 +86,10 @@ export interface ActivitiesLayoutOptions {
     horizontalGap?: number;
     /** Vertical gap (px) between stacked activity nodes. Default matches the historical hardcoded value. */
     verticalGap?: number;
+    /** Activity node width (px). Default 200. */
+    nodeWidth?: number;
+    /** Activity node height (px). Default 80. */
+    nodeHeight?: number;
 }
 export type GanttMode = 'computed' | 'pinned';
 export type GanttBarKind = 'leaf' | 'milestone' | 'phase';

package/dist/blocks/__tests__/layout.test.js

@@ -108,8 +108,8 @@ describe('layoutNestedBlocks', () => {
             },
         });
         const a = layout.blocks[0];
-        expect(a.width).toBe(160);
-        expect(a.height).toBe(72);
+        expect(a.width).toBe(250);
+        expect(a.height).toBe(80);
     });
     it('honours custom layout options', () => {
         const layout = layoutNestedBlocks({

package/dist/blocks/layout.js

@@ -1,6 +1,7 @@
+import { ENTITY_NODE_SIZE } from '../node-size-presets.js';
 const DEFAULTS = {
-    leafWidth: 160,
-    leafHeight: 72,
+    leafWidth: ENTITY_NODE_SIZE.normal.width,
+    leafHeight: ENTITY_NODE_SIZE.normal.height,
     padding: 12,
     headerHeight: 28,
     childGap: 12,

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

@@ -1,6 +1,6 @@
 import { getLevel, getParentAddress } from './address.js';
 const DEFAULT_NODE_WIDTH = 250;
-const DEFAULT_NODE_HEIGHT = 64;
+const DEFAULT_NODE_HEIGHT = 80;
 const DEFAULT_RANK_SEP = 80;
 const DEFAULT_NODE_SEP = 24;
 /** Width of the virtual organisation-root node — narrower than a capability

package/dist/capability-map/dsm-schema.d.ts

@@ -1,5 +1,5 @@
 /**
- * Types for the DSM-migration capability map (docs/extraction/capability-map.md).
+// Types for the DSM-migration capability map (docs/internal/extraction/capability-map.md).
  *
  * Distinct from `./types.ts` (`CapabilityNode`/`CapabilityMapFile`), which is
  * Transitrix's own native `*.capability-map.transitrix.yaml` notation — a

package/dist/capability-map/dsm-schema.js

@@ -1,5 +1,5 @@
 /**
- * Types for the DSM-migration capability map (docs/extraction/capability-map.md).
+// Types for the DSM-migration capability map (docs/internal/extraction/capability-map.md).
  *
  * Distinct from `./types.ts` (`CapabilityNode`/`CapabilityMapFile`), which is
  * Transitrix's own native `*.capability-map.transitrix.yaml` notation — a

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

@@ -1,6 +1,6 @@
 import type { CapabilityNode, CapabilityMapHeader } from './types.js';
 export declare const TREE_NODE_WIDTH = 250;
-export declare const TREE_NODE_HEIGHT = 64;
+export declare const TREE_NODE_HEIGHT = 80;
 /** Gap between sibling columns (node width + rank sep = 330px, matching DSM). */
 export declare const TREE_RANK_SEP = 80;
 /** Vertical gap between sibling nodes. */
@@ -39,4 +39,8 @@ export interface CapabilityTreeLayout {
     };
     levelCounts: CapabilityTreeLevelCounts;
 }
-export declare function layoutCapabilityTree(map: CapabilityMapHeader, collapsedIds?: Set<string>): CapabilityTreeLayout;
+export interface CapabilityTreeLayoutOptions {
+    nodeWidth?: number;
+    nodeHeight?: number;
+}
+export declare function layoutCapabilityTree(map: CapabilityMapHeader, collapsedIds?: Set<string>, options?: CapabilityTreeLayoutOptions): CapabilityTreeLayout;

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

@@ -1,10 +1,12 @@
 export const TREE_NODE_WIDTH = 250;
-export const TREE_NODE_HEIGHT = 64;
+export const TREE_NODE_HEIGHT = 80;
 /** 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()) {
+export function layoutCapabilityTree(map, collapsedIds = new Set(), options = {}) {
+    const nodeWidth = options.nodeWidth ?? TREE_NODE_WIDTH;
+    const nodeHeight = options.nodeHeight ?? TREE_NODE_HEIGHT;
     const nodes = [];
     const edges = [];
     const colNextY = new Map();
@@ -18,12 +20,12 @@ export function layoutCapabilityTree(map, collapsedIds = new Set()) {
         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);
+        const x = depth * (nodeWidth + 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 };
+            advanceY(depth, nodeHeight + TREE_NODE_SEP);
+            nodes.push({ id: node.id, x, y, width: nodeWidth, height: nodeHeight, data: node, depth, hasChildren, isCollapsed });
+            return { top: y, bottom: y + nodeHeight };
         }
         const childSpans = [];
         for (const child of visibleChildren) {
@@ -32,12 +34,12 @@ export function layoutCapabilityTree(map, collapsedIds = new Set()) {
         }
         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 parentY = spanTop + (spanBottom - spanTop) / 2 - nodeHeight / 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) };
+        advanceY(depth, finalY - curColY + nodeHeight + TREE_NODE_SEP);
+        nodes.push({ id: node.id, x, y: finalY, width: nodeWidth, height: nodeHeight, data: node, depth, hasChildren, isCollapsed });
+        return { top: Math.min(finalY, spanTop), bottom: Math.max(finalY + nodeHeight, spanBottom) };
     }
     for (const root of map.capabilities) {
         placeNode(root, 0);

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

@@ -1,15 +1,8 @@
 import type { CapabilityMapHeader } from './types.js';
+import { type NodeSizePreset } from '../node-size-presets.js';
 export interface RenderCapabilityTreeOptions {
     collapsedIds?: Set<string>;
     curvature?: number;
+    nodeSizePreset?: NodeSizePreset;
 }
-/**
- * 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;

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

@@ -1,11 +1,11 @@
-import { layoutCapabilityTree, TREE_NODE_WIDTH, TREE_NODE_HEIGHT, TREE_NODE_SEP } from './layout-tree.js';
+import { layoutCapabilityTree, TREE_NODE_SEP } from './layout-tree.js';
 import { horizontalCubicEdgePath, DEFAULT_EDGE_CURVATURE } from '../edge-path.js';
+import { parseNodeSizePreset, resolveCapabilityMapNodeSize } from '../node-size-presets.js';
+import { maxCharsForInnerWidth, truncateLine } from '../webview/entity-text-layout.js';
 import { escXml } from '../webview/render-util.js';
 const PAD = 24;
 const BTN_R = 8;
 const LEGEND_H = 40;
-const LABEL_MAX_CHARS = 28;
-const LABEL_TRIM_CHARS = 26;
 const BAND_LABELS = ['Levels 0–2', 'Levels 3–4', 'Levels 5+'];
 function depthBand(depth) {
     if (depth <= 2)
@@ -14,21 +14,10 @@ function depthBand(depth) {
         return 1;
     return 2;
 }
-function truncate(s, max, trim) {
-    return s.length > max ? s.slice(0, trim) + '…' : s;
-}
-/**
- * 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 function renderCapabilityTreeSvg(map, opts = {}) {
-    const { collapsedIds = new Set(), curvature = DEFAULT_EDGE_CURVATURE } = opts;
-    const layout = layoutCapabilityTree(map, collapsedIds);
+    const { collapsedIds = new Set(), curvature = DEFAULT_EDGE_CURVATURE, nodeSizePreset = 'normal' } = opts;
+    const nodeSize = resolveCapabilityMapNodeSize(parseNodeSizePreset(nodeSizePreset));
+    const layout = layoutCapabilityTree(map, collapsedIds, nodeSize);
     if (layout.nodes.length === 0) {
         return `<svg xmlns="http://www.w3.org/2000/svg" width="0" height="0" viewBox="0 0 0 0"></svg>`;
     }
@@ -53,26 +42,25 @@ export function renderCapabilityTreeSvg(map, opts = {}) {
         const y = n.y + oy;
         const band = depthBand(n.depth);
         const mat = Math.max(1, Math.min(5, n.data.current_maturity | 0));
-        const nameText = truncate(n.data.name, LABEL_MAX_CHARS, LABEL_TRIM_CHARS);
-        const nameTitle = n.data.name.length > LABEL_MAX_CHARS ? escXml(n.data.name) : '';
-        // Maturity badge: left side of node
         const badgeW = 28;
         const badgeH = 18;
+        const textAreaW = Math.max(0, n.width - badgeW - 26);
+        const maxChars = maxCharsForInnerWidth(textAreaW, 7);
+        const nameText = truncateLine(n.data.name, maxChars);
+        const nameTitle = n.data.name.length > maxChars ? escXml(n.data.name) : '';
         const badgeX = x + 10;
-        const badgeY = y + (TREE_NODE_HEIGHT - badgeH) / 2;
-        // Text area: right of badge
+        const badgeY = y + (n.height - badgeH) / 2;
         const textX = badgeX + badgeW + 8;
-        const nameY = y + TREE_NODE_HEIGHT / 2 - 8;
-        const idY = y + TREE_NODE_HEIGHT / 2 + 9;
-        // Collapse button: centered on right edge of node
-        const btnCx = x + TREE_NODE_WIDTH;
-        const btnCy = y + TREE_NODE_HEIGHT / 2;
+        const nameY = y + n.height / 2 - 8;
+        const idY = y + n.height / 2 + 9;
+        const btnCx = x + n.width;
+        const btnCy = y + n.height / 2;
         const collapseBtn = n.hasChildren
             ? `<circle class="tree-collapse-btn" cx="${btnCx}" cy="${btnCy}" r="${BTN_R}" data-node-id="${escXml(n.id)}" data-collapsed="${n.isCollapsed}"/>
   <text class="tree-collapse-lbl" x="${btnCx}" y="${btnCy}" text-anchor="middle">${n.isCollapsed ? '+' : '−'}</text>`
             : '';
         return `<g${nameTitle ? ` title="${nameTitle}"` : ''}>
-  <rect class="tree-level-${band}" x="${x}" y="${y}" width="${TREE_NODE_WIDTH}" height="${TREE_NODE_HEIGHT}" rx="11" stroke="var(--ts-node-stroke,#94a3b8)" stroke-width="3"/>
+  <rect class="tree-level-${band}" x="${x}" y="${y}" width="${n.width}" height="${n.height}" rx="11" stroke="var(--ts-node-stroke,#94a3b8)" stroke-width="3"/>
   <rect class="tree-maturity-${mat}" x="${badgeX}" y="${badgeY}" width="${badgeW}" height="${badgeH}" rx="4"/>
   <text class="text-pill" x="${badgeX + badgeW / 2}" y="${badgeY + badgeH / 2}" text-anchor="middle" fill="white">L${mat}</text>
   <text class="text-primary" x="${textX}" y="${nameY}" dominant-baseline="central">${escXml(nameText)}</text>

package/dist/fgca/preview-layout.d.ts

@@ -23,7 +23,7 @@ export interface FGCAPreviewActivity {
     name: string;
     goal_id?: number | string | null;
 }
-/** Structural input the preview layout needs — a subset of the parsed FGCA/FGA doc. */
+/** Structural input the preview layout needs — a subset of the parsed DGCA/DGA doc. */
 export interface FGCAPreviewDoc {
     factors: FGCAPreviewFactor[];
     goals: FGCAPreviewGoal[];
@@ -31,7 +31,7 @@ export interface FGCAPreviewDoc {
     activities: FGCAPreviewActivity[];
 }
 export interface FGCAPreviewLayoutOptions {
-    /** FGA hides the Changes column and links Goal → Activity directly. */
+    /** DGA hides the Changes column and links Goal → Activity directly. */
     hideChanges?: boolean;
     /** Horizontal gap (px) between columns. Default matches the historical hardcoded value. */
     colGap?: number;
@@ -39,11 +39,15 @@ export interface FGCAPreviewLayoutOptions {
     rowGap?: number;
     /** Trim to a level cap or a single root goal (vkgeorgia/strategy#77). Defaults to 'all'. */
     scope?: Scope;
+    /** Entity node width (px). Default {@link FGCA_NODE_W}. */
+    nodeWidth?: number;
+    /** Entity node height (px). Default {@link FGCA_NODE_H}. */
+    nodeHeight?: number;
 }
 /**
- * Trims an FGCA/FGA doc to a scope (vkgeorgia/strategy#77).
+ * Trims a DGCA/DGA doc to a scope.
  *
- * FGCA/FGA goals are flat (no parent_id), so:
+ * DGCA/DGA goals are flat (no parent_id), so:
  *   - 'level' → goals with `(level ?? 0) <= maxLevel`.
  *   - 'root'  → the single goal whose id matches `rootGoalId` (empty when absent).
  *
@@ -78,8 +82,8 @@ export interface FGCAPreviewLayout {
     width: number;
     height: number;
 }
-export declare const FGCA_NODE_W = 220;
-export declare const FGCA_NODE_H = 72;
+export declare const FGCA_NODE_W: number;
+export declare const FGCA_NODE_H: number;
 export declare const FGCA_HEADER_H = 32;
 export declare const FGCA_PAD = 20;
 export declare const FGCA_DEFAULT_COL_GAP = 160;

package/dist/fgca/preview-layout.js

@@ -1,15 +1,16 @@
-// Pure column-layout geometry for the static FGCA / FGA previews.
+// Pure column-layout geometry for the static DGCA / DGA previews.
 //
-// This is the layout the Studio extension's `fgca-preview.ts` renders to SVG
+// This is the layout the Studio extension's `dgca-preview.ts` renders to SVG
 // (NOT the ReactFlow `buildFGCALayout` in `./layout.ts`, which targets the
 // interactive web UI). It lives here — rather than inline in the extension —
 // so the gap geometry is unit-testable: the extension has no test harness.
 //
 // No React, no DOM, no vscode. Safe to call in Node.js or a test environment.
+import { ENTITY_NODE_SIZE } from '../node-size-presets.js';
 /**
- * Trims an FGCA/FGA doc to a scope (vkgeorgia/strategy#77).
+ * Trims a DGCA/DGA doc to a scope.
  *
- * FGCA/FGA goals are flat (no parent_id), so:
+ * DGCA/DGA goals are flat (no parent_id), so:
  *   - 'level' → goals with `(level ?? 0) <= maxLevel`.
  *   - 'root'  → the single goal whose id matches `rootGoalId` (empty when absent).
  *
@@ -38,19 +39,19 @@ export function selectScopedFGCA(doc, scope) {
         activities: visibleActivities,
     };
 }
-// Fixed node + frame geometry. Only the inter-node gaps are user-configurable
-// (vkgeorgia/strategy#75); node size and padding stay constant.
-export const FGCA_NODE_W = 220;
-export const FGCA_NODE_H = 72;
+// Default node + frame geometry. Inter-node gaps are user-configurable via
+// Inter-node gaps are user-configurable via spacing settings; node size uses presets.
+export const FGCA_NODE_W = ENTITY_NODE_SIZE.normal.width;
+export const FGCA_NODE_H = ENTITY_NODE_SIZE.normal.height;
 export const FGCA_HEADER_H = 32;
 export const FGCA_PAD = 20;
 export const FGCA_DEFAULT_COL_GAP = 160;
 export const FGCA_DEFAULT_ROW_GAP = 20;
 export function layoutFGCAPreview(inputDoc, options = {}) {
-    const { hideChanges = false, colGap = FGCA_DEFAULT_COL_GAP, rowGap = FGCA_DEFAULT_ROW_GAP, scope = { mode: 'all' }, } = options;
+    const { hideChanges = false, colGap = FGCA_DEFAULT_COL_GAP, rowGap = FGCA_DEFAULT_ROW_GAP, scope = { mode: 'all' }, nodeWidth = FGCA_NODE_W, nodeHeight = FGCA_NODE_H, } = options;
     // Trim to scope first; everything below lays out the visible subset only.
     const doc = selectScopedFGCA(inputDoc, scope);
-    const colStride = FGCA_NODE_W + colGap;
+    const colStride = nodeWidth + colGap;
     const cols = hideChanges
         ? ['driver', 'goal', 'activity']
         : ['driver', 'goal', 'change', 'activity'];
@@ -110,7 +111,7 @@ export function layoutFGCAPreview(inputDoc, options = {}) {
     const nodeMap = new Map();
     const nodes = [];
     const columns = [];
-    const yCenters = new Map(); // nodeId → y + FGCA_NODE_H / 2
+    const yCenters = new Map(); // nodeId → y + nodeHeight / 2
     for (let ci = 0; ci < cols.length; ci++) {
         const col = cols[ci];
         const x = FGCA_PAD + ci * colStride;
@@ -121,8 +122,8 @@ export function layoutFGCAPreview(inputDoc, options = {}) {
             const node = { id: item.id, x, y, label: item.label, col };
             nodes.push(node);
             nodeMap.set(item.id, node);
-            yCenters.set(item.id, y + FGCA_NODE_H / 2);
-            y += FGCA_NODE_H + rowGap;
+            yCenters.set(item.id, y + nodeHeight / 2);
+            y += nodeHeight + rowGap;
         }
     }
     const edges = [];
@@ -131,7 +132,7 @@ export function layoutFGCAPreview(inputDoc, options = {}) {
         const t = nodeMap.get(targetId);
         if (!s || !t)
             return;
-        edges.push({ sx: s.x + FGCA_NODE_W, sy: s.y + FGCA_NODE_H / 2, tx: t.x, ty: t.y + FGCA_NODE_H / 2 });
+        edges.push({ sx: s.x + nodeWidth, sy: s.y + nodeHeight / 2, tx: t.x, ty: t.y + nodeHeight / 2 });
     }
     for (const g of doc.goals) {
         for (const f of (g.factor ?? []))
@@ -164,7 +165,7 @@ export function layoutFGCAPreview(inputDoc, options = {}) {
             }
         }
     }
-    const maxNodeBottom = nodes.reduce((m, n) => Math.max(m, n.y + FGCA_NODE_H), FGCA_PAD + FGCA_HEADER_H + rowGap + FGCA_NODE_H);
+    const maxNodeBottom = nodes.reduce((m, n) => Math.max(m, n.y + nodeHeight), FGCA_PAD + FGCA_HEADER_H + rowGap + nodeHeight);
     const width = FGCA_PAD * 2 + cols.length * colStride - colGap;
     const height = maxNodeBottom + FGCA_PAD;
     return { nodes, edges, columns, width, height };

package/dist/node-size-presets.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Block/cell size presets for diagram renderers.
+ *
+ * Entity nodes (Goals, DGCA/DGA, Blocks leaves, Activities, Capability Map)
+ * share one width × height ladder. Heights use fixed tiers (72 / 80 / 96 px)
+ * so name + type + id never collide; widths scale independently (200 / 250 / 320).
+ *
+ * Process Blueprint uses a separate cell grid, scaled from the same tiers.
+ */
+export type NodeSizePreset = 'compact' | 'normal' | 'wide';
+export declare const NODE_SIZE_PRESET_VALUES: readonly NodeSizePreset[];
+export interface BoxDimensions {
+    width: number;
+    height: number;
+}
+export interface BlocksLeafDimensions extends BoxDimensions {
+}
+export interface ProcessBlueprintDimensions {
+    legendColumnWidth: number;
+    stageColumnWidth: number;
+    stageHeaderHeight: number;
+    goalRowHeight: number;
+    resultRowHeight: number;
+    aspectRowMinHeight: number;
+    pillHeight: number;
+    pillGap: number;
+    cellPadding: number;
+    textLineHeight: number;
+    textCharWidth: number;
+    cellTextPadX: number;
+    cellTextPadY: number;
+}
+export interface CapabilityMapDimensions {
+    nodeWidth: number;
+    nodeHeight: number;
+}
+type PresetTable<T> = Record<NodeSizePreset, T>;
+/** Shared entity-node width tiers (px). */
+export declare const ENTITY_NODE_WIDTH: Record<NodeSizePreset, number>;
+/** Shared entity-node height tiers (px) — room for name + type + id. */
+export declare const ENTITY_NODE_HEIGHT: Record<NodeSizePreset, number>;
+/** Canonical entity-node sizes — used by every box-based notation preview. */
+export declare const ENTITY_NODE_SIZE: PresetTable<BoxDimensions>;
+/** @deprecated alias — use {@link ENTITY_NODE_SIZE} */
+export declare const GOALS_NODE_SIZE: PresetTable<BoxDimensions>;
+/** @deprecated alias — use {@link ENTITY_NODE_SIZE} */
+export declare const DGCA_NODE_SIZE: PresetTable<BoxDimensions>;
+/** @deprecated alias — use {@link ENTITY_NODE_SIZE} */
+export declare const BLOCKS_LEAF_SIZE: PresetTable<BoxDimensions>;
+/** @deprecated alias — use {@link ENTITY_NODE_SIZE} */
+export declare const ACTION_NODE_SIZE: PresetTable<BoxDimensions>;
+export declare const CAPABILITY_MAP_NODE_SIZE: PresetTable<CapabilityMapDimensions>;
+export declare const PROCESS_BLUEPRINT_SIZE: PresetTable<ProcessBlueprintDimensions>;
+export type NodeSizeNotation = 'goals' | 'dgca' | 'dga' | 'blocks' | 'action' | 'processBlueprint' | 'capabilityMap';
+/** Parse a VS Code setting value into a preset id (defaults to `normal`). */
+export declare function parseNodeSizePreset(value: string | undefined): NodeSizePreset;
+export declare function resolveGoalsNodeSize(preset: NodeSizePreset): BoxDimensions;
+export declare function resolveDgcaNodeSize(preset: NodeSizePreset): BoxDimensions;
+export declare function resolveBlocksLeafSize(preset: NodeSizePreset): BlocksLeafDimensions;
+export declare function resolveActionNodeSize(preset: NodeSizePreset): BoxDimensions;
+export declare function resolveProcessBlueprintSize(preset: NodeSizePreset): ProcessBlueprintDimensions;
+export declare function resolveCapabilityMapNodeSize(preset: NodeSizePreset): CapabilityMapDimensions;
+export {};

package/dist/node-size-presets.js

@@ -0,0 +1,117 @@
+/**
+ * Block/cell size presets for diagram renderers.
+ *
+ * Entity nodes (Goals, DGCA/DGA, Blocks leaves, Activities, Capability Map)
+ * share one width × height ladder. Heights use fixed tiers (72 / 80 / 96 px)
+ * so name + type + id never collide; widths scale independently (200 / 250 / 320).
+ *
+ * Process Blueprint uses a separate cell grid, scaled from the same tiers.
+ */
+export const NODE_SIZE_PRESET_VALUES = ['compact', 'normal', 'wide'];
+/** Shared entity-node width tiers (px). */
+export const ENTITY_NODE_WIDTH = {
+    compact: 200,
+    normal: 250,
+    wide: 320,
+};
+/** Shared entity-node height tiers (px) — room for name + type + id. */
+export const ENTITY_NODE_HEIGHT = {
+    compact: 72,
+    normal: 80,
+    wide: 96,
+};
+function entityNodeSize(preset) {
+    return { width: ENTITY_NODE_WIDTH[preset], height: ENTITY_NODE_HEIGHT[preset] };
+}
+/** Canonical entity-node sizes — used by every box-based notation preview. */
+export const ENTITY_NODE_SIZE = {
+    compact: entityNodeSize('compact'),
+    normal: entityNodeSize('normal'),
+    wide: entityNodeSize('wide'),
+};
+/** @deprecated alias — use {@link ENTITY_NODE_SIZE} */
+export const GOALS_NODE_SIZE = ENTITY_NODE_SIZE;
+/** @deprecated alias — use {@link ENTITY_NODE_SIZE} */
+export const DGCA_NODE_SIZE = ENTITY_NODE_SIZE;
+/** @deprecated alias — use {@link ENTITY_NODE_SIZE} */
+export const BLOCKS_LEAF_SIZE = ENTITY_NODE_SIZE;
+/** @deprecated alias — use {@link ENTITY_NODE_SIZE} */
+export const ACTION_NODE_SIZE = ENTITY_NODE_SIZE;
+export const CAPABILITY_MAP_NODE_SIZE = {
+    compact: { nodeWidth: ENTITY_NODE_WIDTH.compact, nodeHeight: ENTITY_NODE_HEIGHT.compact },
+    normal: { nodeWidth: ENTITY_NODE_WIDTH.normal, nodeHeight: ENTITY_NODE_HEIGHT.normal },
+    wide: { nodeWidth: ENTITY_NODE_WIDTH.wide, nodeHeight: ENTITY_NODE_HEIGHT.wide },
+};
+const PROCESS_BLUEPRINT_NORMAL = {
+    legendColumnWidth: 140,
+    stageColumnWidth: 220,
+    stageHeaderHeight: 40,
+    goalRowHeight: 56,
+    resultRowHeight: 56,
+    aspectRowMinHeight: 60,
+    pillHeight: 40,
+    pillGap: 4,
+    cellPadding: 8,
+    textLineHeight: 17,
+    textCharWidth: 7.5,
+    cellTextPadX: 10,
+    cellTextPadY: 10,
+};
+function scaleBlueprint(base, widthScale, heightScale) {
+    const w = (n) => Math.round(n * widthScale);
+    const h = (n) => Math.round(n * heightScale);
+    return {
+        legendColumnWidth: w(base.legendColumnWidth),
+        stageColumnWidth: w(base.stageColumnWidth),
+        stageHeaderHeight: h(base.stageHeaderHeight),
+        goalRowHeight: h(base.goalRowHeight),
+        resultRowHeight: h(base.resultRowHeight),
+        aspectRowMinHeight: h(base.aspectRowMinHeight),
+        pillHeight: h(base.pillHeight),
+        pillGap: base.pillGap,
+        cellPadding: base.cellPadding,
+        textLineHeight: h(base.textLineHeight),
+        textCharWidth: base.textCharWidth,
+        cellTextPadX: base.cellTextPadX,
+        cellTextPadY: base.cellTextPadY,
+    };
+}
+const PB_WIDTH_SCALE = {
+    compact: ENTITY_NODE_WIDTH.compact / ENTITY_NODE_WIDTH.normal,
+    normal: 1,
+    wide: ENTITY_NODE_WIDTH.wide / ENTITY_NODE_WIDTH.normal,
+};
+const PB_HEIGHT_SCALE = {
+    compact: ENTITY_NODE_HEIGHT.compact / ENTITY_NODE_HEIGHT.normal,
+    normal: 1,
+    wide: ENTITY_NODE_HEIGHT.wide / ENTITY_NODE_HEIGHT.normal,
+};
+export const PROCESS_BLUEPRINT_SIZE = {
+    compact: scaleBlueprint(PROCESS_BLUEPRINT_NORMAL, PB_WIDTH_SCALE.compact, PB_HEIGHT_SCALE.compact),
+    normal: PROCESS_BLUEPRINT_NORMAL,
+    wide: scaleBlueprint(PROCESS_BLUEPRINT_NORMAL, PB_WIDTH_SCALE.wide, PB_HEIGHT_SCALE.wide),
+};
+/** Parse a VS Code setting value into a preset id (defaults to `normal`). */
+export function parseNodeSizePreset(value) {
+    if (value === 'compact' || value === 'wide')
+        return value;
+    return 'normal';
+}
+export function resolveGoalsNodeSize(preset) {
+    return ENTITY_NODE_SIZE[preset];
+}
+export function resolveDgcaNodeSize(preset) {
+    return ENTITY_NODE_SIZE[preset];
+}
+export function resolveBlocksLeafSize(preset) {
+    return ENTITY_NODE_SIZE[preset];
+}
+export function resolveActionNodeSize(preset) {
+    return ENTITY_NODE_SIZE[preset];
+}
+export function resolveProcessBlueprintSize(preset) {
+    return PROCESS_BLUEPRINT_SIZE[preset];
+}
+export function resolveCapabilityMapNodeSize(preset) {
+    return CAPABILITY_MAP_NODE_SIZE[preset];
+}