@transitrix/diagrams 1.6.0 → 1.8.1

package/dist/compliance/canon-catalog.js

@@ -0,0 +1,59 @@
+// CanonCatalog builder — repo-scope cross-reference resolution (#518 Phase C3).
+//
+// Scans admitted YAML documents and builds the `{ typeOf }` catalogue that
+// `validateRequirement` / `validateAssertion` accept for REQ-002 and
+// ASSERT-002..005 resolution.
+import { typeOfId } from '../typed-id.js';
+import { emptyCanon, ingestComplianceDoc } from './classify.js';
+function strId(doc) {
+    if (doc === null || typeof doc !== 'object' || Array.isArray(doc))
+        return undefined;
+    const id = doc.id;
+    return typeof id === 'string' && id.trim() !== '' ? id.trim() : undefined;
+}
+/** Admit one parsed document into the id → TYPE map. */
+export function admitDocumentToCatalog(map, doc) {
+    const id = strId(doc);
+    if (!id)
+        return undefined;
+    const fromPrefix = typeOfId(id);
+    if (fromPrefix) {
+        map.set(id, fromPrefix);
+        return id;
+    }
+    if (doc !== null && typeof doc === 'object' && !Array.isArray(doc)) {
+        const d = doc;
+        if (d.zone === 'codex') {
+            const explicit = typeof d.type === 'string' ? d.type.trim().toUpperCase() : undefined;
+            if (explicit) {
+                map.set(id, explicit);
+                return id;
+            }
+        }
+    }
+    return undefined;
+}
+/** Build a read-only `CanonCatalog` from a populated id → TYPE map. */
+export function catalogFromMap(map) {
+    return { typeOf: (id) => map.get(id) };
+}
+/** Ingest compliance projections and admit cross-reference targets from a batch
+ *  of already-parsed YAML documents (no IO). */
+export function buildComplianceScan(docs) {
+    const complianceCanon = emptyCanon();
+    const catalogMap = new Map();
+    const pathById = new Map();
+    for (const { path, data } of docs) {
+        const ingested = ingestComplianceDoc(complianceCanon, data);
+        if (ingested)
+            pathById.set(ingested, path);
+        const admitted = admitDocumentToCatalog(catalogMap, data);
+        if (admitted && !pathById.has(admitted))
+            pathById.set(admitted, path);
+    }
+    return {
+        complianceCanon,
+        catalog: catalogFromMap(catalogMap),
+        pathById,
+    };
+}

package/dist/compliance/coverage-metric.d.ts

@@ -1,4 +1,5 @@
 import type { ComplianceCanon } from './classify.js';
