@transitrix/diagrams 1.0.0 → 1.1.0

package/dist/fgca/resolver.js

@@ -0,0 +1,126 @@
+/**
+ * FGCA canon resolver — assembles a flat canonical FGCA document from a
+ * view_config projection and a canon element/relation store (VP-3).
+ *
+ * Output shape matches the flat form that `parseCanonicalFGCA` expects:
+ * top-level `factors[]`, `goals[]`, `changes[]`, `activities[]` with typed
+ * string IDs.  Filesystem-free — callable from unit tests without vscode.
+ */
+function isObject(v) {
+    return !!v && typeof v === 'object' && !Array.isArray(v);
+}
+function str(v) {
+    return typeof v === 'string' && v.trim().length > 0 ? v : undefined;
+}
+function strArray(v) {
+    if (!Array.isArray(v))
+        return [];
+    return v.filter((x) => typeof x === 'string' && x.trim().length > 0);
+}
+function collectByNotation(docs, notation) {
+    const out = new Map();
+    for (const doc of docs) {
+        if (!isObject(doc))
+            continue;
+        if (str(doc['notation']) !== notation)
+            continue;
+        const id = str(doc['id']);
+        if (!id)
+            continue;
+        if (!out.has(id))
+            out.set(id, doc);
+    }
+    return out;
+}
+/**
+ * Returns true when the parsed view document uses the canon-projection form
+ * (`view_config` key present, no inline `factors[]` / `goals[]` arrays).
+ * Used by the preview to decide whether to run the resolver or fall back to
+ * direct `parseCanonicalFGCA` on the inline document.
+ */
+export function isFGCAViewDoc(parsed) {
+    if (!isObject(parsed))
+        return false;
+    return 'view_config' in parsed && !('factors' in parsed) && !('goals' in parsed);
+}
+/**
+ * Assemble a flat canonical FGCA document from the canon element store,
+ * filtered by the view document's `view_config`.  The return value is ready
+ * to pass to `parseCanonicalFGCA`.
+ *
+ * Cross-reference fields (`goal.factors[]`, `change.goals[]`,
+ * `activity.changes[]`) are carried from the canon elements unchanged; the
+ * resolver decides which elements to include, not how they are shaped.
+ */
+export function resolveFGCA(viewDoc, sources) {
+    if (!isObject(viewDoc)) {
+        return { notation: 'fgca', factors: [], goals: [], changes: [], activities: [] };
+    }
+    const vc = isObject(viewDoc['view_config']) ? viewDoc['view_config'] : {};
+    const goalsConf = isObject(vc['goals']) ? vc['goals'] : {};
+    const factorsConf = isObject(vc['factors']) ? vc['factors'] : {};
+    const changesConf = isObject(vc['changes']) ? vc['changes'] : {};
+    const activitiesConf = isObject(vc['activities']) ? vc['activities'] : {};
+    const factorElemsLegacy = collectByNotation(sources.elements, 'factor');
+    const factorElemsNew = collectByNotation(sources.elements, 'driver');
+    const factorElems = new Map([...factorElemsLegacy, ...factorElemsNew]);
+    const goalElems = collectByNotation(sources.elements, 'goal');
+    const changeElems = collectByNotation(sources.elements, 'change');
+    const activityElems = collectByNotation(sources.elements, 'activity');
+    // 1. Select goal set
+    const goalsFilter = str(goalsConf['filter']) ?? 'all';
+    let selectedGoals;
+    if (goalsFilter === 'ids') {
+        const ids = strArray(goalsConf['ids']);
+        selectedGoals = ids.flatMap((id) => { const g = goalElems.get(id); return g ? [g] : []; });
+    }
+    else if (goalsFilter === 'tags') {
+        const tags = strArray(goalsConf['tags']);
+        selectedGoals = [...goalElems.values()].filter((g) => strArray(g['tags']).some((t) => tags.includes(t)));
+    }
+    else {
+        // 'all' — include every goal element in the canon store
+        selectedGoals = [...goalElems.values()];
+    }
+    const selectedGoalIds = new Set(selectedGoals.map((g) => str(g['id'])).filter((x) => x !== undefined));
+    // 2. Select factors: derived follows goal.factors[]; all = every factor
+    let selectedFactors;
+    if (str(factorsConf['surface']) === 'all') {
+        selectedFactors = [...factorElems.values()];
+    }
+    else {
+        const refIds = new Set();
+        for (const g of selectedGoals)
+            for (const fid of strArray(g['factors']))
+                refIds.add(fid);
+        selectedFactors = [...refIds].flatMap((id) => { const f = factorElems.get(id); return f ? [f] : []; });
+    }
+    // 3. Select changes: derived = changes referencing ≥1 selected goal
+    let selectedChanges;
+    if (str(changesConf['surface']) === 'all') {
+        selectedChanges = [...changeElems.values()];
+    }
+    else {
+        selectedChanges = [...changeElems.values()].filter((c) => strArray(c['goals']).some((gid) => selectedGoalIds.has(gid)));
+    }
+    const selectedChangeIds = new Set(selectedChanges.map((c) => str(c['id'])).filter((x) => x !== undefined));
+    // 4. Select activities: derived = reference ≥1 selected change or goal (degenerate FGA link)
+    let selectedActivities;
+    if (str(activitiesConf['surface']) === 'all') {
+        selectedActivities = [...activityElems.values()];
+    }
+    else {
+        selectedActivities = [...activityElems.values()].filter((a) => strArray(a['changes']).some((cid) => selectedChangeIds.has(cid)) ||
+            strArray(a['goals']).some((gid) => selectedGoalIds.has(gid)));
+    }
+    return {
+        notation: 'fgca',
+        id: viewDoc['id'],
+        name: viewDoc['name'],
+        spec_version: viewDoc['spec_version'],
+        factors: selectedFactors,
+        goals: selectedGoals,
+        changes: selectedChanges,
+        activities: selectedActivities,
+    };
+}

