@transitrix/diagrams 1.6.0 → 1.8.1

package/src/goals/mutations.ts

@@ -22,12 +22,12 @@ function getTypeForLevel(tree: GoalTree, level: number): string {
   return gt?.name ?? '';
 }
 
-function updateDescendantLevels(goals: Goal[], id: number, levelDelta: number): void {
-  for (const g of goals) {
+function updateDescendantLevels(clone: GoalTree, id: number, levelDelta: number, maxLevel: number): void {
+  for (const g of clone.goals) {
     if (g.parent_id === id) {
-      g.level += levelDelta;
-      g.type = '';
-      updateDescendantLevels(goals, g.id, levelDelta);
+      g.level = Math.min(g.level + levelDelta, maxLevel);
+      g.type = getTypeForLevel(clone, g.level);
+      updateDescendantLevels(clone, g.id, levelDelta, maxLevel);
     }
   }
 }
@@ -70,7 +70,7 @@ export function reparent(tree: GoalTree, sourceId: number, targetId: number): Mu
   source.parent_id = targetId;
   source.level = newLevel;
   source.type = getTypeForLevel(clone, newLevel);
-  if (levelDelta !== 0) updateDescendantLevels(clone.goals, sourceId, levelDelta);
+  if (levelDelta !== 0) updateDescendantLevels(clone, sourceId, levelDelta, maxLevel);
 
   const v = validateGoalTree(clone);
   if (!v.valid) return refusalError(v.errors[0]?.message ?? 'Validation failed after reparent');

package/src/goals/parse-canonical.ts

@@ -36,6 +36,11 @@ export interface CanonicalGoalsResult extends ValidationResult {
 const GOAL_ID_RE = /^GOAL(-[A-Z0-9][A-Z0-9_]*)*-\d+$/;
 const GOALS_DOC_ID_RE = /^GOALS(-[A-Z0-9][A-Z0-9_]*)*-\d+$/;
 
+/** Display id for previews — canonical `GOAL-…` when present, else internal numeric id. */
+export function displayGoalId(goal: { id: number; canonical_id?: string }): string {
+  return goal.canonical_id ?? String(goal.id);
+}
+
 function isNonEmptyString(v: unknown): v is string {
   return typeof v === 'string' && v.trim().length > 0;
 }
@@ -267,6 +272,7 @@ export function parseCanonicalGoals(input: unknown): CanonicalGoalsResult {
       isNonEmptyString(parent) && idToInternal.has(parent) ? idToInternal.get(parent)! : 0;
     return {
       id: idToInternal.get(o['id'] as string)!,
+      canonical_id: o['id'] as string,
       name: o['name'] as string,
       type: o['type'] as string,
       level: o['level'] as number,

package/src/goals/types.ts

@@ -10,6 +10,8 @@ export interface Factor {
 
 export interface Goal {
   id: number;
+  /** Canonical typed id from the YAML (`GOAL-…`) when parsed from canonical form. */
+  canonical_id?: string;
   name: string;
   type: string;
   level: number;

package/src/node-size-presets.ts

@@ -0,0 +1,157 @@
+/**
+ * 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 const NODE_SIZE_PRESET_VALUES: readonly NodeSizePreset[] = ['compact', 'normal', 'wide'] as const;
+
+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 const GOALS_NODE_SIZE: PresetTable<BoxDimensions> = {
+  compact: { width: 200, height: 72 },
+  normal: { width: 250, height: 72 },
+  wide: { width: 320, height: 72 },
+};
+
+export const DGCA_NODE_SIZE: PresetTable<BoxDimensions> = {
+  compact: { width: 200, height: 72 },
+  normal: { width: 220, height: 72 },
+  wide: { width: 280, height: 72 },
+};
+
+export const BLOCKS_LEAF_SIZE: PresetTable<BlocksLeafDimensions> = {
+  compact: { width: 140, height: 72 },
+  normal: { width: 160, height: 72 },
+  wide: { width: 200, height: 72 },
+};
+
+export const ACTION_NODE_SIZE: PresetTable<BoxDimensions> = {
+  compact: { width: 180, height: 72 },
+  normal: { width: 200, height: 80 },
+  wide: { width: 260, height: 80 },
+};
+
+export const PROCESS_BLUEPRINT_SIZE: PresetTable<ProcessBlueprintDimensions> = {
+  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: PresetTable<CapabilityMapDimensions> = {
+  compact: { nodeWidth: 200, nodeHeight: 56 },
+  normal: { nodeWidth: 240, nodeHeight: 60 },
+  wide: { nodeWidth: 300, nodeHeight: 64 },
+};
+
+export type NodeSizeNotation =
+  | 'goals'
+  | 'dgca'
+  | 'dga'
+  | 'blocks'
+  | 'action'
+  | 'processBlueprint'
+  | 'capabilityMap';
+
+/** Parse a VS Code setting value into a preset id (defaults to `normal`). */
+export function parseNodeSizePreset(value: string | undefined): NodeSizePreset {
+  if (value === 'compact' || value === 'wide') return value;
+  return 'normal';
+}
+
+export function resolveGoalsNodeSize(preset: NodeSizePreset): BoxDimensions {
+  return GOALS_NODE_SIZE[preset];
+}
+
+export function resolveDgcaNodeSize(preset: NodeSizePreset): BoxDimensions {
+  return DGCA_NODE_SIZE[preset];
+}
+
+export function resolveBlocksLeafSize(preset: NodeSizePreset): BlocksLeafDimensions {
+  return BLOCKS_LEAF_SIZE[preset];
+}
+
+export function resolveActionNodeSize(preset: NodeSizePreset): BoxDimensions {
+  return ACTION_NODE_SIZE[preset];
+}
+
+export function resolveProcessBlueprintSize(preset: NodeSizePreset): ProcessBlueprintDimensions {
+  return PROCESS_BLUEPRINT_SIZE[preset];
+}
+
+export function resolveCapabilityMapNodeSize(preset: NodeSizePreset): CapabilityMapDimensions {
+  return CAPABILITY_MAP_NODE_SIZE[preset];
+}

package/src/process-blueprint/layout.ts

@@ -18,6 +18,7 @@ import type {
   StageHeaderCell,
   StageTextCell,
 } from './types.js';
+import { wrapTextLines } from '../webview/entity-text-layout.js';
 
 const ASPECT_CATEGORIES: AspectCategory[] = ['systems', 'actors', 'equipment', 'information_entities'];
 
@@ -78,56 +79,11 @@ function resolveOptions(options: ProcessBlueprintLayoutOptions | undefined): Res
 }
 
 /**
- * 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: string, maxChars: number, maxLines: number): string[] {
-  const trimmed = (text ?? '').trim();
-  if (trimmed.length === 0) return [];
-  const budget = Math.max(1, maxChars);
-
-  const words = trimmed.split(/\s+/);
-  const lines: string[] = [];
-  let cur = '';
-  const flush = (): void => {
-    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: Stage[]): Map<string, number> {

package/src/repo-validate/types.ts

@@ -4,9 +4,8 @@
 // referential integrity, atomicity, ID uniqueness, policy — the checks that the
 // methodology's Python `.validators/lint.py` owns today. This converges those
 // checks onto the shared TypeScript model so there is a single validation
-// runtime (methodology ADR
-// `2026-06-11-validation-two-axis-model.md`; Studio referencing ADR
-// `docs/decisions/2026-06-11-validation-runtime-convergence.md`).
+// runtime (methodology ADR "Validation Two-Axis Model"; Studio decision
+// "Validation Runtime Convergence").
 //
 // The finding shape is deliberately minimal — `{ scope, id, message }`. The
 // richer `target` / `category` reporting taxonomy is explicitly DEFERRED per the

package/src/webview/__tests__/entity-text-layout.test.ts

@@ -0,0 +1,52 @@
+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/src/webview/__tests__/entry.test.ts

@@ -47,9 +47,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/src/webview/__tests__/render-blocks.test.ts

@@ -10,15 +10,7 @@ import { describe, expect, it } from 'vitest';
 
 import type { BlocksFile } from '../../blocks/types.js';
 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: string, id: string): BlocksFile {
   return {

package/src/webview/__tests__/render-goals.test.ts

@@ -65,8 +65,22 @@ describe('renderGoalsSvg', () => {
     expect(svg).toContain('height="0"');
   });
 
-  it('omits the title block when treeName is missing', () => {
-    const svg = renderGoalsSvg(SIMPLE_TREE);
-    expect(svg).not.toContain('Goal tree —');
+  it('shows canonical goal ids in node labels when present', () => {
+    const tree: GoalTree = {
+      goal_types: [{ name: 'Strategy', level: 0 }],
+      goals: [
+        {
+          id: 1,
+          canonical_id: 'GOAL-REVENUE-1',
+          name: 'Triple revenue',
+          type: 'Strategy',
+          level: 0,
+          parent_id: 0,
+        },
+      ],
+    };
+    const svg = renderGoalsSvg(tree);
+    expect(svg).toContain('GOAL-REVENUE-1');
+    expect(svg).not.toMatch(/>\s*1\s*</);
   });
 });