@transitrix/diagrams 1.3.0 → 1.5.0

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

@@ -0,0 +1,178 @@
+/**
+ * Unit tests for the host-neutral nested-blocks SVG renderer used by both the
+ * VS Code blocks preview and the IntelliJ JCEF webview bundle. These tests pin
+ * the per-node label rule (CLAUDE.md "Entity block layout"): leaf nodes wrap
+ * the name to at most 3 lines and the ID to at most 2 lines, with `…`
+ * truncation beyond that; container headers stack name + ID, each truncated
+ * with `…` to fit the block width. No label may extend past the rect.
+ */
+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;
+function leafDoc(name, id) {
+    return {
+        notation: 'blocks',
+        spec_version: '0.1',
+        nested_blocks: {
+            id: 'BLOCKS-T-1',
+            name: 'Test',
+            blocks: [{ id, name }],
+        },
+    };
+}
+function containerDoc(name, id, childId = 'CHILD', childName = 'Child') {
+    return {
+        notation: 'blocks',
+        spec_version: '0.1',
+        nested_blocks: {
+            id: 'BLOCKS-T-1',
+            name: 'Test',
+            blocks: [
+                {
+                    id,
+                    name,
+                    children: [{ id: childId, name: childName }],
+                },
+            ],
+        },
+    };
+}
+/** Pull every text-primary / text-id line out of an SVG, in document order. */
+function extractLabels(svg) {
+    const re = /<text class="(text-(?:primary|id))"[^>]*>([^<]*)<\/text>/g;
+    const out = [];
+    let m;
+    while ((m = re.exec(svg)))
+        out.push({ cls: m[1], text: m[2] });
+    return out;
+}
+/** Extract {class, y} for each text element in SVG document order. */
+function extractTextY(svg) {
+    const re = /<text class="(text-(?:primary|id))"[^>]*\by="([^"]+)"/g;
+    const out = [];
+    let m;
+    while ((m = re.exec(svg)))
+        out.push({ cls: m[1], y: parseFloat(m[2]) });
+    return out;
+}
+describe('renderBlocksSvg — leaf labels', () => {
+    it('wraps a long name to at most 3 lines and truncates with …', () => {
+        const longName = 'Personal data records that linger after consent withdrawal across many systems and ' +
+            'archives — known erasure gap';
+        const svg = renderBlocksSvg(leafDoc(longName, 'PII'));
+        const nameLines = extractLabels(svg).filter((l) => l.cls === 'text-primary');
+        expect(nameLines.length).toBeGreaterThan(0);
+        expect(nameLines.length).toBeLessThanOrEqual(3);
+        // If the name needed truncation, the final visible line must end with `…`.
+        if (nameLines.length === 3) {
+            expect(nameLines[2].text.endsWith('…')).toBe(true);
+        }
+    });
+    it('wraps a long ID to at most 2 lines and truncates with …', () => {
+        const longId = 'VERY_LONG_BLOCK_IDENTIFIER_WITH_MANY_SEGMENTS_AND_MORE_AND_MORE';
+        const svg = renderBlocksSvg(leafDoc('Short name', longId));
+        const idLines = extractLabels(svg).filter((l) => l.cls === 'text-id');
+        expect(idLines.length).toBeGreaterThan(0);
+        expect(idLines.length).toBeLessThanOrEqual(2);
+        if (idLines.length === 2) {
+            expect(idLines[1].text.endsWith('…')).toBe(true);
+        }
+    });
+    it('keeps every label inside the 160px leaf width (approximated by CHAR_W * length)', () => {
+        const svg = renderBlocksSvg(leafDoc('Personal data records that linger after consent withdrawal across many systems', 'PII_RECORDS_WITH_A_FAIRLY_LONG_IDENTIFIER_HERE'));
+        const labels = extractLabels(svg);
+        const inner = 160 - TEXT_MARGIN_X * 2;
+        for (const l of labels) {
+            const cw = l.cls === 'text-primary' ? CHAR_W : CHAR_W_ID;
+            expect(l.text.length * cw).toBeLessThanOrEqual(inner);
+        }
+    });
+});
+describe('renderBlocksSvg — container headers', () => {
+    it('renders the name and ID as two separate stacked text elements', () => {
+        const svg = renderBlocksSvg(containerDoc('Active systems', 'ACTIVE_SYSTEMS'));
+        const labels = extractLabels(svg);
+        // Container header contributes one text-primary (name) and one text-id (id);
+        // the leaf child contributes another pair. So 2 of each kind in total.
+        const primaries = labels.filter((l) => l.cls === 'text-primary').map((l) => l.text);
+        const ids = labels.filter((l) => l.cls === 'text-id').map((l) => l.text);
+        expect(primaries).toContain('Active systems');
+        expect(ids).toContain('ACTIVE_SYSTEMS');
+        // The legacy "(id)" suffix on the name line must not appear — id has its own row.
+        for (const t of primaries)
+            expect(t).not.toContain('(');
+    });
+    it('truncates a long container ID so it does not overflow the block width', () => {
+        const svg = renderBlocksSvg(containerDoc('Short name', 'VERY_LONG_CONTAINER_IDENTIFIER_THAT_WOULD_OTHERWISE_OVERFLOW', 'CHILD', 'Child'));
+        const labels = extractLabels(svg);
+        // The container width derives from its single 160px child: 160 + 2*12 (padding) = 184.
+        const containerW = 160 + 24;
+        const inner = containerW - TEXT_MARGIN_X * 2;
+        for (const l of labels) {
+            const cw = l.cls === 'text-primary' ? CHAR_W : CHAR_W_ID;
+            expect(l.text.length * cw).toBeLessThanOrEqual(inner);
+        }
+        // The full ID was too long to fit on one line of `inner / CHAR_W_ID` chars, so
+        // the rendered ID must be the truncated form ending in `…`.
+        const renderedIds = labels.filter((l) => l.cls === 'text-id').map((l) => l.text);
+        expect(renderedIds.some((t) => t.endsWith('…'))).toBe(true);
+    });
+    it('truncates a long container name with … to fit the block width', () => {
+        const longName = 'Active systems that are erasure-reachable within the standard 30-day operational window';
+        const svg = renderBlocksSvg(containerDoc(longName, 'ACTIVE'));
+        const labels = extractLabels(svg);
+        const containerW = 160 + 24;
+        const inner = containerW - TEXT_MARGIN_X * 2;
+        const primaries = labels.filter((l) => l.cls === 'text-primary');
+        for (const l of primaries) {
+            expect(l.text.length * CHAR_W).toBeLessThanOrEqual(inner);
+        }
+        // At least one primary line must have been truncated.
+        expect(primaries.some((l) => l.text.endsWith('…'))).toBe(true);
+    });
+});
+describe('renderBlocksSvg — name/ID vertical overlap regression (follows-up on #419)', () => {
+    // Root cause: NAME_ID_GAP was 6 px. text-primary is 12 px tall (±6 px around
+    // centre) and text-id is 10 px tall (±5 px around centre). The minimum gap
+    // between centres to avoid overlap is 11 px; a gap of 6 caused 5 px of overlap.
+    // Fix: NAME_ID_GAP = 14 (3 px visual buffer, matching the gap between name lines).
+    const NAME_HALF_H = 6; // half of text-primary font size (12 px)
+    const ID_HALF_H = 5; // half of text-id font size (10 px)
+    it('leaf node: last name line bottom does not overlap first ID line top (1 name + 1 ID)', () => {
+        const svg = renderBlocksSvg(leafDoc('Short', 'BLK-1'));
+        const positions = extractTextY(svg);
+        const nameY = positions.filter(p => p.cls === 'text-primary').map(p => p.y);
+        const idY = positions.filter(p => p.cls === 'text-id').map(p => p.y);
+        expect(nameY.length).toBeGreaterThan(0);
+        expect(idY.length).toBeGreaterThan(0);
+        const lastNameBottom = Math.max(...nameY) + NAME_HALF_H;
+        const firstIdTop = Math.min(...idY) - ID_HALF_H;
+        expect(firstIdTop).toBeGreaterThan(lastNameBottom);
+    });
+    it('leaf node: no overlap with a 3-word name (2 name lines + 1 ID)', () => {
+        const svg = renderBlocksSvg(leafDoc('Three Word Name', 'BLK-001'));
+        const positions = extractTextY(svg);
+        const nameY = positions.filter(p => p.cls === 'text-primary').map(p => p.y);
+        const idY = positions.filter(p => p.cls === 'text-id').map(p => p.y);
+        const lastNameBottom = Math.max(...nameY) + NAME_HALF_H;
+        const firstIdTop = Math.min(...idY) - ID_HALF_H;
+        expect(firstIdTop).toBeGreaterThan(lastNameBottom);
+    });
+    it('leaf node: no overlap with a long name (3 name lines) and wrapped ID (2 lines)', () => {
+        const longName = 'Personal data records that linger after consent withdrawal across many systems and archives';
+        const longId = 'VERY_LONG_BLOCK_IDENTIFIER_WITH_MANY_SEGMENTS_AND_MORE';
+        const svg = renderBlocksSvg(leafDoc(longName, longId));
+        const positions = extractTextY(svg);
+        const nameY = positions.filter(p => p.cls === 'text-primary').map(p => p.y);
+        const idY = positions.filter(p => p.cls === 'text-id').map(p => p.y);
+        const lastNameBottom = Math.max(...nameY) + NAME_HALF_H;
+        const firstIdTop = Math.min(...idY) - ID_HALF_H;
+        expect(firstIdTop).toBeGreaterThan(lastNameBottom);
+    });
+});