+import type { CanonCatalog } from '../typed-id.js';
 /** Declarative filter resolved at build time from the canon's codex catalogue. */
 export interface CoverageMetricRegimesFilter {
     jurisdiction?: string[];
@@ -73,6 +74,17 @@ export interface CoverageMatrix {
     rows: CoverageRow[];
     thresholds: CoverageMetricThresholds;
 }
+/** Repo-scope cross-reference finding for a coverage-metric view (#518 C3). */
+export interface CoverageViewFinding {
+    code: string;
+    severity: 'error' | 'warning';
+    message: string;
+}
+/**
+ * Repo-scope cross-reference checks for a parsed coverage-metric view config.
+ * Surfaces unresolved product and regime ids before `buildCoverageMatrix` runs.
+ */
+export declare function collectCoverageViewResolutionFindings(config: CoverageMetricConfig, catalog: CanonCatalog, complianceCanon: ComplianceCanon): CoverageViewFinding[];
 /**
  * Parse and validate a raw (YAML-parsed) document into a `CoverageMetricConfig`.
  *

package/dist/compliance/coverage-metric.js

@@ -5,6 +5,41 @@
 // across the scoped products, and what is the RAG status against the configured
 // thresholds.
 import { buildComplianceIndex } from './reverse-index.js';
+/**
+ * Repo-scope cross-reference checks for a parsed coverage-metric view config.
+ * Surfaces unresolved product and regime ids before `buildCoverageMatrix` runs.
+ */
+export function collectCoverageViewResolutionFindings(config, catalog, complianceCanon) {
+    const findings = [];
+    const codexIds = new Set(complianceCanon.codex.map((c) => c.id));
+    for (const id of config.subjects?.products ?? []) {
+        const t = catalog.typeOf(id);
+        if (t === undefined) {
+            findings.push({
+                code: 'COVMET-REF',
+                severity: 'error',
+                message: `subjects.products: "${id}" does not resolve to an admitted artefact.`,
+            });
+        }
+        else if (t !== 'PRODUCT') {
+            findings.push({
+                code: 'COVMET-REF',
+                severity: 'error',
+                message: `subjects.products: "${id}" resolves to ${t}, not PRODUCT.`,
+            });
+        }
+    }
+    for (const id of config.regimes?.include ?? []) {
+        if (!codexIds.has(id)) {
+            findings.push({
+                code: 'COVMET-REF',
+                severity: 'error',
+                message: `regimes.include: "${id}" does not resolve to an admitted codex artefact.`,
+            });
+        }
+    }
+    return findings;
+}
 // ── Parser ───────────────────────────────────────────────────────────────────
 function parseRegimes(raw) {
     const warnings = [];

package/dist/compliance/impact.d.ts

@@ -1,5 +1,6 @@
 import type { AssertionStatus } from '../assertion/types.js';
 import type { ComplianceCanon } from './classify.js';
+import type { CanonCatalog } from '../typed-id.js';
 import type { IndexAssertion, IndexRequirement, ObjectDetailInput, DeadlineStatus } from './types.js';
 /** Filter selecting REQUIREMENTs by codex source (jurisdiction / regime keys
  *  are accepted for forward compatibility but not yet honoured — the canon
@@ -57,12 +58,17 @@ export interface ImpactColumn {
      *  Used to enforce the subject type label invariant (§5.2, COMPIMP-010). */
     subjectType: 'product' | 'process' | 'capability';
 }
-/** A structural validation finding emitted by the matrix builder. */
 export interface ImpactFinding {
     code: string;
     severity: 'error' | 'warning';
     message: string;
 }
+/**
+ * Repo-scope cross-reference checks for a parsed compliance-impact view config
+ * (#518 Phase C3). Surfaces unresolved subject, obligation, and regime ids before
+ * `buildImpactMatrix` runs.
+ */
+export declare function collectImpactViewResolutionFindings(config: ImpactViewConfig, catalog: CanonCatalog, complianceCanon: ComplianceCanon): ImpactFinding[];
 /**
  * Grouping options for matrix columns.
  *

package/dist/compliance/impact.js

@@ -7,6 +7,59 @@
 // (`product` columns × `obligation` rows). Stage / task grouping is planned
 // for CV-3a and intentionally out of scope here.
 import { buildComplianceIndex } from './reverse-index.js';
+/**
+ * Repo-scope cross-reference checks for a parsed compliance-impact view config
+ * (#518 Phase C3). Surfaces unresolved subject, obligation, and regime ids before
+ * `buildImpactMatrix` runs.
+ */
+export function collectImpactViewResolutionFindings(config, catalog, complianceCanon) {
+    const findings = [];
+    const codexIds = new Set(complianceCanon.codex.map((c) => c.id));
+    const subjectChecks = [
+        { ids: config.subjects.products, expectedType: 'PRODUCT', path: 'subjects.products' },
+        { ids: config.subjects.processes, expectedType: 'PROCESS', path: 'subjects.processes' },
+        { ids: config.subjects.capabilities, expectedType: 'CAPABILITY', path: 'subjects.capabilities' },
+    ];
+    for (const { ids, expectedType, path } of subjectChecks) {
+        for (const id of ids ?? []) {
+            const t = catalog.typeOf(id);
+            if (t === undefined) {
+                findings.push({
+                    code: 'COMPIMP-REF',
+                    severity: 'error',
+                    message: `${path}: "${id}" does not resolve to an admitted artefact.`,
+                });
+            }
+            else if (t !== expectedType) {
+                findings.push({
+                    code: 'COMPIMP-REF',
+                    severity: 'error',
+                    message: `${path}: "${id}" resolves to ${t}, not ${expectedType}.`,
+                });
+            }
+        }
+    }
+    for (const id of config.obligations.include ?? []) {
+        const t = catalog.typeOf(id);
+        if (t === undefined || t !== 'REQUIREMENT') {
+            findings.push({
+                code: 'COMPIMP-REF',
+                severity: 'error',
+                message: `obligations.include: "${id}" does not resolve to an admitted REQUIREMENT.`,
+            });
+        }
+    }
+    for (const id of config.obligations.filter?.derived_from_codex ?? []) {
+        if (!codexIds.has(id)) {
+            findings.push({
+                code: 'COMPIMP-REF',
+                severity: 'error',
+                message: `obligations.filter.derived_from_codex: "${id}" does not resolve to an admitted codex artefact.`,
+            });
+        }
+    }
+    return findings;
+}
 // ── Pinned defaults ─────────────────────────────────────────────────────────
 /**
  * Explicit defaults for every optional field in ImpactViewConfig.

package/dist/compliance/index.d.ts

@@ -5,13 +5,15 @@ export { buildGapReport } from './gap-report.js';
 export type { GapReport, GapReportOptions } from './gap-report.js';
 export { emptyCanon, ingestComplianceDoc } from './classify.js';
 export type { ComplianceCanon, ComplianceProduct, ComplianceCodexDoc } from './classify.js';
+export { admitDocumentToCatalog, buildComplianceScan, catalogFromMap, } from './canon-catalog.js';
+export type { ComplianceScanResult, ScannedYamlDoc } from './canon-catalog.js';
 export { renderComplianceMarkdown } from './markdown.js';
 export type { ReportScope, MarkdownOptions } from './markdown.js';
 export { renderComplianceHtml, renderImpactMatrixHtml } from './html.js';
 export type { HtmlOptions, ImpactMatrixHtmlOptions } from './html.js';
-export { buildImpactMatrix, renderImpactMarkdown, parseImpactViewConfig, COMPLIANCE_IMPACT_DEFAULTS, extractObjectDetails, extractProcessFlowTasks, mergeStageTaskDetails, computeDeadlineStatus } from './impact.js';
-export type { ImpactCell, ImpactColumn, ImpactEmptyCellLabels, ImpactGrouping, ImpactMatrix, ImpactObligationFilter, ImpactStatusDisplay, ImpactSubjects, ImpactViewConfig, ParseImpactViewConfigResult, } from './impact.js';
+export { buildImpactMatrix, renderImpactMarkdown, parseImpactViewConfig, collectImpactViewResolutionFindings, COMPLIANCE_IMPACT_DEFAULTS, extractObjectDetails, extractProcessFlowTasks, mergeStageTaskDetails, computeDeadlineStatus } from './impact.js';
+export type { ImpactCell, ImpactColumn, ImpactEmptyCellLabels, ImpactFinding, ImpactGrouping, ImpactMatrix, ImpactObligationFilter, ImpactStatusDisplay, ImpactSubjects, ImpactViewConfig, ParseImpactViewConfigResult, } from './impact.js';
 export { assertionToScoringElement, complianceConfidenceHeader, requirementToScoringElement, scoreComplianceView, } from './confidence.js';
-export { parseCoverageMetricConfig, buildCoverageMatrix, } from './coverage-metric.js';
-export type { CoverageMetricConfig, CoverageMetricRegimes, CoverageMetricRegimesFilter, CoverageMetricSubjects, CoverageMetricThresholds, CoverageMatrix, CoverageRow, ParseCoverageMetricResult, RagStatus, } from './coverage-metric.js';
+export { parseCoverageMetricConfig, buildCoverageMatrix, collectCoverageViewResolutionFindings, } from './coverage-metric.js';
+export type { CoverageMetricConfig, CoverageMetricRegimes, CoverageMetricRegimesFilter, CoverageMetricSubjects, CoverageMetricThresholds, CoverageMatrix, CoverageRow, CoverageViewFinding, ParseCoverageMetricResult, RagStatus, } from './coverage-metric.js';
 export type { ComplianceIndex, ComplianceIndexInput, DeadlineStatus, IndexRequirement, IndexAssertion, LawTree, LawTreeRequirement, ProductView, ProductRequirementStatus, ObjectDetailDef, ObjectDetailInput, RequirementTrace, TraceAssertionRow, TraceElementCatalog, TraceElementRef, TraceSourceRef, } from './types.js';

package/dist/compliance/index.js

@@ -3,8 +3,9 @@ export { buildLawTree, buildProductView } from './views.js';
 export { buildRequirementTrace, buildTraceElementCatalog } from './trace.js';
 export { buildGapReport } from './gap-report.js';
 export { emptyCanon, ingestComplianceDoc } from './classify.js';
+export { admitDocumentToCatalog, buildComplianceScan, catalogFromMap, } from './canon-catalog.js';
 export { renderComplianceMarkdown } from './markdown.js';
 export { renderComplianceHtml, renderImpactMatrixHtml } from './html.js';
-export { buildImpactMatrix, renderImpactMarkdown, parseImpactViewConfig, COMPLIANCE_IMPACT_DEFAULTS, extractObjectDetails, extractProcessFlowTasks, mergeStageTaskDetails, computeDeadlineStatus } from './impact.js';
+export { buildImpactMatrix, renderImpactMarkdown, parseImpactViewConfig, collectImpactViewResolutionFindings, COMPLIANCE_IMPACT_DEFAULTS, extractObjectDetails, extractProcessFlowTasks, mergeStageTaskDetails, computeDeadlineStatus } from './impact.js';
 export { assertionToScoringElement, complianceConfidenceHeader, requirementToScoringElement, scoreComplianceView, } from './confidence.js';
-export { parseCoverageMetricConfig, buildCoverageMatrix, } from './coverage-metric.js';
+export { parseCoverageMetricConfig, buildCoverageMatrix, collectCoverageViewResolutionFindings, } from './coverage-metric.js';

package/dist/constraint/__tests__/example.test.d.ts

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

package/dist/constraint/__tests__/example.test.js

@@ -0,0 +1,14 @@
+import { describe, it, expect } from 'vitest';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import path from 'node:path';
+import yaml from 'js-yaml';
+import { validateConstraint } from '../validate.js';
+const dir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../../../../tests/fixtures/notation-corpus/constraint');
+describe('constraint worked example (notation-corpus)', () => {
+    it('validates CONSTRAINT-GDPR-RESIDENCY-1.yaml without error', () => {
+        const data = yaml.load(readFileSync(path.join(dir, 'CONSTRAINT-GDPR-RESIDENCY-1.yaml'), 'utf-8'));
+        const v = validateConstraint(data);
+        expect(v.valid, JSON.stringify(v.errors)).toBe(true);
+    });
+});

package/dist/constraint/__tests__/validate.test.d.ts

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

package/dist/constraint/__tests__/validate.test.js

@@ -0,0 +1,58 @@
+import { describe, it, expect } from 'vitest';
+import { validateConstraint } from '../validate.js';
+function valid() {
+    return {
+        notation: 'constraint',
+        id: 'CONSTRAINT-GDPR-RESIDENCY-1',
+        name: 'EU customer personal data must be stored within EU/EEA jurisdictions',
+        statement: 'Personal data of EU customers MUST NOT be persisted outside EU / EEA jurisdictions.',
+        status: 'active',
+        zone: 'canon',
+        admitted_at: '2026-05-29',
+        admitted_by: 'v.korobeinikov',
+        gate_checks: { uniqueness: 'pass', consistency: 'pass', completeness: 'pass' },
+        valid_from: '2018-05-25',
+        valid_to: null,
+        severity: 'mandatory',
+        owner_role: 'ROLE-DPO-1',
+        applies_to: ['APPLICATION-CRM-1'],
+    };
+}
+const codes = (input, opts) => validateConstraint(input, opts).errors.map((e) => e.code);
+describe('validateConstraint — positive', () => {
+    it('accepts a well-formed constraint', () => {
+        const r = validateConstraint(valid());
+        expect(r.valid, JSON.stringify(r.errors)).toBe(true);
+    });
+});
+describe('validateConstraint — CONST-001', () => {
+    it('flags missing required fields and wrong notation', () => {
+        const r = valid();
+        delete r.statement;
+        expect(codes(r)).toContain('CONST-001');
+        expect(codes({ ...valid(), notation: 'requirement' })).toContain('CONST-001');
+        expect(codes({ ...valid(), id: 'CONSTRAINT-001' })).toContain('CONST-001');
+    });
+});
+describe('validateConstraint — CONST-002/003', () => {
+    it('flags invalid status and severity', () => {
+        expect(codes({ ...valid(), status: 'enabled' })).toContain('CONST-002');
+        expect(codes({ ...valid(), severity: 'critical' })).toContain('CONST-003');
+    });
+});
+describe('validateConstraint — CONST-004/005 (catalog)', () => {
+    it('flags unresolved applies_to and owner_role with catalog', () => {
+        const catalog = { typeOf: () => undefined };
+        expect(codes(valid(), { catalog })).toContain('CONST-004');
+        expect(codes(valid(), { catalog })).toContain('CONST-005');
+    });
+    it('does not flag CONST-004 without catalog for well-formed applies_to', () => {
+        expect(codes(valid())).not.toContain('CONST-004');
+    });
+    it('resolves applies_to when catalogue admits the target', () => {
+        const catalog = {
+            typeOf: (id) => (id === 'APPLICATION-CRM-1' ? 'APPLICATION' : id === 'ROLE-DPO-1' ? 'ROLE' : undefined),
+        };
+        expect(validateConstraint(valid(), { catalog }).valid).toBe(true);
+    });
+});

package/dist/constraint/index.d.ts

@@ -0,0 +1,4 @@
+export { CONSTRAINT_STATUSES, CONSTRAINT_SEVERITIES } from './types.js';
+export type { ConstraintStatus, ConstraintSeverity } from './types.js';
+export { validateConstraint } from './validate.js';
+export type { ConstraintValidateOptions } from './validate.js';

package/dist/constraint/index.js

@@ -0,0 +1,2 @@
+export { CONSTRAINT_STATUSES, CONSTRAINT_SEVERITIES } from './types.js';
+export { validateConstraint } from './validate.js';

package/dist/constraint/types.d.ts

@@ -0,0 +1,4 @@
+export declare const CONSTRAINT_STATUSES: readonly ["active", "proposed", "deprecated", "retired"];
+export type ConstraintStatus = (typeof CONSTRAINT_STATUSES)[number];
+export declare const CONSTRAINT_SEVERITIES: readonly ["mandatory", "recommended", "advisory"];
+export type ConstraintSeverity = (typeof CONSTRAINT_SEVERITIES)[number];

package/dist/constraint/types.js

@@ -0,0 +1,2 @@
+export const CONSTRAINT_STATUSES = ['active', 'proposed', 'deprecated', 'retired'];
+export const CONSTRAINT_SEVERITIES = ['mandatory', 'recommended', 'advisory'];

package/dist/constraint/validate.d.ts

@@ -0,0 +1,7 @@
+import type { ValidationResult } from '../validation-types.js';
+import { type CanonCatalog } from '../typed-id.js';
+export interface ConstraintValidateOptions {
+    /** When provided, CONST-004/005 enforce artefact existence for cross-refs. */
+    catalog?: CanonCatalog;
+}
+export declare function validateConstraint(input: unknown, options?: ConstraintValidateOptions): ValidationResult;

