@transitrix/diagrams 1.7.6 → 1.8.1

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 = 200;
+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/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

@@ -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

@@ -4,7 +4,9 @@ export const TREE_NODE_HEIGHT = 64;
 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).
  *

package/dist/fgca/preview-layout.js

@@ -1,15 +1,15 @@
-// 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.
 /**
- * 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,8 +38,8 @@ 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.
+// 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 = 220;
 export const FGCA_NODE_H = 72;
 export const FGCA_HEADER_H = 32;
@@ -47,10 +47,10 @@ 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 +110,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 +121,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 +131,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 +164,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,50 @@
+/**
+ * Block/cell size presets for diagram renderers.
+ *
+ * Presets drive both layout geometry and shared text-layout char budgets.
+ * Smooth per-pixel sliders are intentionally deferred.
+ */
+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>;
+export declare const GOALS_NODE_SIZE: PresetTable<BoxDimensions>;
+export declare const DGCA_NODE_SIZE: PresetTable<BoxDimensions>;
+export declare const BLOCKS_LEAF_SIZE: PresetTable<BlocksLeafDimensions>;
+export declare const ACTION_NODE_SIZE: PresetTable<BoxDimensions>;
+export declare const PROCESS_BLUEPRINT_SIZE: PresetTable<ProcessBlueprintDimensions>;
+export declare const CAPABILITY_MAP_NODE_SIZE: PresetTable<CapabilityMapDimensions>;
+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,103 @@
+/**
+ * Block/cell size presets for diagram renderers.
+ *
+ * Presets drive both layout geometry and shared text-layout char budgets.
+ * Smooth per-pixel sliders are intentionally deferred.
+ */
+export const NODE_SIZE_PRESET_VALUES = ['compact', 'normal', 'wide'];
+export const GOALS_NODE_SIZE = {
+    compact: { width: 200, height: 72 },
+    normal: { width: 250, height: 72 },
+    wide: { width: 320, height: 72 },
+};
+export const DGCA_NODE_SIZE = {
+    compact: { width: 200, height: 72 },
+    normal: { width: 220, height: 72 },
+    wide: { width: 280, height: 72 },
+};
+export const BLOCKS_LEAF_SIZE = {
+    compact: { width: 140, height: 72 },
+    normal: { width: 160, height: 72 },
+    wide: { width: 200, height: 72 },
+};
+export const ACTION_NODE_SIZE = {
+    compact: { width: 180, height: 72 },
+    normal: { width: 200, height: 80 },
+    wide: { width: 260, height: 80 },
+};
+export const PROCESS_BLUEPRINT_SIZE = {
+    compact: {
+        legendColumnWidth: 120,
+        stageColumnWidth: 180,
+        stageHeaderHeight: 36,
+        goalRowHeight: 52,
+        resultRowHeight: 52,
+        aspectRowMinHeight: 56,
+        pillHeight: 36,
+        pillGap: 4,
+        cellPadding: 8,
+        textLineHeight: 16,
+        textCharWidth: 7.5,
+        cellTextPadX: 10,
+        cellTextPadY: 10,
+    },
+    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,
+    },
+    wide: {
+        legendColumnWidth: 160,
+        stageColumnWidth: 280,
+        stageHeaderHeight: 44,
+        goalRowHeight: 60,
+        resultRowHeight: 60,
+        aspectRowMinHeight: 64,
+        pillHeight: 44,
+        pillGap: 4,
+        cellPadding: 8,
+        textLineHeight: 18,
+        textCharWidth: 7.5,
+        cellTextPadX: 10,
+        cellTextPadY: 10,
+    },
+};
+export const CAPABILITY_MAP_NODE_SIZE = {
+    compact: { nodeWidth: 200, nodeHeight: 56 },
+    normal: { nodeWidth: 240, nodeHeight: 60 },
+    wide: { nodeWidth: 300, nodeHeight: 64 },
+};
+/** 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 GOALS_NODE_SIZE[preset];
+}
+export function resolveDgcaNodeSize(preset) {
+    return DGCA_NODE_SIZE[preset];
+}
+export function resolveBlocksLeafSize(preset) {
+    return BLOCKS_LEAF_SIZE[preset];
+}
+export function resolveActionNodeSize(preset) {
+    return ACTION_NODE_SIZE[preset];
+}
+export function resolveProcessBlueprintSize(preset) {
+    return PROCESS_BLUEPRINT_SIZE[preset];
+}
+export function resolveCapabilityMapNodeSize(preset) {
+    return CAPABILITY_MAP_NODE_SIZE[preset];
+}

package/dist/process-blueprint/layout.js

@@ -1,3 +1,4 @@
+import { wrapTextLines } from '../webview/entity-text-layout.js';
 const ASPECT_CATEGORIES = ['systems', 'actors', 'equipment', 'information_entities'];
 const ASPECT_LABEL = {
     systems: 'Systems',
@@ -30,55 +31,11 @@ function resolveOptions(options) {
     return { ...DEFAULTS, ...(options ?? {}) };
 }
 /**
- * Greedy word-wrap to a max characters-per-line budget. Words longer than the
- * budget are hard-split; if the result exceeds `maxLines`, the last kept line
- * is truncated with an ellipsis so a single pathological cell can't grow the
- * whole row unbounded.
+ * Greedy word-wrap to a max characters-per-line budget. Delegates to the shared
+ * shared text-layout module.
  */
 function wrapText(text, maxChars, maxLines) {
-    const trimmed = (text ?? '').trim();
-    if (trimmed.length === 0)
-        return [];
-    const budget = Math.max(1, maxChars);
-    const words = trimmed.split(/\s+/);
-    const lines = [];
-    let cur = '';
-    const flush = () => {
-        if (cur.length > 0) {
-            lines.push(cur);
-            cur = '';
-        }
-    };
-    for (const word of words) {
-        if (word.length > budget) {
-            // Token wider than the cell: hard-break it across lines.
-            flush();
-            let rest = word;
-            while (rest.length > budget) {
-                lines.push(rest.slice(0, budget));
-                rest = rest.slice(budget);
-            }
-            cur = rest;
-            continue;
-        }
-        const candidate = cur.length > 0 ? `${cur} ${word}` : word;
-        if (candidate.length > budget) {
-            flush();
-            cur = word;
-        }
-        else {
-            cur = candidate;
-        }
-    }
-    flush();
-    if (lines.length > maxLines) {
-        const capped = lines.slice(0, maxLines);
-        const last = capped[maxLines - 1];
-        const clipped = last.length > budget - 1 ? last.slice(0, budget - 1) : last;
-        capped[maxLines - 1] = `${clipped.replace(/…$/, '')}…`;
-        return capped;
-    }
-    return lines;
+    return wrapTextLines(text, maxChars, maxLines);
 }
 function buildStageIndex(stages) {
     const idx = new Map();

package/dist/webview/__tests__/entity-text-layout.test.d.ts

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

package/dist/webview/__tests__/entity-text-layout.test.js

@@ -0,0 +1,43 @@
+import { describe, expect, it } from 'vitest';
+import { layoutCenteredEntityText, maxCharsForInnerWidth, wrapWords, wrapTextLines, } from '../entity-text-layout.js';
+describe('entity-text-layout', () => {
+    it('wrapWords respects max lines and truncates with ellipsis', () => {
+        const long = 'one two three four five six seven eight nine ten eleven twelve';
+        const lines = wrapWords(long, 12, 2);
+        expect(lines.length).toBeLessThanOrEqual(2);
+        expect(lines[lines.length - 1]).toMatch(/…$/);
+    });
+    it('maxCharsForInnerWidth scales with inner width', () => {
+        expect(maxCharsForInnerWidth(160, 7)).toBeGreaterThan(maxCharsForInnerWidth(120, 7));
+    });
+    it('layoutCenteredEntityText emits more name capacity on wide boxes', () => {
+        const narrow = layoutCenteredEntityText({
+            boxX: 0,
+            boxY: 0,
+            boxWidth: 200,
+            boxHeight: 72,
+            name: 'Improve customer onboarding experience across regions',
+            id: 'GOAL-001',
+            nameMaxLines: 2,
+            idMaxLines: 1,
+        });
+        const wide = layoutCenteredEntityText({
+            boxX: 0,
+            boxY: 0,
+            boxWidth: 320,
+            boxHeight: 72,
+            name: 'Improve customer onboarding experience across regions',
+            id: 'GOAL-001',
+            nameMaxLines: 2,
+            idMaxLines: 1,
+        });
+        const narrowPrimary = narrow.filter((l) => l.cls === 'text-primary').map((l) => l.text).join(' ');
+        const widePrimary = wide.filter((l) => l.cls === 'text-primary').map((l) => l.text).join(' ');
+        expect(widePrimary.replace(/…/g, '').length).toBeGreaterThanOrEqual(narrowPrimary.replace(/…/g, '').length);
+    });
+    it('wrapTextLines hard-breaks oversized tokens (blueprint cells)', () => {
+        const lines = wrapTextLines('supercalifragilisticexpialidocious word', 10, 3);
+        expect(lines.length).toBeGreaterThan(1);
+        expect(lines.every((l) => l.length <= 10)).toBe(true);
+    });
+});

package/dist/webview/__tests__/entry.test.js

@@ -40,9 +40,9 @@ describe('webview/entry — Step 2 host API', () => {
     });
     it('routes non-goals kinds to their validator after Step 4 (no NOTATION-NOT-WIRED)', () => {
         // Every supported kind is now wired to its validator + renderer. A
-        // malformed fgca document must surface a structured validation error from
-        // the fgca validator — never the Step-2/3 "not wired" placeholder.
-        const r = render('fgca', 'changes: []\n');
+        // malformed dgca document must surface a structured validation error from
+        // the dgca validator — never the Step-2/3 "not wired" placeholder.
+        const r = render('dgca', 'changes: []\n');
         expect(r.status).toBe('error');
         expect(r.errors.length).toBeGreaterThan(0);
         expect(r.errors.every((e) => e.code !== 'NOTATION-NOT-WIRED')).toBe(true);

package/dist/webview/__tests__/render-blocks.test.js

@@ -8,13 +8,7 @@
  */
 import { describe, expect, it } from 'vitest';
 import { renderBlocksSvg } from '../render-blocks.js';
-// Approximate character widths used by the renderer when sizing labels.
-// Kept in sync with `CHAR_W` / `CHAR_W_ID` in render-blocks.ts so the test
-// can compute the same overflow bounds the renderer uses.
-const CHAR_W = 7;
-const CHAR_W_ID = 6;
-// Same horizontal margin the renderer reserves so text never abuts the rect.
-const TEXT_MARGIN_X = 8;
+import { CHAR_W_PRIMARY as CHAR_W, CHAR_W_ID, TEXT_MARGIN_X } from '../entity-text-layout.js';
 function leafDoc(name, id) {
     return {
         notation: 'blocks',