package/dist/webview/entry.d.ts

@@ -27,7 +27,7 @@ export interface RenderResult {
  * convention used by the VS Code extension's `activationEvents`. All twelve
  * are wired to their validator + renderer as of Step 4.
  */
-export type NotationKind = 'goals' | 'dgca' | 'dga' | 'fgca' | 'fga' | 'activities' | 'activity-card' | 'applications' | 'products' | 'process-map' | 'process-blueprint' | 'scenarios' | 'capability-map' | 'blocks';
+export type NotationKind = 'goals' | 'dgca' | 'dga' | 'action' | 'action-card' | 'applications' | 'products' | 'process-map' | 'process-blueprint' | 'scenarios' | 'capability-map' | 'blocks';
 export declare function render(notationKind: string, source: string): RenderResult;
 export declare const api: {
     version: string;

package/dist/webview/entry.js

@@ -48,10 +48,8 @@ const SUPPORTED_KINDS = [
     'goals',
     'dgca',
     'dga',
-    'fgca',
-    'fga',
-    'activities',
-    'activity-card',
+    'action',
+    'action-card',
     'applications',
     'products',
     'process-map',
@@ -110,11 +108,7 @@ function dispatchValidate(kind, doc) {
             }
             return r;
         }
-        // DGCA and DGA are the canonical new names; FGCA/FGA are accepted as
-        // deprecated aliases. All four share the same parse + renderer; only the
-        // Change column visibility differs (DGA/FGA collapse it).
-        case 'dgca':
-        case 'fgca': {
+        case 'dgca': {
             const v = parseCanonicalFGCA(doc);
             const r = emptyResult(kind, v.valid ? 'ok' : 'error');
             r.errors.push(...v.errors);
@@ -124,8 +118,7 @@ function dispatchValidate(kind, doc) {
             }
             return r;
         }
-        case 'dga':
-        case 'fga': {
+        case 'dga': {
             const v = parseCanonicalFGA(doc);
             const r = emptyResult(kind, v.valid ? 'ok' : 'error');
             r.errors.push(...v.errors);
@@ -135,10 +128,10 @@ function dispatchValidate(kind, doc) {
             }
             return r;
         }
-        case 'activities':
-            return renderFromValidation('activities', validateActivities(doc), () => renderActivitiesSvg(doc));
-        case 'activity-card':
-            return renderFromValidation('activity-card', validateActivityCard(doc), () => renderActivityCardSvg(doc));
+        case 'action':
+            return renderFromValidation('action', validateActivities(doc), () => renderActivitiesSvg(doc));
+        case 'action-card':
+            return renderFromValidation('action-card', validateActivityCard(doc), () => renderActivityCardSvg(doc));
         case 'process-blueprint':
             return renderFromValidation('process-blueprint', validateProcessBlueprint(doc), () => renderProcessBlueprintSvg(doc));
         case 'blocks':

package/dist/webview/notation-style.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Shared visual constants for entity-box (block-style) notation renderers.
+ *
+ * Goals, Nested Blocks, FGCA/DGCA, and any future notation using the same
+ * entity-box visual language import their shared style tokens from here.
+ * Centralising them prevents the per-renderer drift that caused the Goals/Blocks
+ * style mismatch (border radius diverged to rx=6 in Blocks vs rx=8 everywhere
+ * else). Change here and every notation updates together.
+ */
+/** Border-radius (px) for entity and leaf-block node rectangles. */
+export declare const ENTITY_NODE_RX = 8;

package/dist/webview/notation-style.js

@@ -0,0 +1,11 @@
+/**
+ * Shared visual constants for entity-box (block-style) notation renderers.
+ *
+ * Goals, Nested Blocks, FGCA/DGCA, and any future notation using the same
+ * entity-box visual language import their shared style tokens from here.
+ * Centralising them prevents the per-renderer drift that caused the Goals/Blocks
+ * style mismatch (border radius diverged to rx=6 in Blocks vs rx=8 everywhere
+ * else). Change here and every notation updates together.
+ */
+/** Border-radius (px) for entity and leaf-block node rectangles. */
+export const ENTITY_NODE_RX = 8;

package/dist/webview/render-activities.d.ts

@@ -28,6 +28,18 @@ export interface RenderActivitiesOptions {
     curvature?: number;
     /** Entry curvature at the target node; defaults to `curvature` when omitted. */
     entryCurvature?: number;
+    /**
+     * When true (the default), activities with `activity_type === 'project'` are
+     * excluded from the network layout. Project container nodes add visual noise
+     * in the PSND view because the diagram itself already represents the project
+     * scope; suppressing them declutters the network without altering canonical
+     * data. Set to false to render all activities regardless of type.
+     *
+     * Convention: Network/diagram views suppress project nodes by default.
+     * Text/document views (Tree) keep them visible and compensate with the
+     * Action name in the view header.
+     */
+    suppressProjectNodes?: boolean;
 }
 /**
  * Render the network (PSND) view of an already-validated ActivityDoc to a

package/dist/webview/render-activities.js

@@ -132,12 +132,18 @@ export function renderActivitiesNetworkBody(layout, cpm, ox, oy, curvature, entr
  * than short-circuiting.
  */
 export function renderActivitiesSvg(doc, options = {}) {
-    const { title = '', gaps = {}, curvature = DEFAULT_EDGE_CURVATURE, entryCurvature } = options;
-    const layout = layoutActivities(doc, gaps);
+    const { title = '', gaps = {}, curvature = DEFAULT_EDGE_CURVATURE, entryCurvature, suppressProjectNodes = true, } = options;
+    // #421: Suppress project-type container nodes in the network layout by
+    // default (see suppressProjectNodes JSDoc). A shallow copy avoids mutating
+    // the caller's doc.
+    const renderDoc = suppressProjectNodes
+        ? { ...doc, activities: (doc.activities ?? []).filter((a) => a.activity_type?.toLowerCase() !== 'project') }
+        : doc;
+    const layout = layoutActivities(renderDoc, gaps);
     if (layout.nodes.length === 0) {
         return `<svg xmlns="http://www.w3.org/2000/svg" width="0" height="0" viewBox="0 0 0 0"></svg>`;
     }
-    const cpm = computeCpm(doc.activities ?? []);
+    const cpm = computeCpm(renderDoc.activities ?? []);
     const titleH = title ? 24 : 0;
     const w = layout.bounds.width + N_PAD * 2;
     const h = layout.bounds.height + N_PAD * 2 + titleH;

package/dist/webview/render-blocks.js

@@ -15,11 +15,61 @@
 import { layoutNestedBlocks } from '../blocks/layout.js';
 import { generateSvgEmbedCss } from '../theme/index.js';
 import { escXml } from './render-util.js';
+import { ENTITY_NODE_RX } from './notation-style.js';
 const PAD = 24;
 // Approximate character width (px) at text-primary size (12px/600).
 const CHAR_W = 7;
-// Approximate character width (px) at text-id size (10px/600) — used for ID suffix.
+// Approximate character width (px) at text-id size (10px/600).
 const CHAR_W_ID = 6;
+// Vertical spacing between line centres.
+const LINE_H = 14; // name lines (text-primary, 12 px font)
+const LINE_H_ID = 12; // id lines (text-id, 10 px font)
+// Minimum gap to avoid overlap: half of name text height (6 px) + half of id
+// text height (5 px) = 11 px. Use 14 px to match the name-line separation and
+// leave a 3 px visual buffer — same as the gap between consecutive name lines.
+const NAME_ID_GAP = 14;
+/** Word-wrap `text` to at most `maxLines` lines of `maxChars` each. */
+function wrapWords(text, maxChars, maxLines) {
+    const safeMax = Math.max(2, maxChars);
+    const words = text.split(' ');
+    const lines = [];
+    let cur = '';
+    for (let i = 0; i < words.length; i++) {
+        const w = words[i];
+        const next = cur ? `${cur} ${w}` : w;
+        if (next.length <= safeMax) {
+            cur = next;
+        }
+        else {
+            if (cur)
+                lines.push(cur);
+            cur = '';
+            if (lines.length >= maxLines)
+                break;
+            if (lines.length === maxLines - 1) {
+                const rest = words.slice(i).join(' ');
+                lines.push(rest.length <= safeMax ? rest : rest.slice(0, safeMax - 1) + '…');
+                return lines;
+            }
+            cur = w.length <= safeMax ? w : w.slice(0, safeMax - 1) + '…';
+        }
+    }
+    if (cur && lines.length < maxLines)
+        lines.push(cur);
+    return lines.length ? lines : [text.slice(0, safeMax - 1) + '…'];
+}
+/** Split an ID (no spaces) across at most 2 lines, breaking at `_` or `-`. */
+function wrapId(id, maxChars) {
+    if (id.length <= maxChars)
+        return [id];
+    const seg = id.slice(0, maxChars);
+    const sepIdx = Math.max(seg.lastIndexOf('_'), seg.lastIndexOf('-'));
+    const cut = sepIdx > Math.floor(maxChars / 3) ? sepIdx : maxChars - 1;
+    const isSep = id[cut] === '_' || id[cut] === '-';
+    const line1 = id.slice(0, cut);
+    const rest = id.slice(cut + (isSep ? 1 : 0));
+    return [line1, rest.length <= maxChars ? rest : rest.slice(0, maxChars - 1) + '…'];
+}
 /**
  * Pick the diagram-frame level class for a block at the given depth.
  *
@@ -32,34 +82,67 @@ function levelClassForDepth(depth) {
     const idx = Math.min(Math.max(depth - 1, 0), 6);
     return `level-${idx}`;
 }
-/** Truncate at a word boundary so labels never break in the middle of a word. */
-function wordTruncate(text, maxChars) {
-    if (text.length <= maxChars)
+// Reserve a small horizontal margin so text never abuts the rounded corners.
+const TEXT_MARGIN_X = 8;
+/** Truncate `text` to at most `maxChars` characters, at a word boundary when possible. */
+function truncateLine(text, maxChars) {
+    const safeMax = Math.max(2, maxChars);
+    if (text.length <= safeMax)
         return text;
-    const cut = text.slice(0, maxChars - 1);
+    const cut = text.slice(0, safeMax - 1);
     const lastSpace = cut.lastIndexOf(' ');
-    return (lastSpace > maxChars / 2 ? cut.slice(0, lastSpace) : cut) + '…';
+    return (lastSpace > safeMax / 2 ? cut.slice(0, lastSpace) : cut) + '…';
+}
+/** Single-line ID truncation that prefers `_`/`-` separators before falling back to a hard cut. */
+function truncateId(id, maxChars) {
+    const safeMax = Math.max(2, maxChars);
+    if (id.length <= safeMax)
+        return id;
+    const cut = id.slice(0, safeMax - 1);
+    const sepIdx = Math.max(cut.lastIndexOf('_'), cut.lastIndexOf('-'));
+    return (sepIdx > safeMax / 3 ? cut.slice(0, sepIdx) : cut) + '…';
 }
 function emitBlockSvg(b, ox, oy, parts) {
     const cls = levelClassForDepth(b.depth);
     const cx = b.x + ox + b.width / 2;
-    parts.push(`<rect class="diagram-node ${cls}" x="${b.x + ox}" y="${b.y + oy}" width="${b.width}" height="${b.height}" rx="6"/>`);
+    parts.push(`<rect class="diagram-node ${cls}" x="${b.x + ox}" y="${b.y + oy}" width="${b.width}" height="${b.height}" rx="${ENTITY_NODE_RX}"/>`);
+    const innerW = Math.max(0, b.width - TEXT_MARGIN_X * 2);
     const isLeaf = b.children.length === 0;
     if (isLeaf) {
-        // Leaf block: name on upper line, ID on lower line — both centred.
-        const nameY = b.y + oy + Math.round(b.height * 0.38);
-        const idY = b.y + oy + Math.round(b.height * 0.66);
-        const maxChars = Math.max(4, Math.floor(b.width / CHAR_W));
-        parts.push(`<text class="text-primary" x="${cx}" y="${nameY}" text-anchor="middle" dominant-baseline="central">${escXml(wordTruncate(b.name, maxChars))}</text>`, `<text class="text-id" x="${cx}" y="${idY}" text-anchor="middle" dominant-baseline="central">${escXml(b.id)}</text>`);
+        // Leaf block: name (up to 3 lines) then ID (up to 2 lines), centred vertically.
+        const maxCharsName = Math.max(4, Math.floor(innerW / CHAR_W));
+        const maxCharsId = Math.max(4, Math.floor(innerW / CHAR_W_ID));
+        const nameLines = wrapWords(b.name, maxCharsName, 3);
+        const idLines = wrapId(b.id, maxCharsId);
+        const nameTotalSpan = (nameLines.length - 1) * LINE_H;
+        const idTotalSpan = (idLines.length - 1) * LINE_H_ID;
+        const totalSpan = nameTotalSpan + NAME_ID_GAP + idTotalSpan;
+        const firstY = Math.round(b.y + oy + (b.height - totalSpan) / 2);
+        for (let i = 0; i < nameLines.length; i++) {
+            parts.push(`<text class="text-primary" x="${cx}" y="${firstY + i * LINE_H}" text-anchor="middle" dominant-baseline="central">${escXml(nameLines[i])}</text>`);
+        }
+        const idFirstY = firstY + nameTotalSpan + NAME_ID_GAP;
+        for (let i = 0; i < idLines.length; i++) {
+            parts.push(`<text class="text-id" x="${cx}" y="${idFirstY + i * LINE_H_ID}" text-anchor="middle" dominant-baseline="central">${escXml(idLines[i])}</text>`);
+        }
     }
     else {
-        // Container block: name + (ID) on the single header line; ID in grey.
-        const headerY = b.y + oy + b.headerHeight / 2;
-        const idSuffix = ` (${b.id})`;
-        const idSuffixW = idSuffix.length * CHAR_W_ID;
-        const nameMaxChars = Math.max(4, Math.floor((b.width - idSuffixW) / CHAR_W));
-        const nameText = wordTruncate(b.name, nameMaxChars);
-        parts.push(`<text class="text-primary" x="${cx}" y="${headerY}" text-anchor="middle" dominant-baseline="central">${escXml(nameText)}<tspan fill="var(--ts-text-secondary, #64748b)" font-size="10" font-weight="600">${escXml(idSuffix)}</tspan></text>`);
+        // Container block: name (text-primary) above, ID (text-id, grey) below — both
+        // single-line, truncated with `…` to fit within `b.width`. The header strip is
+        // only `headerHeight` tall (default 28px), which is enough for one line each at
+        // the configured text sizes. Stacking the ID as its own text-id element keeps
+        // the wrapping/truncation rule consistent with leaves and guarantees no overflow
+        // for any combination of name/ID length.
+        const maxCharsName = Math.max(4, Math.floor(innerW / CHAR_W));
+        const maxCharsId = Math.max(4, Math.floor(innerW / CHAR_W_ID));
+        const nameText = truncateLine(b.name, maxCharsName);
+        const idText = truncateId(b.id, maxCharsId);
+        const headerMid = b.y + oy + b.headerHeight / 2;
+        const halfSpan = (LINE_H + LINE_H_ID) / 4;
+        const nameY = Math.round(headerMid - halfSpan);
+        const idY = Math.round(headerMid + halfSpan);
+        parts.push(`<text class="text-primary" x="${cx}" y="${nameY}" text-anchor="middle" dominant-baseline="central">${escXml(nameText)}</text>`);
+        parts.push(`<text class="text-id" x="${cx}" y="${idY}" text-anchor="middle" dominant-baseline="central">${escXml(idText)}</text>`);
         for (const c of b.children)
             emitBlockSvg(c, ox, oy, parts);
     }

package/dist/webview/render-goals.js

@@ -14,6 +14,7 @@ import { layoutGoalTree } from '../goals/layout.js';
 import { horizontalCubicEdgePath, DEFAULT_EDGE_CURVATURE } from '../edge-path.js';
 import { generateSvgEmbedCss } from '../theme/index.js';
 import { escXml } from './render-util.js';
+import { ENTITY_NODE_RX } from './notation-style.js';
 const NODE_W = 250;
 const NODE_H = 72;
 const RANK_SEP = 100;
@@ -103,7 +104,7 @@ export function renderGoalsLayoutSvg(layout, options = {}) {
         const typeLabel = n.data.type ?? '';
         const idText = String(n.data.id);
         return `<g>
-  <rect class="diagram-node level-${level}" x="${x}" y="${y}" width="${n.width}" height="${n.height}" rx="8"/>
+  <rect class="diagram-node level-${level}" x="${x}" y="${y}" width="${n.width}" height="${n.height}" rx="${ENTITY_NODE_RX}"/>
   <text class="text-primary" x="${x + n.width / 2}" y="${nameY1}" text-anchor="middle" dominant-baseline="central">${escXml(line1)}</text>${twoLines ? `
   <text class="text-primary" x="${x + n.width / 2}" y="${nameY2}" text-anchor="middle" dominant-baseline="central">${escXml(line2)}</text>` : ''}${typeLabel ? `
   <text class="text-secondary" x="${x + n.width / 2}" y="${typeY}" text-anchor="middle" dominant-baseline="central">${escXml(typeLabel)}</text>` : ''}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@transitrix/diagrams",
-  "version": "1.3.0",
+  "version": "1.5.0",
   "type": "module",
   "description": "Shared rendering, validation, and pure mutations for Transitrix custom diagram formats.",
   "license": "MIT",

package/src/__tests__/yaml-normalize.test.ts

@@ -61,8 +61,8 @@ describe('coerceDatesToIsoStrings', () => {
 describe('coerceDatesToIsoStrings — js-yaml integration', () => {
   it('quoted ISO dates are preserved untouched', () => {
     const text = [
-      'notation: activities',
-      'activities:',
+      'notation: action',
+      'actions:',
       '  - id: "A-001"',
       '    name: "Quoted dates"',
       '    duration: 3',
@@ -70,18 +70,18 @@ describe('coerceDatesToIsoStrings — js-yaml integration', () => {
       '    end_date: "2026-06-03"',
       '',
     ].join('\n');
-    const parsed = yaml.load(text) as { activities: { start_date: unknown; end_date: unknown }[] };
+    const parsed = yaml.load(text) as { actions: { start_date: unknown; end_date: unknown }[] };
     coerceDatesToIsoStrings(parsed);
-    expect(parsed.activities[0].start_date).toBe('2026-06-01');
-    expect(parsed.activities[0].end_date).toBe('2026-06-03');
+    expect(parsed.actions[0].start_date).toBe('2026-06-01');
+    expect(parsed.actions[0].end_date).toBe('2026-06-03');
     const v = validateActivities(parsed);
     expect(v.valid).toBe(true);
   });
 
   it('bare ISO dates are coerced to ISO strings and pass validation', () => {
     const text = [
-      'notation: activities',
-      'activities:',
+      'notation: action',
+      'actions:',
       '  - id: "A-001"',
       '    name: "Bare dates"',
       '    duration: 3',
@@ -89,14 +89,14 @@ describe('coerceDatesToIsoStrings — js-yaml integration', () => {
       '    end_date: 2026-06-03',
       '',
     ].join('\n');
-    const parsed = yaml.load(text) as { activities: { start_date: unknown; end_date: unknown }[] };
+    const parsed = yaml.load(text) as { actions: { start_date: unknown; end_date: unknown }[] };
     // Without coercion, js-yaml returns Date instances and the validator
     // would emit ACT-008 because typeof !== 'string'. Sanity-check that
     // assumption before normalisation.
-    expect(parsed.activities[0].start_date).toBeInstanceOf(Date);
+    expect(parsed.actions[0].start_date).toBeInstanceOf(Date);
     coerceDatesToIsoStrings(parsed);
-    expect(parsed.activities[0].start_date).toBe('2026-06-01');
-    expect(parsed.activities[0].end_date).toBe('2026-06-03');
+    expect(parsed.actions[0].start_date).toBe('2026-06-01');
+    expect(parsed.actions[0].end_date).toBe('2026-06-03');
     const v = validateActivities(parsed);
     expect(v.valid).toBe(true);
   });

package/src/activities/__tests__/gantt.test.ts

@@ -243,3 +243,48 @@ describe('computeGanttLayout — pinned mode', () => {
     expect(r.links[0].targetId).toBe('B');
   });
 });
+
+describe('computeGanttLayout — project-type activity suppression (regression for follow-up to #421)', () => {
+  // A project-type container activity is classified as a phase and rolls up into
+  // a bar spanning the full timeline. buildActivityViews filters project-type
+  // activities before calling computeGanttLayout so this bar never reaches the
+  // rendered Gantt. These tests confirm: (a) the container bar exists when NOT
+  // filtered, and (b) filtering it out still yields correct leaf/phase bars.
+
+  const docWithProjectContainer: ActivityDoc = {
+    notation: 'action',
+    title: 'Platform Launch Action',
+    project: { start_date: '2026-06-01' },
+    activities: [
+      { id: 'PROJ-1', name: 'Platform Launch', activity_type: 'project' },
+      { id: 'TASK-1', name: 'Design', activity_type: 'task', duration: 3, parent: 'PROJ-1' },
+      { id: 'TASK-2', name: 'Implement', activity_type: 'task', duration: 5, parent: 'PROJ-1', predecessors: ['TASK-1'] },
+    ],
+  };
+
+  it('includes the project container as a phase bar when not pre-filtered', () => {
+    const r = assertRenders(computeGanttLayout(docWithProjectContainer));
+    const projBar = r.bars.find(b => b.id === 'PROJ-1');
+    expect(projBar).toBeDefined();
+    expect(projBar!.kind).toBe('phase');
+  });
+
+  it('still renders leaf tasks correctly when project-type activity is pre-filtered', () => {
+    const filteredDoc: ActivityDoc = {
+      ...docWithProjectContainer,
+      activities: docWithProjectContainer.activities.filter(
+        (a) => a.activity_type?.toLowerCase() !== 'project',
+      ),
+    };
+    const r = assertRenders(computeGanttLayout(filteredDoc));
+    // Project container bar must not appear.
+    expect(r.bars.find(b => b.id === 'PROJ-1')).toBeUndefined();
+    // Leaf tasks must still render with correct dates.
+    const t1 = r.bars.find(b => b.id === 'TASK-1')!;
+    const t2 = r.bars.find(b => b.id === 'TASK-2')!;
+    expect(t1).toBeDefined();
+    expect(t2).toBeDefined();
+    expect(t1.startDate).toBe('2026-06-01');
+    expect(t2.startDate).toBe('2026-06-04'); // ES = 3 (after TASK-1)
+  });
+});