@transitrix/diagrams 1.8.13 → 1.8.19

package/dist/activities/validate.js

@@ -7,7 +7,15 @@ export function validateActivities(input) {
         return { valid: false, errors: [{ code: 'ACT-001', message: 'Input must be an object' }], warnings };
     }
     const raw = input;
-    // ACT-001: notation must be "action"
+    // ACT-001: notation must be "action". ACT-020 is deliberately NOT ported
+    // here (DSM's api02/internal/importer/activities.go ValidateActivities
+    // still accepts the pre-2026-06-25 "activities" notation/root-key alias
+    // with a warning) — PR #320 ("drop deprecated notation aliases
+    // fgca/fga/activities/activity-card") already removed that leniency from
+    // this validator on purpose, with tests asserting it is "no longer
+    // accepted". Re-introducing it would reverse a deliberate, shipped
+    // decision, not fill a gap; flagged in the PR for a call rather than
+    // silently reversed either way.
     if (raw.notation === undefined) {
         errors.push({ code: 'ACT-001', message: 'notation field is required' });
         return { valid: false, errors, warnings };

package/dist/blocks/index.d.ts

@@ -1,4 +1,5 @@
-export type { Block, NestedBlocksHeader, BlocksFile, BlocksLayoutOptions, LaidOutBlock, BlocksLayout, } from './types.js';
-export { validateNestedBlocks, isWellFormedBlock } from './validate.js';
-export type { ValidationError as BlocksValidationError, ValidationWarning as BlocksValidationWarning, ValidationResult as BlocksValidationResult, } from './validate.js';
-export { layoutNestedBlocks, iterateBlocks } from './layout.js';
+export type { Block, NestedBlocksHeader, BlocksFile, BlocksLayoutOptions, LaidOutBlock, BlocksLayout, GridColumn, GridRow, GridHeader, GridFile, GridLayoutOptions, LaidOutGridColumn, LaidOutGridRow, LaidOutGridCell, GridLayout, } from './types.js';
+export { validateNestedBlocks, validateGrid, validateBlocks, isWellFormedBlock } from './validate.js';
+export type { ValidationError as BlocksValidationError, ValidationWarning as BlocksValidationWarning, ValidationResult as BlocksValidationResult, GridRule, ValidateGridOptions, ValidateBlocksOptions, } from './validate.js';
+export { layoutNestedBlocks, layoutGrid, iterateBlocks } from './layout.js';
+export { GRID_TEMPLATE_RULES } from './templates/index.js';

package/dist/blocks/index.js

@@ -1,2 +1,3 @@
-export { validateNestedBlocks, isWellFormedBlock } from './validate.js';
-export { layoutNestedBlocks, iterateBlocks } from './layout.js';
+export { validateNestedBlocks, validateGrid, validateBlocks, isWellFormedBlock } from './validate.js';
+export { layoutNestedBlocks, layoutGrid, iterateBlocks } from './layout.js';
+export { GRID_TEMPLATE_RULES } from './templates/index.js';

package/dist/blocks/layout.d.ts

@@ -1,4 +1,11 @@
-import type { BlocksFile, BlocksLayout, BlocksLayoutOptions, LaidOutBlock } from './types.js';
+import type { BlocksFile, BlocksLayout, BlocksLayoutOptions, GridFile, GridLayout, GridLayoutOptions, LaidOutBlock } from './types.js';
 export declare function layoutNestedBlocks(file: BlocksFile, options?: BlocksLayoutOptions): BlocksLayout;
 /** Iterate every laid-out block (including nested children) in pre-order. */
 export declare function iterateBlocks(layout: BlocksLayout): Iterable<LaidOutBlock>;
+/**
+ * Matrix subset (08-blocks.md §4a): lay out a `grid:` root document as a
+ * single-layer rectangular table — a row-header column, a column-header row,
+ * and one cell per `(row, column)` pair. Assumes the document is already
+ * well-formed ({@link validateGrid}); callers validate first.
+ */
+export declare function layoutGrid(file: GridFile, options?: GridLayoutOptions): GridLayout;

package/dist/blocks/layout.js

@@ -7,6 +7,12 @@ const DEFAULTS = {
     childGap: 12,
     topLevelGap: 24,
 };
+const GRID_DEFAULTS = {
+    columnWidth: 130,
+    rowHeight: 44,
+    rowHeaderWidth: 200,
+    headerHeight: 56,
+};
 function resolveOptions(options) {
     return { ...DEFAULTS, ...(options ?? {}) };
 }
@@ -144,3 +150,54 @@ export function* iterateBlocks(layout) {
     for (const b of layout.blocks)
         yield* walk(b);
 }
+/**
+ * Matrix subset (08-blocks.md §4a): lay out a `grid:` root document as a
+ * single-layer rectangular table — a row-header column, a column-header row,
+ * and one cell per `(row, column)` pair. Assumes the document is already
+ * well-formed ({@link validateGrid}); callers validate first.
+ */
+export function layoutGrid(file, options) {
+    const opts = { ...GRID_DEFAULTS, ...(options ?? {}) };
+    const grid = file?.grid;
+    const rawColumns = Array.isArray(grid?.columns) ? grid.columns : [];
+    const rawRows = Array.isArray(grid?.rows) ? grid.rows : [];
+    const columns = rawColumns.map((c, i) => ({
+        id: c.id,
+        name: c.name,
+        x: opts.rowHeaderWidth + i * opts.columnWidth,
+        width: opts.columnWidth,
+    }));
+    const rows = rawRows.map((r, i) => ({
+        id: r.id,
+        name: r.name,
+        y: opts.headerHeight + i * opts.rowHeight,
+        height: opts.rowHeight,
+    }));
+    const cells = [];
+    for (let ri = 0; ri < rawRows.length; ri++) {
+        const row = rawRows[ri];
+        for (let ci = 0; ci < rawColumns.length; ci++) {
+            const col = rawColumns[ci];
+            const raw = row.assign?.[col.id];
+            cells.push({
+                rowId: row.id,
+                colId: col.id,
+                x: columns[ci].x,
+                y: rows[ri].y,
+                width: opts.columnWidth,
+                height: opts.rowHeight,
+                value: raw === undefined ? undefined : String(raw),
+            });
+        }
+    }
+    const width = opts.rowHeaderWidth + rawColumns.length * opts.columnWidth;
+    const height = opts.headerHeight + rawRows.length * opts.rowHeight;
+    return {
+        bounds: { x: 0, y: 0, width, height },
+        rowHeaderWidth: opts.rowHeaderWidth,
+        headerHeight: opts.headerHeight,
+        columns,
+        rows,
+        cells,
+    };
+}

package/dist/blocks/templates/index.d.ts

@@ -0,0 +1,9 @@
+import type { GridRule } from '../validate.js';
+/**
+ * Closed registry of built-in grid templates (§6a): each entry is a template
+ * name (as passed to `--template <name>`) mapped to its `GridRule`s. Adding a
+ * new template means adding one rule module + one entry here — the same
+ * shape as adding a new notation validator, not a plugin/config-loading
+ * mechanism (deliberately out of scope — see the design note on `RACI-001`).
+ */
+export declare const GRID_TEMPLATE_RULES: Record<string, GridRule[]>;

package/dist/blocks/templates/index.js

@@ -0,0 +1,11 @@
+import { RACI_GRID_RULES } from './raci.js';
+/**
+ * Closed registry of built-in grid templates (§6a): each entry is a template
+ * name (as passed to `--template <name>`) mapped to its `GridRule`s. Adding a
+ * new template means adding one rule module + one entry here — the same
+ * shape as adding a new notation validator, not a plugin/config-loading
+ * mechanism (deliberately out of scope — see the design note on `RACI-001`).
+ */
+export const GRID_TEMPLATE_RULES = {
+    raci: RACI_GRID_RULES,
+};

package/dist/blocks/templates/raci.d.ts

@@ -0,0 +1,9 @@
+import type { GridRule } from '../validate.js';
+/**
+ * RACI-as-matrix template (methodology `templates/raci/`), built on the
+ * `blocks` matrix subset (08-blocks.md §4a). The base grid validator does not
+ * fix a cell-value vocabulary, so this invariant — exactly one Accountable
+ * owner per row — lives here, not in `validateGrid` (see §6a).
+ */
+export declare const raciExactlyOneAccountableRule: GridRule;
+export declare const RACI_GRID_RULES: GridRule[];

package/dist/blocks/templates/raci.js

@@ -0,0 +1,24 @@
+/**
+ * RACI-as-matrix template (methodology `templates/raci/`), built on the
+ * `blocks` matrix subset (08-blocks.md §4a). The base grid validator does not
+ * fix a cell-value vocabulary, so this invariant — exactly one Accountable
+ * owner per row — lives here, not in `validateGrid` (see §6a).
+ */
+export const raciExactlyOneAccountableRule = {
+    ruleId: 'RACI-001',
+    severity: 'error',
+    check(grid) {
+        const findings = [];
+        grid.rows.forEach((row, i) => {
+            const accountableCount = Object.values(row.assign ?? {}).filter((v) => v === 'A').length;
+            if (accountableCount !== 1) {
+                findings.push({
+                    message: `Row "${row.name}" (${row.id}) must have exactly one column assigned "A" (Accountable); found ${accountableCount}`,
+                    path: `grid.rows[${i}]`,
+                });
+            }
+        });
+        return findings;
+    },
+};
+export const RACI_GRID_RULES = [raciExactlyOneAccountableRule];

package/dist/blocks/types.d.ts

@@ -18,6 +18,64 @@ export interface BlocksFile {
     spec_version?: string;
     nested_blocks: NestedBlocksHeader;
 }
+export interface GridColumn {
+    id: string;
+    name: string;
+}
+export interface GridRow {
+    id: string;
+    name: string;
+    assign?: Record<string, unknown>;
+}
+export interface GridHeader {
+    columns: GridColumn[];
+    rows: GridRow[];
+}
+export interface GridFile {
+    notation: string;
+    spec_version?: string;
+    grid: GridHeader;
+}
+export interface GridLayoutOptions {
+    /** Width of each data column (px). */
+    columnWidth?: number;
+    /** Height of each data row (px). */
+    rowHeight?: number;
+    /** Width of the row-header column carrying each row's name (px). */
+    rowHeaderWidth?: number;
+    /** Height of the column-header row carrying each column's name (px). */
+    headerHeight?: number;
+}
+export interface LaidOutGridColumn {
+    id: string;
+    name: string;
+    x: number;
+    width: number;
+}
+export interface LaidOutGridRow {
+    id: string;
+    name: string;
+    y: number;
+    height: number;
+}
+export interface LaidOutGridCell {
+    rowId: string;
+    colId: string;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    /** The cell's `assign` value, stringified; omitted (blank) when unassigned. */
+    value?: string;
+}
+export interface GridLayout {
+    bounds: LayoutBounds;
+    rowHeaderWidth: number;
+    headerHeight: number;
+    columns: LaidOutGridColumn[];
+    rows: LaidOutGridRow[];
+    cells: LaidOutGridCell[];
+}
 export interface BlocksLayoutOptions {
     /** Width of a leaf block (a block with no children). */
     leafWidth?: number;

package/dist/blocks/validate.d.ts

@@ -1,7 +1,37 @@
-import type { Block } from './types.js';
+import type { Block, GridHeader } from './types.js';
 import type { ValidationError, ValidationWarning, ValidationResult } from '../validation-types.js';
 export type { ValidationError, ValidationWarning, ValidationResult };
+/**
+ * A template-level check over an already well-formed grid document (matrix
+ * subset, §4a). Templates built on the `grid:` root (e.g. RACI) supply their
+ * own `GridRule`s for vocabulary-specific invariants — the base validator
+ * intentionally does not fix what `assign` values mean (08-blocks.md §6a), so
+ * those invariants never live inside `validateGrid` itself.
+ */
+export interface GridRule {
+    /** Template-namespaced rule code, e.g. "RACI-001" — never a BL-0xx code. */
+    ruleId: string;
+    severity: 'error' | 'warning';
+    check(grid: GridHeader): Array<{
+        message: string;
+        path?: string;
+    }>;
+}
+export interface ValidateGridOptions {
+    /** Extra template-level rules to run once the base grid is well-formed. */
+    rules?: GridRule[];
+}
 export declare function validateNestedBlocks(input: unknown): ValidationResult;
+/** Matrix subset (§4a): validate a `grid:` root document — BL-021..BL-025. */
+export declare function validateGrid(input: unknown, options?: ValidateGridOptions): ValidationResult;
+export interface ValidateBlocksOptions extends ValidateGridOptions {
+}
+/**
+ * Root-form dispatcher (§4/§4a): a document declares exactly one of
+ * `nested_blocks` (tree form) or `grid` (matrix subset) — never both, never
+ * neither (BL-020). Delegates to whichever form is present.
+ */
+export declare function validateBlocks(input: unknown, options?: ValidateBlocksOptions): ValidationResult;
 /**
  * Convenience: validate a single `Block` subtree. Used by tests and by
  * downstream consumers that need to check a sub-document.

package/dist/blocks/validate.js

@@ -163,6 +163,133 @@ export function validateNestedBlocks(input) {
     }
     return { valid: errors.length === 0, errors, warnings };
 }
+/** Matrix subset (§4a): validate a `grid:` root document — BL-021..BL-025. */
+export function validateGrid(input, options = {}) {
+    const errors = [];
+    const warnings = [];
+    if (!input || typeof input !== 'object') {
+        return { valid: false, errors: [{ code: 'BL-001', message: 'Input must be an object' }], warnings };
+    }
+    const raw = input;
+    if ('notation' in raw && raw['notation'] !== 'blocks') {
+        errors.push({
+            code: 'BL-001',
+            message: `notation must be "blocks", got "${String(raw['notation'])}"`,
+        });
+    }
+    if (!('grid' in raw) || !raw['grid'] || typeof raw['grid'] !== 'object') {
+        errors.push({ code: 'BL-020', message: 'Missing required root key: grid' });
+        return { valid: false, errors, warnings };
+    }
+    const grid = raw['grid'];
+    const rawColumns = grid['columns'];
+    const rawRows = grid['rows'];
+    if (!Array.isArray(rawColumns) || rawColumns.length === 0) {
+        errors.push({ code: 'BL-021', message: 'grid.columns must be a non-empty array' });
+    }
+    if (!Array.isArray(rawRows) || rawRows.length === 0) {
+        errors.push({ code: 'BL-022', message: 'grid.rows must be a non-empty array' });
+    }
+    if (errors.length > 0)
+        return { valid: false, errors, warnings };
+    const columnIds = new Set();
+    const columns = [];
+    rawColumns.forEach((entry, i) => {
+        const path = `grid.columns[${i}]`;
+        const c = entry;
+        if (!entry || typeof entry !== 'object' || !isNonEmptyString(c['id']) || !isNonEmptyString(c['name'])) {
+            errors.push({ code: 'BL-023', message: `${path} must have non-empty id and name`, path });
+            return;
+        }
+        const id = c['id'].trim();
+        if (columnIds.has(id)) {
+            errors.push({ code: 'BL-024', message: `Duplicate column id: "${id}"`, path });
+        }
+        else {
+            columnIds.add(id);
+        }
+        columns.push({ id, name: c['name'] });
+    });
+    const rowIds = new Set();
+    const rows = [];
+    rawRows.forEach((entry, i) => {
+        const path = `grid.rows[${i}]`;
+        const r = entry;
+        if (!entry || typeof entry !== 'object' || !isNonEmptyString(r['id']) || !isNonEmptyString(r['name'])) {
+            errors.push({ code: 'BL-023', message: `${path} must have non-empty id and name`, path });
+            return;
+        }
+        const id = r['id'].trim();
+        if (rowIds.has(id)) {
+            errors.push({ code: 'BL-024', message: `Duplicate row id: "${id}"`, path });
+        }
+        else {
+            rowIds.add(id);
+        }
+        const rawAssign = r['assign'];
+        let assign;
+        if (rawAssign !== undefined) {
+            if (!rawAssign || typeof rawAssign !== 'object' || Array.isArray(rawAssign)) {
+                errors.push({ code: 'BL-023', message: `${path}.assign must be a map when present`, path });
+            }
+            else {
+                assign = rawAssign;
+                for (const colId of Object.keys(assign)) {
+                    if (!columnIds.has(colId)) {
+                        errors.push({
+                            code: 'BL-025',
+                            message: `${path}.assign references unknown column id "${colId}"`,
+                            path,
+                        });
+                    }
+                }
+            }
+        }
+        rows.push({ id, name: r['name'], assign });
+    });
+    if (errors.length > 0)
+        return { valid: false, errors, warnings };
+    const grid_ = { columns, rows };
+    for (const rule of options.rules ?? []) {
+        for (const finding of rule.check(grid_)) {
+            const entry = { code: rule.ruleId, message: finding.message, path: finding.path };
+            if (rule.severity === 'error')
+                errors.push(entry);
+            else
+                warnings.push(entry);
+        }
+    }
+    return { valid: errors.length === 0, errors, warnings };
+}
+/**
+ * Root-form dispatcher (§4/§4a): a document declares exactly one of
+ * `nested_blocks` (tree form) or `grid` (matrix subset) — never both, never
+ * neither (BL-020). Delegates to whichever form is present.
+ */
+export function validateBlocks(input, options = {}) {
+    if (!input || typeof input !== 'object') {
+        return { valid: false, errors: [{ code: 'BL-001', message: 'Input must be an object' }], warnings: [] };
+    }
+    const raw = input;
+    const hasNested = raw['nested_blocks'] !== undefined && raw['nested_blocks'] !== null;
+    const hasGrid = raw['grid'] !== undefined && raw['grid'] !== null;
+    if (hasNested && hasGrid) {
+        return {
+            valid: false,
+            errors: [{ code: 'BL-020', message: 'Document root must declare exactly one of nested_blocks or grid, not both' }],
+            warnings: [],
+        };
+    }
+    if (hasGrid)
+        return validateGrid(input, options);
+    if (hasNested)
+        return validateNestedBlocks(input);
+    return {
+        valid: false,
+        errors: [{ code: 'BL-020', message: 'Document root must declare exactly one of nested_blocks or grid' }],
+        warnings: [],
+    };
+}
 /**
  * Convenience: validate a single `Block` subtree. Used by tests and by
  * downstream consumers that need to check a sub-document.

package/dist/capability-map/validate.js

@@ -13,11 +13,18 @@ export function validateCapabilityMap(input) {
         return { valid: false, errors: [{ code: 'CMAP-001', message: 'Input must be an object' }], warnings };
     }
     const raw = input;
+    // HDR-001/002 — DSM's own rule codes for the same header check CMAP-001
+    // already makes (api02/internal/importer/capabilities.go ValidateCapMap),
+    // added alongside it (not instead of it) so DSM can map a finding straight
+    // back onto its own import-log taxonomy while CMAP-001 stays the richer,
+    // pre-existing Studio-native code for this notation's own validator.
     if (!('notation' in raw)) {
         errors.push({ code: 'CMAP-001', message: 'Missing required field: notation' });
+        errors.push({ code: 'HDR-001', message: 'notation field is missing' });
     }
     else if (raw['notation'] !== 'capability-map') {
         errors.push({ code: 'CMAP-001', message: `notation must be "capability-map", got "${raw['notation']}"` });
+        errors.push({ code: 'HDR-002', message: `notation must be "capability-map", got "${raw['notation']}"` });
     }
     if (errors.length > 0)
         return { valid: false, errors, warnings };
@@ -91,6 +98,40 @@ function validateCapabilityTree(nodes, pathPrefix, errors, seenIds) {
         }
         if (node['applications'] !== undefined && !Array.isArray(node['applications']))
             errors.push({ code: 'CMAP-003', message: `${nodePath}: applications must be an array` });
+        // LIFECYCLE-001/004 — DSM's own rule codes (capabilities.go
+        // ValidateCapMap/validateCapMapNodes) for `valid_from`/`valid_to`, the
+        // CONTRACT.md §7 primitive-lifecycle fields. Net new: this notation's own
+        // validator has no equivalent check today — `CapabilityNode` (types.ts)
+        // does not even declare these fields, since Studio's own schema tracks
+        // lifecycle via `target_date` instead. The fields are still read directly
+        // off the raw untyped node here because real capability-map documents
+        // (e.g. organizations/acme_corp) author them inline per §7 regardless.
+        {
+            const id = typeof node['id'] === 'string' ? node['id'] : nodePath;
+            const validFrom = node['valid_from'];
+            const validTo = node['valid_to'];
+            let fromDate;
+            let toDate;
+            if (validFrom !== undefined && validFrom !== null) {
+                if (typeof validFrom !== 'string' || !DATE_RE.test(validFrom)) {
+                    errors.push({ code: 'LIFECYCLE-001', message: `capability ${id} valid_from "${String(validFrom)}" is not a valid YYYY-MM-DD date (must be quoted)` });
+                }
+                else {
+                    fromDate = validFrom;
+                }
+            }
+            if (validTo !== undefined && validTo !== null) {
+                if (typeof validTo !== 'string' || !DATE_RE.test(validTo)) {
+                    errors.push({ code: 'LIFECYCLE-001', message: `capability ${id} valid_to "${String(validTo)}" is not a valid YYYY-MM-DD date (must be quoted)` });
+                }
+                else {
+                    toDate = validTo;
+                }
+            }
+            if (fromDate && toDate && toDate < fromDate) {
+                errors.push({ code: 'LIFECYCLE-004', message: `capability ${id} valid_to ${toDate} is before valid_from ${fromDate}` });
+            }
+        }
         if (node['children'] !== undefined) {
             if (!Array.isArray(node['children'])) {
                 errors.push({ code: 'CMAP-003', message: `${nodePath}: children must be an array` });

package/dist/edge-path.d.ts

@@ -20,3 +20,18 @@ export declare const DEFAULT_EDGE_CURVATURE = 1;
  *   - >1  → progressively stronger arc at that end.
  */
 export declare function horizontalCubicEdgePath(sx: number, sy: number, tx: number, ty: number, curvature?: number, entryCurvature?: number): string;
+/**
+ * Builds the SVG `d` for a "skip" edge that must arc over an intermediate
+ * node sitting on the direct (sx,sy)→(tx,ty) line — e.g. a Network/PSND view
+ * where a multi-predecessor activity's nearer predecessor shares a row with
+ * one of the columns in between, so the direct line would be drawn straight
+ * through that node. Both control points target `bowY` instead of each
+ * endpoint's own Y, producing a hump that departs/arrives at an angle rather
+ * than the flat horizontal tangent of `horizontalCubicEdgePath`.
+ *
+ * A cubic's actual apex only reaches part-way from an endpoint Y to the
+ * control-point Y (75% at the midpoint for a fully symmetric sy=ty curve),
+ * so callers must pick `bowY` well past the obstacle for the apex to clear
+ * it — see `render-activities.ts`'s `blockingNodes`/`bowY` for the margin.
+ */
+export declare function bowedCubicEdgePath(sx: number, sy: number, tx: number, ty: number, bowY: number, curvature?: number): string;

package/dist/edge-path.js

@@ -47,3 +47,22 @@ export function horizontalCubicEdgePath(sx, sy, tx, ty, curvature = DEFAULT_EDGE
     const entryHandle = baseHandle * (entryCurvature ?? curvature);
     return `M${sx},${sy} C${sx + exitHandle},${sy} ${tx - entryHandle},${ty} ${tx},${ty}`;
 }
+/**
+ * Builds the SVG `d` for a "skip" edge that must arc over an intermediate
+ * node sitting on the direct (sx,sy)→(tx,ty) line — e.g. a Network/PSND view
+ * where a multi-predecessor activity's nearer predecessor shares a row with
+ * one of the columns in between, so the direct line would be drawn straight
+ * through that node. Both control points target `bowY` instead of each
+ * endpoint's own Y, producing a hump that departs/arrives at an angle rather
+ * than the flat horizontal tangent of `horizontalCubicEdgePath`.
+ *
+ * A cubic's actual apex only reaches part-way from an endpoint Y to the
+ * control-point Y (75% at the midpoint for a fully symmetric sy=ty curve),
+ * so callers must pick `bowY` well past the obstacle for the apex to clear
+ * it — see `render-activities.ts`'s `blockingNodes`/`bowY` for the margin.
+ */
+export function bowedCubicEdgePath(sx, sy, tx, ty, bowY, curvature = DEFAULT_EDGE_CURVATURE) {
+    const dx = tx - sx;
+    const handle = Math.max(EDGE_MIN_HANDLE, Math.min(Math.abs(dx) * DX_FACTOR, MAX_HANDLE)) * curvature;
+    return `M${sx},${sy} C${sx + handle},${bowY} ${tx - handle},${bowY} ${tx},${ty}`;
+}

package/dist/fgca/parse-canonical.js

@@ -104,6 +104,14 @@ export function parseCanonicalFGCA(input) {
     }
     const activitiesRaw = asObjectArray(raw['actions']);
     if (activitiesRaw === null && 'activities' in raw) {
+        // DSM's Go ValidateFGCA (fgca.go) still accepts this as the deprecated
+        // "activities" key and promotes it with a DGCA-DEPR warning, not an
+        // error. Deliberately NOT matched here — PR #320 ("drop deprecated
+        // notation aliases fgca/fga/activities/activity-card") already removed
+        // that leniency from this validator on purpose. Re-introducing
+        // DGCA-DEPR would reverse a deliberate, shipped decision, not fill a
+        // gap; see docs/validation.md's "Standalone-element envelope rules"
+        // section for the full note.
         errors.push({ code: 'FGCA-004', message: '"activities" key is not accepted — rename to "actions"', path: 'actions' });
     }
     if (factorsRaw === null)

package/dist/repo-validate/check-element-hygiene.d.ts

@@ -0,0 +1,8 @@
+import type { RepoFinding, RepoModelInput } from './types.js';
+/**
+ * Run the standalone-element envelope checks (GOAL-ELEM-001..003,
+ * ACTION-001/002/005) over the loaded element set and append findings.
+ * Called from `validateRepoModel` alongside `checkStrategyChainSemantics`.
+ * Pure, deterministic order.
+ */
+export declare function checkElementHygiene(input: RepoModelInput, findings: RepoFinding[]): void;