package/dist/constraint/validate.js

@@ -0,0 +1,115 @@
+// CONSTRAINT validator — methodology ELEMENT_PRIMITIVES.md §7.13 (sibling to
+// 15-requirement.md). Implements CONST-001..005 for the compliance suite (#518 C4).
+import { typeOfId, isCanonicalIdOfType } from '../typed-id.js';
+import { CONSTRAINT_STATUSES, CONSTRAINT_SEVERITIES } from './types.js';
+const REQUIRED_FIELDS = [
+    'notation',
+    'name',
+    'statement',
+    'status',
+    'zone',
+    'admitted_at',
+    'admitted_by',
+    'gate_checks',
+    'valid_from',
+];
+export function validateConstraint(input, options = {}) {
+    const errors = [];
+    const warnings = [];
+    if (input === null || typeof input !== 'object' || Array.isArray(input)) {
+        errors.push({ code: 'CONST-001', message: 'Constraint must be a YAML mapping.' });
+        return { valid: false, errors, warnings };
+    }
+    const c = input;
+    if (!isCanonicalIdOfType(c.id, 'CONSTRAINT')) {
+        errors.push({
+            code: 'CONST-001',
+            message: `id "${String(c.id)}" must match CONSTRAINT-[<middle>-]<INTEGER>.`,
+            path: 'id',
+        });
+    }
+    if (c.notation !== 'constraint') {
+        errors.push({ code: 'CONST-001', message: 'notation must be the fixed value "constraint".', path: 'notation' });
+    }
+    for (const f of REQUIRED_FIELDS) {
+        if (f === 'notation')
+            continue;
+        if (f === 'gate_checks') {
+            if (c.gate_checks === null || typeof c.gate_checks !== 'object') {
+                errors.push({ code: 'CONST-001', message: 'gate_checks is required and must be a mapping.', path: 'gate_checks' });
+            }
+            continue;
+        }
+        const v = c[f];
+        if (typeof v !== 'string' || v.trim() === '') {
+            errors.push({ code: 'CONST-001', message: `${f} is required.`, path: f });
+        }
+    }
+    if (c.zone !== 'canon') {
+        errors.push({ code: 'CONST-001', message: 'zone must be "canon" for a CONSTRAINT.', path: 'zone' });
+    }
+    if (!('valid_to' in c) || !(typeof c.valid_to === 'string' || c.valid_to === null)) {
+        errors.push({ code: 'CONST-001', message: 'valid_to is required (an ISO date string or null).', path: 'valid_to' });
+    }
+    const status = typeof c.status === 'string' ? c.status.trim() : '';
+    if (status && !CONSTRAINT_STATUSES.includes(status)) {
+        errors.push({
+            code: 'CONST-002',
+            message: `status must be one of ${CONSTRAINT_STATUSES.join(', ')}.`,
+            path: 'status',
+        });
+    }
+    if (c.severity !== undefined) {
+        const severity = typeof c.severity === 'string' ? c.severity.trim() : '';
+        if (!severity || !CONSTRAINT_SEVERITIES.includes(severity)) {
+            errors.push({
+                code: 'CONST-003',
+                message: `severity must be one of ${CONSTRAINT_SEVERITIES.join(', ')}.`,
+                path: 'severity',
+            });
+        }
+    }
+    if (c.applies_to !== undefined) {
+        if (!Array.isArray(c.applies_to)) {
+            errors.push({ code: 'CONST-001', message: 'applies_to must be a list of typed IDs.', path: 'applies_to' });
+        }
+        else {
+            c.applies_to.forEach((ref, i) => {
+                const type = typeOfId(ref);
+                if (!type) {
+                    errors.push({
+                        code: 'CONST-004',
+                        message: `applies_to[${i}] "${String(ref)}" is not a resolvable typed ID.`,
+                        path: `applies_to[${i}]`,
+                    });
+                    return;
+                }
+                if (options.catalog && options.catalog.typeOf(ref) === undefined) {
+                    errors.push({
+                        code: 'CONST-004',
+                        message: `applies_to[${i}] "${String(ref)}" does not resolve to an admitted artefact.`,
+                        path: `applies_to[${i}]`,
+                    });
+                }
+            });
+        }
+    }
+    if (c.owner_role !== undefined) {
+        const role = c.owner_role;
+        if (typeof role !== 'string' || !isCanonicalIdOfType(role, 'ROLE')) {
+            errors.push({
+                code: 'CONST-005',
+                message: `owner_role "${String(role)}" must be a typed ROLE id.`,
+                path: 'owner_role',
+            });
+        }
+        else if (options.catalog && options.catalog.typeOf(role) === undefined) {
+            errors.push({
+                code: 'CONST-005',
+                message: `owner_role "${role}" does not resolve to an admitted artefact.`,
+                path: 'owner_role',
+            });
+        }
+    }
+    return { valid: errors.length === 0, errors, warnings };
+}