package/dist/fgca/types.d.ts

@@ -1,30 +1,30 @@
-export interface FactorItem {
-    id: number;
+export interface DriverItem {
+    id: number | string;
     name: string;
 }
 export interface GoalItem {
-    id: number;
+    id: number | string;
     name: string;
     level?: number;
     /** Goals may carry embedded factor links returned by the API. */
     factor?: Array<{
-        id: number;
+        id: number | string;
     }>;
 }
 export interface BdnChangeWithActivities {
-    id: number;
+    id: number | string;
     name: string;
-    goal_id: number;
-    activity_ids: number[];
+    goal_id: number | string;
+    activity_ids: Array<number | string>;
 }
 export interface ActivityItem {
-    id: number;
+    id: number | string;
     name: string;
-    goal_id?: number | null;
+    goal_id?: number | string | null;
     activity_type_id?: number;
 }
 export interface ActivityTypeItem {
-    id: number;
+    id: number | string;
     name?: string;
 }
 export interface DiagramStyle {
@@ -34,6 +34,6 @@ export interface DiagramStyle {
     edgeWidth?: number;
 }
 /** The four columns of the FGCA diagram. */
-export type FGCAColumn = "factor" | "goal" | "change" | "activity";
+export type FGCAColumn = "driver" | "goal" | "change" | "activity";
 export declare const ALL_FGCA_COLUMNS: FGCAColumn[];
 export declare const FGCA_COLUMN_LABELS: Record<FGCAColumn, string>;

package/dist/fgca/types.js

@@ -1,6 +1,6 @@
-export const ALL_FGCA_COLUMNS = ["factor", "goal", "change", "activity"];
+export const ALL_FGCA_COLUMNS = ["driver", "goal", "change", "activity"];
 export const FGCA_COLUMN_LABELS = {
-    factor: "F",
+    driver: "D",
     goal: "G",
     change: "C",
     activity: "A",

package/dist/fgca/validate.d.ts

@@ -1,4 +1,4 @@
-import type { FactorItem, GoalItem, BdnChangeWithActivities, ActivityItem } from './types.js';
+import type { DriverItem, GoalItem, BdnChangeWithActivities, ActivityItem } from './types.js';
 import type { ValidationError, ValidationWarning, ValidationResult } from '../validation-types.js';
 export type FGCAValidationError = ValidationError;
 export type FGCAValidationWarning = ValidationWarning;
@@ -6,7 +6,7 @@ export type FGCAValidationResult = ValidationResult;
 export interface FGCADoc {
     notation: string;
     spec_version?: string;
-    factors: FactorItem[];
+    factors: DriverItem[];
     goals: GoalItem[];
     changes: BdnChangeWithActivities[];
     activities: ActivityItem[];

package/dist/fgca/validate.js

@@ -9,10 +9,13 @@ export function validateFGCADoc(input) {
         errors.push({ code: 'MISSING_NOTATION', message: 'notation field is required' });
         return { valid: false, errors, warnings };
     }
-    if (raw.notation !== 'fgca') {
-        errors.push({ code: 'WRONG_NOTATION', message: `notation must be "fgca", got "${String(raw.notation)}"` });
+    if (raw.notation !== 'fgca' && raw.notation !== 'dgca') {
+        errors.push({ code: 'WRONG_NOTATION', message: `notation must be "dgca" (or legacy "fgca"), got "${String(raw.notation)}"` });
         return { valid: false, errors, warnings };
     }
+    if (raw.notation === 'fgca') {
+        warnings.push({ code: 'DEPRECATED_NOTATION', message: 'notation "fgca" is deprecated — rename to "dgca"' });
+    }
     if (!Array.isArray(raw.factors))
         errors.push({ code: 'SCHEMA_INVALID', message: 'factors must be an array', path: 'factors' });
     if (!Array.isArray(raw.goals))
@@ -29,7 +32,7 @@ export function validateFGCADoc(input) {
         for (const el of arr) {
             if (el && typeof el === 'object') {
                 const id = el.id;
-                if (typeof id === 'number')
+                if (typeof id === 'number' || typeof id === 'string')
                     out.add(id);
             }
         }
@@ -45,8 +48,8 @@ export function validateFGCADoc(input) {
             continue;
         }
         const factor = f;
-        if (typeof factor.id !== 'number')
-            errors.push({ code: 'SCHEMA_INVALID', message: 'factor id must be a number', path: `factors[${i}]` });
+        if (typeof factor.id !== 'number' && typeof factor.id !== 'string')
+            errors.push({ code: 'SCHEMA_INVALID', message: 'factor id must be a number or string', path: `factors[${i}]` });
         if (typeof factor.name !== 'string' || !factor.name.trim())
             errors.push({ code: 'EMPTY_NAME', message: `Factor ${String(factor.id)} has empty name`, path: `factors[${i}]` });
     }
@@ -57,8 +60,8 @@ export function validateFGCADoc(input) {
             continue;
         }
         const goal = g;
-        if (typeof goal.id !== 'number')
-            errors.push({ code: 'SCHEMA_INVALID', message: 'goal id must be a number', path: `goals[${i}]` });
+        if (typeof goal.id !== 'number' && typeof goal.id !== 'string')
+            errors.push({ code: 'SCHEMA_INVALID', message: 'goal id must be a number or string', path: `goals[${i}]` });
         if (typeof goal.name !== 'string' || !goal.name.trim())
             errors.push({ code: 'EMPTY_NAME', message: `Goal ${String(goal.id)} has empty name`, path: `goals[${i}]` });
         const factorRefs = Array.isArray(goal.factor) ? goal.factor : [];
@@ -66,7 +69,7 @@ export function validateFGCADoc(input) {
             if (!fr || typeof fr !== 'object')
                 continue;
             const fid = fr.id;
-            if (typeof fid === 'number' && !factorIds.has(fid)) {
+            if ((typeof fid === 'number' || typeof fid === 'string') && !factorIds.has(fid)) {
                 warnings.push({ code: 'BROKEN_REF', message: `Goal ${String(goal.id)} references missing factor ${fid}`, path: `goals[${i}].factor` });
             }
         }
@@ -78,16 +81,16 @@ export function validateFGCADoc(input) {
             continue;
         }
         const change = c;
-        if (typeof change.id !== 'number')
-            errors.push({ code: 'SCHEMA_INVALID', message: 'change id must be a number', path: `changes[${i}]` });
+        if (typeof change.id !== 'number' && typeof change.id !== 'string')
+            errors.push({ code: 'SCHEMA_INVALID', message: 'change id must be a number or string', path: `changes[${i}]` });
         if (typeof change.name !== 'string' || !change.name.trim())
             errors.push({ code: 'EMPTY_NAME', message: `Change ${String(change.id)} has empty name`, path: `changes[${i}]` });
-        if (typeof change.goal_id === 'number' && !goalIds.has(change.goal_id)) {
+        if ((typeof change.goal_id === 'number' || typeof change.goal_id === 'string') && !goalIds.has(change.goal_id)) {
             warnings.push({ code: 'BROKEN_REF', message: `Change ${String(change.id)} references missing goal ${change.goal_id}`, path: `changes[${i}].goal_id` });
         }
         const aids = Array.isArray(change.activity_ids) ? change.activity_ids : [];
         for (const aid of aids) {
-            if (typeof aid === 'number' && !activityIds.has(aid)) {
+            if ((typeof aid === 'number' || typeof aid === 'string') && !activityIds.has(aid)) {
                 warnings.push({ code: 'BROKEN_REF', message: `Change ${String(change.id)} references missing activity ${aid}`, path: `changes[${i}].activity_ids` });
             }
         }
@@ -99,8 +102,8 @@ export function validateFGCADoc(input) {
             continue;
         }
         const activity = a;
-        if (typeof activity.id !== 'number')
-            errors.push({ code: 'SCHEMA_INVALID', message: 'activity id must be a number', path: `activities[${i}]` });
+        if (typeof activity.id !== 'number' && typeof activity.id !== 'string')
+            errors.push({ code: 'SCHEMA_INVALID', message: 'activity id must be a number or string', path: `activities[${i}]` });
         if (typeof activity.name !== 'string' || !activity.name.trim())
             errors.push({ code: 'EMPTY_NAME', message: `Activity ${String(activity.id)} has empty name`, path: `activities[${i}]` });
     }

package/dist/goals/index.d.ts

@@ -1,4 +1,4 @@
-export type { Goal, GoalType, GoalTree, Factor, ImpactType, ValidationResult, ValidationError, ValidationWarning, MutationResult, LayoutOptions, LaidOutNode, LaidOutEdge, GoalTreeLayout, } from './types.js';
+export type { Goal, GoalType, GoalTree, ImpactType, ValidationResult, ValidationError, ValidationWarning, MutationResult, LayoutOptions, LaidOutNode, LaidOutEdge, GoalTreeLayout, } from './types.js';
 export { validateGoalTree } from './validate.js';
 export { parseCanonicalGoals } from './parse-canonical.js';
 export type { CanonicalGoalsResult } from './parse-canonical.js';

package/dist/index.d.ts

@@ -1,13 +1,16 @@
 export * from "./activities/index";
 export * from "./activity-card/index";
+export * from "./actor/index";
 export * from "./geometry";
 export * from "./applications/index";
 export * from "./assertion/index";
 export * from "./blocks/index";
 export * from "./capability-map/index";
+export * from "./change/index";
 export * from "./compliance/index";
 export * from "./compliance-matrix/index";
 export * from "./confidence/index";
+export * from "./factor/index";
 export * from "./fgca/index";
 export * from "./goals/index";
 export * from "./process-blueprint/index";
@@ -16,6 +19,8 @@ export * from "./products/index";
 export * from "./repo-validate/index";
 export * from "./requirement/index";
 export * from "./scenarios/index";
+export * from "./stakeholder/index";
+export * from "./target-state/index";
 export { SCHEMA_VERSION } from "./schema-version";
 export * from "./theme/index";
 export * from "./typed-id";

package/dist/index.js

@@ -1,13 +1,16 @@
 export * from "./activities/index";
 export * from "./activity-card/index";
+export * from "./actor/index";
 export * from "./geometry";
 export * from "./applications/index";
 export * from "./assertion/index";
 export * from "./blocks/index";
 export * from "./capability-map/index";
+export * from "./change/index";
 export * from "./compliance/index";
 export * from "./compliance-matrix/index";
 export * from "./confidence/index";
+export * from "./factor/index";
 export * from "./fgca/index";
 export * from "./goals/index";
 export * from "./process-blueprint/index";
@@ -16,6 +19,8 @@ export * from "./products/index";
 export * from "./repo-validate/index";
 export * from "./requirement/index";
 export * from "./scenarios/index";
+export * from "./stakeholder/index";
+export * from "./target-state/index";
 export { SCHEMA_VERSION } from "./schema-version";
 export * from "./theme/index";
 export * from "./typed-id";

package/dist/process-blueprint/__tests__/layout.test.js

@@ -156,4 +156,41 @@ describe('layoutProcessBlueprint', () => {
         expect(layout.stageColumnWidth).toBe(300);
         expect(layout.stageHeaders[1].x).toBe(200 + 300);
     });
+    describe('visibleAspects', () => {
+        const FILE_WITH_ALL = build({
+            stages: [{ id: 'STAGE-1', name: 'A', goal: 'g', result: 'r' }],
+            systems: [{ name: 'OMS', stages: ['STAGE-1'] }],
+            actors: [{ name: 'Ops', stages: ['STAGE-1'] }],
+            equipment: [{ name: 'Printer', stages: ['STAGE-1'] }],
+        });
+        it('shows all categories when visibleAspects is not set', () => {
+            const layout = layoutProcessBlueprint(FILE_WITH_ALL);
+            expect(layout.aspectRows.map(r => r.category)).toEqual(expect.arrayContaining(['systems', 'actors', 'equipment']));
+            expect(layout.aspectRows).toHaveLength(3);
+        });
+        it('limits rows to those in visibleAspects', () => {
+            const layout = layoutProcessBlueprint(FILE_WITH_ALL, {
+                visibleAspects: ['systems'],
+            });
+            expect(layout.aspectRows).toHaveLength(1);
+            expect(layout.aspectRows[0].category).toBe('systems');
+        });
+        it('suppresses all aspect rows when visibleAspects is empty', () => {
+            const layout = layoutProcessBlueprint(FILE_WITH_ALL, { visibleAspects: [] });
+            expect(layout.aspectRows).toHaveLength(0);
+        });
+        it('preserves the canonical ASPECT_CATEGORIES order within the filtered set', () => {
+            const layout = layoutProcessBlueprint(FILE_WITH_ALL, {
+                visibleAspects: ['equipment', 'systems'],
+            });
+            expect(layout.aspectRows.map(r => r.category)).toEqual(['systems', 'equipment']);
+        });
+        it('ignores categories in visibleAspects that have no data', () => {
+            const layout = layoutProcessBlueprint(FILE_WITH_ALL, {
+                visibleAspects: ['systems', 'information_entities'],
+            });
+            expect(layout.aspectRows).toHaveLength(1);
+            expect(layout.aspectRows[0].category).toBe('systems');
+        });
+    });
 });

package/dist/process-blueprint/index.d.ts

@@ -1,4 +1,4 @@
-export type { AspectCategory, Stage, AspectEntry, LaneConfig, ProcessBlueprintHeader, ProcessBlueprintFile, ProcessBlueprintLayoutOptions, LegendCell, StageHeaderCell, StageTextCell, AspectPill, AspectRow, ProcessBlueprintLayout, ComplianceDecoration, ComplianceChip, ComplianceRow, ComplianceLaneConfig, ComplianceLaneAssertion, ComplianceLaneRequirement, ComplianceLaneInput, } from './types.js';
+export type { AspectCategory, RowId, Stage, AspectEntry, LaneConfig, ProcessBlueprintHeader, ProcessBlueprintFile, ProcessBlueprintLayoutOptions, LegendCell, StageHeaderCell, StageTextCell, AspectPill, AspectRow, ProcessBlueprintLayout, ComplianceDecoration, ComplianceChip, ComplianceRow, ComplianceLaneConfig, ComplianceLaneAssertion, ComplianceLaneRequirement, ComplianceLaneInput, } from './types.js';
 export { validateProcessBlueprint } from './validate.js';
 export type { ValidationError as ProcessBlueprintValidationError, ValidationWarning as ProcessBlueprintValidationWarning, ValidationResult as ProcessBlueprintValidationResult, } from './validate.js';
 export { layoutProcessBlueprint } from './layout.js';

package/dist/process-blueprint/layout.js

@@ -12,14 +12,19 @@ const DEFAULTS = {
     goalRowHeight: 56,
     resultRowHeight: 56,
     aspectRowMinHeight: 60,
-    pillHeight: 28,
+    pillHeight: 40,
     pillGap: 4,
     cellPadding: 8,
-    textLineHeight: 15,
-    textCharWidth: 6.2,
+    // 17px gives comfortable breathing room between wrapped lines at typical
+    // webview font sizes (VS Code uses ~13–14px body, SVG text-secondary ≈ same).
+    textLineHeight: 17,
+    // 7.5px per char is a conservative estimate that causes wrap to trigger
+    // before text visually overflows the cell border.
+    textCharWidth: 7.5,
     cellTextPadX: 10,
     cellTextPadY: 10,
-    maxTextLines: 6,
+    // No hard truncation: rows grow to fit all wrapped lines.
+    maxTextLines: 100,
 };
 function resolveOptions(options) {
     return { ...DEFAULTS, ...(options ?? {}) };
@@ -285,8 +290,21 @@ function deriveComplianceRow(stages, stageIndexById, input, opts, yStart) {
 export function layoutProcessBlueprint(file, options) {
     const opts = resolveOptions(options);
     const pb = file.process_blueprint;
-    const stages = Array.isArray(pb?.stages) ? pb.stages : [];
+    // Filter stages by visibleStages if set
+    const allStages = Array.isArray(pb?.stages) ? pb.stages : [];
+    const stages = opts.visibleStages
+        ? allStages.filter(s => s?.id != null && opts.visibleStages.includes(s.id))
+        : allStages;
     const stageIndexById = buildStageIndex(stages);
+    // Row visibility from visibleRows
+    const visRows = opts.visibleRows;
+    const showGoal = !visRows || visRows.includes('goal');
+    const showResult = !visRows || visRows.includes('result');
+    const effectiveVisibleAspects = visRows
+        ? ASPECT_CATEGORIES.filter(c => visRows.includes(c))
+        : opts.visibleAspects;
+    const effectiveComplianceEnabled = opts.complianceLane?.enabled === true &&
+        (!visRows || visRows.includes('compliance'));
     // Stage headers
     const stageHeaders = stages.map((s, i) => ({
         stageIndex: i,
@@ -307,33 +325,40 @@ export function layoutProcessBlueprint(file, options) {
     };
     const goalLines = stages.map(s => wrap(s?.goal ?? ''));
     const resultLines = stages.map(s => wrap(s?.result ?? ''));
-    const goalRowY = opts.stageHeaderHeight;
-    const goalRowHeight = rowHeightFor(goalLines.map(l => l.length), opts.goalRowHeight);
-    const resultRowY = goalRowY + goalRowHeight;
-    const resultRowHeight = rowHeightFor(resultLines.map(l => l.length), opts.resultRowHeight);
-    const goalCells = stages.map((s, i) => ({
-        stageIndex: i,
-        text: s?.goal ?? '',
-        lines: goalLines[i],
-        x: opts.legendColumnWidth + i * opts.stageColumnWidth,
-        y: goalRowY,
-        width: opts.stageColumnWidth,
-        height: goalRowHeight,
-    }));
-    const resultCells = stages.map((s, i) => ({
-        stageIndex: i,
-        text: s?.result ?? '',
-        lines: resultLines[i],
-        x: opts.legendColumnWidth + i * opts.stageColumnWidth,
-        y: resultRowY,
-        width: opts.stageColumnWidth,
-        height: resultRowHeight,
-    }));
-    const aspectsStartY = resultRowY + resultRowHeight;
+    let cursorY = opts.stageHeaderHeight;
+    let goalRowY = 0, goalRowHeight = 0;
+    let resultRowY = 0, resultRowHeight = 0;
+    const goalCells = [];
+    const resultCells = [];
+    if (showGoal) {
+        goalRowY = cursorY;
+        goalRowHeight = rowHeightFor(goalLines.map(l => l.length), opts.goalRowHeight);
+        goalCells.push(...stages.map((s, i) => ({
+            stageIndex: i, text: s?.goal ?? '', lines: goalLines[i],
+            x: opts.legendColumnWidth + i * opts.stageColumnWidth, y: goalRowY,
+            width: opts.stageColumnWidth, height: goalRowHeight,
+        })));
+        cursorY += goalRowHeight;
+    }
+    if (showResult) {
+        resultRowY = cursorY;
+        resultRowHeight = rowHeightFor(resultLines.map(l => l.length), opts.resultRowHeight);
+        resultCells.push(...stages.map((s, i) => ({
+            stageIndex: i, text: s?.result ?? '', lines: resultLines[i],
+            x: opts.legendColumnWidth + i * opts.stageColumnWidth, y: resultRowY,
+            width: opts.stageColumnWidth, height: resultRowHeight,
+        })));
+        cursorY += resultRowHeight;
+    }
+    const aspectsStartY = cursorY;
     // Aspect rows: only categories with at least one entry, in fixed order.
+    // When effectiveVisibleAspects is set, skip categories not in the list.
+    const aspectCategoriesToRender = effectiveVisibleAspects !== undefined
+        ? ASPECT_CATEGORIES.filter(c => effectiveVisibleAspects.includes(c))
+        : ASPECT_CATEGORIES;
     const aspectRows = [];
     let aspectCursorY = aspectsStartY;
-    for (const category of ASPECT_CATEGORIES) {
+    for (const category of aspectCategoriesToRender) {
         const arr = pb?.[category];
         if (!Array.isArray(arr) || arr.length === 0)
             continue;
@@ -354,6 +379,13 @@ export function layoutProcessBlueprint(file, options) {
             const x = opts.legendColumnWidth + p.startStageIndex * opts.stageColumnWidth + opts.cellPadding;
             const width = (p.endStageIndex - p.startStageIndex + 1) * opts.stageColumnWidth - 2 * opts.cellPadding;
             const y = aspectCursorY + opts.cellPadding + slot[i] * (opts.pillHeight + opts.pillGap);
+            const pillMaxChars = Math.max(4, Math.floor((width - 2 * opts.cellPadding) / opts.textCharWidth));
+            const nameWrapped = wrapText(p.name, pillMaxChars, 2);
+            // Show id as second line only when the name fits on one line; otherwise
+            // use both lines for the name so it isn't truncated.
+            const lines = p.id && nameWrapped.length <= 1
+                ? [...nameWrapped, p.id].slice(0, 2)
+                : nameWrapped;
             return {
                 category: p.category,
                 entryIndex: p.entryIndex,
@@ -365,6 +397,7 @@ export function layoutProcessBlueprint(file, options) {
                 y,
                 width,
                 height: opts.pillHeight,
+                lines,
             };
         });
         aspectRows.push({
@@ -377,7 +410,7 @@ export function layoutProcessBlueprint(file, options) {
     }
     // Compliance lane — derived from assertions/requirements, rendered after aspect rows.
     let complianceRow;
-    if (opts.complianceLane?.enabled && opts.complianceInput) {
+    if (effectiveComplianceEnabled && opts.complianceInput) {
         complianceRow = deriveComplianceRow(stages, stageIndexById, opts.complianceInput, opts, aspectCursorY);
         if (complianceRow) {
             aspectCursorY += complianceRow.height;
@@ -385,8 +418,8 @@ export function layoutProcessBlueprint(file, options) {
     }
     // Legend (left column labels): one entry per row.
     const legend = [
-        { kind: 'goal', label: 'Goal', y: goalRowY, height: goalRowHeight },
-        { kind: 'result', label: 'Result', y: resultRowY, height: resultRowHeight },
+        ...(showGoal ? [{ kind: 'goal', label: 'Goal', y: goalRowY, height: goalRowHeight }] : []),
+        ...(showResult ? [{ kind: 'result', label: 'Result', y: resultRowY, height: resultRowHeight }] : []),
         ...aspectRows.map(row => ({
             kind: 'aspect',
             category: row.category,
@@ -394,9 +427,7 @@ export function layoutProcessBlueprint(file, options) {
             y: row.y,
             height: row.height,
         })),
-        ...(complianceRow
-            ? [{ kind: 'compliance', label: 'Compliance', y: complianceRow.y, height: complianceRow.height }]
-            : []),
+        ...(complianceRow ? [{ kind: 'compliance', label: 'Compliance', y: complianceRow.y, height: complianceRow.height }] : []),
     ];
     const totalWidth = opts.legendColumnWidth + stages.length * opts.stageColumnWidth;
     const totalHeight = aspectCursorY;

package/dist/process-blueprint/types.d.ts

@@ -1,4 +1,5 @@
 export type AspectCategory = 'systems' | 'actors' | 'equipment' | 'information_entities';
+export type RowId = 'goal' | 'result' | 'systems' | 'actors' | 'equipment' | 'information_entities' | 'compliance';
 /**
  * One of the three orthogonal decoration signals that can appear on a compliance
  * law chip (ADR 2026-06-09-compliance-impact-as-blueprint-lane §3):
@@ -24,7 +25,7 @@ export interface ComplianceLaneAssertion {
     /** Requirement ID this assertion is about. */
     about: string;
     /** Compliance realisation status. */
-    status: 'compliant' | 'partial' | 'non_compliant' | 'under_review' | 'n_a';
+    status: 'compliant' | 'partial' | 'non_compliant' | 'under_review' | 'pending_owner' | 'n_a';
     /**
      * Typed IDs of stages / process steps where the requirement is realised.
      * When empty/absent, the assertion covers the entire subject, not a specific stage.
@@ -106,7 +107,22 @@ export interface LaneConfig {
     compliance_filter?: {
         /** ISO jurisdiction codes; empty array means all jurisdictions. */
         jurisdictions?: string[];
+        /**
+         * Per-stage map of law IDs known from the previous generated snapshot.
+         * Key: stage ID; Value: array of law IDs present in that stage's previous report.
+         * Laws absent from the previous snapshot receive the `new` decoration.
+         * When absent, every law chip is treated as new.
+         */
+        previous_snapshot?: Record<string, string[]>;
     };
+    /**
+     * Lanes to show; controls which aspect rows and the compliance lane are rendered.
+     * Valid values: `"systems"` | `"actors"` | `"equipment"` | `"information_entities"` | `"compliance"`.
+     * When absent, all lanes with data are shown (current default behaviour).
+     * Named report config — committed, versioned. Per-user overrides live in
+     * `.transitrix/display-preferences/process-blueprint.json` (gitignored, never committed).
+     */
+    visible_lanes?: string[];
 }
 export interface ProcessBlueprintHeader {
     id: string;
@@ -155,6 +171,23 @@ export interface ProcessBlueprintLayoutOptions {
     complianceLane?: ComplianceLaneConfig;
     /** Assertion + requirement data for the compliance lane derivation. */
     complianceInput?: ComplianceLaneInput;
+    /**
+     * Restrict which aspect-category rows are rendered.
+     * When absent, all categories that have at least one entry are shown.
+     * Pass an empty array to suppress all aspect rows.
+     */
+    visibleAspects?: AspectCategory[];
+    /**
+     * Restrict which rows are rendered. When absent, all rows with data are shown.
+     * When set, takes precedence over `visibleAspects` for aspect categories and
+     * overrides `complianceLane.enabled` for the compliance row.
+     */
+    visibleRows?: RowId[];
+    /**
+     * Restrict which stages (columns) are rendered by their stage ID.
+     * When absent, all stages are shown.
+     */
+    visibleStages?: string[];
 }
 import type { LayoutBounds } from '../geometry.js';
 export type { LayoutBounds };
@@ -195,6 +228,8 @@ export interface AspectPill {
     y: number;
     width: number;
     height: number;
+    /** Word-wrapped lines of `name`, pre-fitted to the pill width by the layout. */
+    lines: string[];
 }
 export interface AspectRow {
     category: AspectCategory;

package/dist/scenarios/index.d.ts

@@ -1,2 +1,2 @@
-export type { ScenarioStatus, FactorRelevance, FactorView, GoalRef, CapabilityRef, ActivityRef, ProductRef, ProcessRef, ApplicationRef, ScenarioHeader, ScenarioFile, } from './types.js';
+export type { ScenarioStatus, DriverRelevance, DriverView, GoalRef, CapabilityRef, ActivityRef, ProductRef, ProcessRef, ApplicationRef, ScenarioHeader, ScenarioFile, } from './types.js';
 export { validateScenario } from './validate.js';