package/dist/fgca/__tests__/parse-canonical.test.js

@@ -32,6 +32,29 @@ describe('parseCanonicalFGCA', () => {
         expect(r.parsed?.changes).toHaveLength(1);
         expect(r.parsed?.activities).toHaveLength(1);
     });
+    it('accepts ACTION-* ids (methodology 1.0) alongside legacy ACTIVITY-*', () => {
+        const r = parseCanonicalFGCA({
+            ...VALID,
+            actions: [
+                { id: 'ACTION-CRM-EU-1', name: 'CRM rollout', changes: ['CHANGE-1'] },
+                { id: 'ACTIVITY-2', name: 'Legacy workstream', changes: ['CHANGE-1'] },
+            ],
+        });
+        expect(r.valid, JSON.stringify(r.errors)).toBe(true);
+        expect(r.parsed?.activities.map((a) => a.id)).toEqual(['ACTION-CRM-EU-1', 'ACTIVITY-2']);
+    });
+    it('defaults changes to [] when view_config.layers.changes is off (DGA-in-dgca)', () => {
+        const r = parseCanonicalFGCA({
+            ...VALID,
+            changes: undefined,
+            view_config: { layers: { changes: 'off' } },
+            actions: [
+                { id: 'ACTION-DISCOVERY-1', name: 'Gap assessment', goals: ['GOAL-1'] },
+            ],
+        });
+        expect(r.valid, JSON.stringify(r.errors)).toBe(true);
+        expect(r.parsed?.changes).toEqual([]);
+    });
     it('FGCA-001: rejects non-object input', () => {
         expect(parseCanonicalFGCA(null).errors[0].code).toBe('FGCA-001');
         expect(parseCanonicalFGCA('string').errors[0].code).toBe('FGCA-001');
@@ -178,6 +201,14 @@ describe('parseCanonicalFGA', () => {
         expect(r.parsed?.goals).toHaveLength(1);
         expect(r.parsed?.activities).toHaveLength(1);
     });
+    it('accepts ACTION-* ids in FGA mode', () => {
+        const r = parseCanonicalFGA({
+            ...VALID_FGA,
+            actions: [{ id: 'ACTION-GDPR-DSR-WORKFLOW-1', name: 'DSR workflow', goals: ['GOAL-1'] }],
+        });
+        expect(r.valid, JSON.stringify(r.errors)).toBe(true);
+        expect(r.parsed?.activities[0].id).toBe('ACTION-GDPR-DSR-WORKFLOW-1');
+    });
     it('populates activity.goal_id from activity.goals[] (the FGA edge-driving field)', () => {
         // The "FGA nodes render, no edges" bug: activities had no resolvable
         // goal_id, so the renderer drew no goal → activity edges.

package/dist/fgca/parse-canonical.d.ts

@@ -6,7 +6,7 @@
  *
  * - Flat top-level arrays, no `fgca:` wrapper.
  * - Typed string IDs per `IDS_AND_REFERENCES.md` (`FACTOR-1`,
- *   `GOAL-RET-1`, `CHANGE-1`, `ACTIVITY-ONBOARD-1`).
+ *   `GOAL-RET-1`, `CHANGE-1`, `ACTION-ONBOARD-1` (legacy `ACTIVITY-*` accepted).
  * - Plural canonical-direction cross-references: `goal.factors`,
  *   `change.goals`, `activity.changes`, `activity.goals`.
  * - Per-notation validation codes `FGCA-001 … FGCA-015`.

package/dist/fgca/parse-canonical.js

@@ -6,7 +6,7 @@
  *
  * - Flat top-level arrays, no `fgca:` wrapper.
  * - Typed string IDs per `IDS_AND_REFERENCES.md` (`FACTOR-1`,
- *   `GOAL-RET-1`, `CHANGE-1`, `ACTIVITY-ONBOARD-1`).
+ *   `GOAL-RET-1`, `CHANGE-1`, `ACTION-ONBOARD-1` (legacy `ACTIVITY-*` accepted).
  * - Plural canonical-direction cross-references: `goal.factors`,
  *   `change.goals`, `activity.changes`, `activity.goals`.
  * - Per-notation validation codes `FGCA-001 … FGCA-015`.
@@ -31,7 +31,8 @@ const DRIVER_ID_RE = /^DRIVER(-[A-Z0-9][A-Z0-9_]*)*-\d+$/;
 const FACTOR_OR_DRIVER_ID_RE = /^(FACTOR|DRIVER)(-[A-Z0-9][A-Z0-9_]*)*-\d+$/;
 const GOAL_ID_RE = /^GOAL(-[A-Z0-9][A-Z0-9_]*)*-\d+$/;
 const CHANGE_ID_RE = /^CHANGE(-[A-Z0-9][A-Z0-9_]*)*-\d+$/;
-const ACTIVITY_ID_RE = /^ACTIVITY(-[A-Z0-9][A-Z0-9_]*)*-\d+$/;
+// ACTION is canonical since methodology 1.0; ACTIVITY accepted for legacy docs.
+const ACTION_OR_ACTIVITY_ID_RE = /^(ACTION|ACTIVITY)(-[A-Z0-9][A-Z0-9_]*)*-\d+$/;
 const FGCA_DOC_ID_RE = /^(FGCA|DGCA)(-[A-Z0-9][A-Z0-9_]*)*-\d+$/;
 const CONSTRAINT_ID_RE = /^CONSTRAINT(-[A-Z0-9][A-Z0-9_]*)*-\d+$/;
 function isNonEmptyString(v) {
@@ -42,6 +43,16 @@ function asObjectArray(v) {
         return null;
     return v.map((el) => (el && typeof el === 'object' ? el : null));
 }
+/** DGA mode (`view_config.layers.changes: off`) may omit the changes layer. */
+function isChangesLayerOff(raw) {
+    const vc = raw['view_config'];
+    if (!vc || typeof vc !== 'object')
+        return false;
+    const layers = vc['layers'];
+    if (!layers || typeof layers !== 'object')
+        return false;
+    return layers['changes'] === 'off';
+}
 /**
  * Validate canonical FGCA YAML and, on success, return an internal-form
  * `FGCADoc` ready for `buildFGCALayout`.
@@ -87,7 +98,10 @@ export function parseCanonicalFGCA(input) {
     }
     const factorsRaw = asObjectArray(raw['factors']);
     const goalsRaw = asObjectArray(raw['goals']);
-    const changesRaw = asObjectArray(raw['changes']);
+    let changesRaw = asObjectArray(raw['changes']);
+    if (changesRaw === null && raw['changes'] === undefined && isChangesLayerOff(raw)) {
+        changesRaw = [];
+    }
     const activitiesRaw = asObjectArray(raw['actions']);
     if (activitiesRaw === null && 'activities' in raw) {
         errors.push({ code: 'FGCA-004', message: '"activities" key is not accepted — rename to "actions"', path: 'actions' });
@@ -145,7 +159,7 @@ export function parseCanonicalFGCA(input) {
     factors.forEach((el, i) => checkLayerElement(el, `factors[${i}]`, FACTOR_OR_DRIVER_ID_RE, factorIds));
     goals.forEach((el, i) => checkLayerElement(el, `goals[${i}]`, GOAL_ID_RE, goalIds));
     changes.forEach((el, i) => checkLayerElement(el, `changes[${i}]`, CHANGE_ID_RE, changeIds));
-    activities.forEach((el, i) => checkLayerElement(el, `activities[${i}]`, ACTIVITY_ID_RE, activityIds));
+    activities.forEach((el, i) => checkLayerElement(el, `activities[${i}]`, ACTION_OR_ACTIVITY_ID_RE, activityIds));
     if (errors.length > 0)
         return { valid: false, errors, warnings };
     // Cross-refs.

package/dist/fgca/preview-layout.d.ts

@@ -23,7 +23,7 @@ export interface FGCAPreviewActivity {
     name: string;
     goal_id?: number | string | null;
 }
-/** Structural input the preview layout needs — a subset of the parsed FGCA/FGA doc. */
+/** Structural input the preview layout needs — a subset of the parsed DGCA/DGA doc. */
 export interface FGCAPreviewDoc {
     factors: FGCAPreviewFactor[];
     goals: FGCAPreviewGoal[];
@@ -31,7 +31,7 @@ export interface FGCAPreviewDoc {
     activities: FGCAPreviewActivity[];
 }
 export interface FGCAPreviewLayoutOptions {
-    /** FGA hides the Changes column and links Goal → Activity directly. */
+    /** DGA hides the Changes column and links Goal → Activity directly. */
     hideChanges?: boolean;
     /** Horizontal gap (px) between columns. Default matches the historical hardcoded value. */
     colGap?: number;
@@ -39,11 +39,15 @@ export interface FGCAPreviewLayoutOptions {
     rowGap?: number;
     /** Trim to a level cap or a single root goal (vkgeorgia/strategy#77). Defaults to 'all'. */
     scope?: Scope;
+    /** Entity node width (px). Default {@link FGCA_NODE_W}. */
+    nodeWidth?: number;
+    /** Entity node height (px). Default {@link FGCA_NODE_H}. */
+    nodeHeight?: number;
 }
 /**
- * Trims an FGCA/FGA doc to a scope (vkgeorgia/strategy#77).
+ * Trims a DGCA/DGA doc to a scope.
  *
- * FGCA/FGA goals are flat (no parent_id), so:
+ * DGCA/DGA goals are flat (no parent_id), so:
  *   - 'level' → goals with `(level ?? 0) <= maxLevel`.
  *   - 'root'  → the single goal whose id matches `rootGoalId` (empty when absent).
  *