@transitrix/diagrams 1.10.0 → 1.12.0

package/src/compliance-verification-matrix/build.ts

@@ -0,0 +1,84 @@
+// Requirement -> verification matrix builder.
+
+import type { ComplianceIndex } from '../compliance/types.js';
+import { buildGapReport } from '../compliance/gap-report.js';
+import type {
+  RequirementVerificationMatrix,
+  RequirementVerificationMatrixOptions,
+  RequirementVerificationRow,
+} from './types.js';
+
+function byId<T extends { id: string }>(a: T, b: T): number {
+  return a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
+}
+
+/**
+ * Builds the repository-wide requirement -> verification matrix.
+ *
+ * Pure projection over an already-built `ComplianceIndex`
+ * (`compliance/reverse-index.ts`) — no I/O, no revalidation. Reuses
+ * `buildGapReport`'s `REQ-VERIF-COVERAGE-001`/`-002` verdicts verbatim rather
+ * than recomputing a competing coverage status.
+ *
+ * Ordering: requirements sorted by id; within a requirement, its verification
+ * rows sorted by verification id. Both are explicit sorts over the index's
+ * values, so the result is independent of the Map's insertion order (which —
+ * for a caller that built the index from a filesystem walk — would otherwise
+ * track directory enumeration order).
+ */
+export function buildRequirementVerificationMatrix(
+  index: ComplianceIndex,
+  options: RequirementVerificationMatrixOptions = {},
+): RequirementVerificationMatrix {
+  const gapReport = buildGapReport(index, options);
+  const noVerification = new Set(gapReport.requirementsWithoutVerification.map(r => r.id));
+  const unresolvedVerification = new Set(gapReport.requirementsWithUnresolvedVerification.map(r => r.id));
+
+  const requirements = [...index.requirementById.values()].sort(byId);
+
+  const rows: RequirementVerificationRow[] = [];
+  let verificationRowCount = 0;
+  let gapRequirementCount = 0;
+
+  for (const requirement of requirements) {
+    const parentId = requirement.parent;
+    const parentLabel = parentId ? index.requirementById.get(parentId)?.name : undefined;
+
+    const base: Pick<RequirementVerificationRow, 'requirementId' | 'requirementLabel' | 'parentId' | 'parentLabel'> = {
+      requirementId: requirement.id,
+      requirementLabel: requirement.name,
+      ...(parentId !== undefined ? { parentId } : {}),
+      ...(parentLabel !== undefined ? { parentLabel } : {}),
+    };
+
+    if (noVerification.has(requirement.id)) {
+      gapRequirementCount++;
+      rows.push({ ...base, coverageGap: 'REQ-VERIF-COVERAGE-001' });
+      continue;
+    }
+
+    const gap = unresolvedVerification.has(requirement.id) ? ('REQ-VERIF-COVERAGE-002' as const) : undefined;
+    if (gap) gapRequirementCount++;
+
+    const verifications = [...(index.verificationsByRequirement.get(requirement.id) ?? [])].sort(byId);
+    for (const verification of verifications) {
+      verificationRowCount++;
+      rows.push({
+        ...base,
+        verificationId: verification.id,
+        verificationLabel: verification.protocol ?? verification.id,
+        verificationOutcome: verification.outcome,
+        ...(gap ? { coverageGap: gap } : {}),
+      });
+    }
+  }
+
+  return {
+    rows,
+    summary: {
+      requirements: requirements.length,
+      verifications: verificationRowCount,
+      gaps: gapRequirementCount,
+    },
+  };
+}

package/src/compliance-verification-matrix/csv.ts

@@ -0,0 +1,47 @@
+// Deterministic CSV serialiser for the requirement-verification matrix.
+// Same row order as `buildRequirementVerificationMatrix` (requirement id,
+// then verification id). CRLF line endings, RFC-4180 quoting — the same
+// convention as the Gap Dashboard export.
+
+import type { RequirementVerificationMatrix, RequirementVerificationRow } from './types.js';
+
+const HEADER = [
+  'requirement_id',
+  'requirement_label',
+  'parent_id',
+  'parent_label',
+  'related_test_result_id',
+  'related_test_result_label',
+  'outcome',
+  'coverage_gap',
+] as const;
+
+function csvCell(value: string | undefined): string {
+  const v = value ?? '';
+  return `"${v.replace(/"/g, '""')}"`;
+}
+
+function rowCells(row: RequirementVerificationRow): string[] {
+  return [
+    row.requirementId,
+    row.requirementLabel,
+    row.parentId ?? '',
+    row.parentLabel ?? '',
+    row.verificationId ?? '',
+    row.verificationLabel ?? '',
+    row.verificationOutcome ?? '',
+    row.coverageGap ?? '',
+  ];
+}
+
+/**
+ * Serialise the matrix to CSV. Identical input yields byte-identical output;
+ * the row order is the builder's stable order.
+ */
+export function renderRequirementVerificationMatrixCsv(matrix: RequirementVerificationMatrix): string {
+  const lines = [HEADER.map(h => csvCell(h)).join(',')];
+  for (const row of matrix.rows) {
+    lines.push(rowCells(row).map(csvCell).join(','));
+  }
+  return lines.join('\r\n') + '\r\n';
+}

package/src/compliance-verification-matrix/index.ts

@@ -0,0 +1,7 @@
+export { buildRequirementVerificationMatrix } from './build.js';
+export { renderRequirementVerificationMatrixCsv } from './csv.js';
+export type {
+  RequirementVerificationMatrix,
+  RequirementVerificationMatrixOptions,
+  RequirementVerificationRow,
+} from './types.js';

package/src/compliance-verification-matrix/types.ts

@@ -0,0 +1,85 @@
+// Requirement -> verification matrix — deterministic, repository-wide
+// projection over the shared compliance reverse-index. Pure data; the
+// consumer (a VS Code table, an export) renders it.
+
+import type { VerificationOutcome } from '../verification/types.js';
+
+/**
+ * One row of the requirement-verification matrix.
+ *
+ * A requirement with N admitted VERIFICATION records produces N rows, one per
+ * verification. A requirement with none still produces exactly one row,
+ * carrying the `REQ-VERIF-COVERAGE-001` gap. A requirement whose
+ * verifications exist but never closed (pass/fail) produces one row per
+ * verification — each carrying the `REQ-VERIF-COVERAGE-002` gap alongside its
+ * (still-open) outcome; the open verification is real data and is never
+ * replaced by a placeholder gap row.
+ *
+ * Coverage comes only from `VERIFICATION.verifies` (27-verification.md §2). A
+ * child requirement's verification never covers its `parent`
+ * (15-requirement.md §2.4 — `parent` records structure only, no roll-up).
+ */
+export interface RequirementVerificationRow {
+  requirementId: string;
+  requirementLabel: string;
+
+  /**
+   * Direct `REQUIREMENT.parent` id, verbatim, present whenever the field is
+   * set — whether or not it resolves. `parent` resolution is not currently a
+   * validator concern (15-requirement.md §2.4); a dangling parent must still
+   * be visible on the row, not silently dropped.
+   */
+  parentId?: string;
+  /**
+   * The resolved parent's `name`, present only when `parentId` names an
+   * admitted requirement in the index. Absent when `parentId` is set but
+   * unresolved (dangling), or when the requirement has no parent.
+   */
+  parentLabel?: string;
+
+  /** The verification filling this row, when one exists. */
+  verificationId?: string;
+  /**
+   * VERIFICATION carries no `name`/label field of its own
+   * (27-verification.md §2); `protocol` — the procedure description — is the
+   * closest human-readable text and is what this row shows as its label.
+   */
+  verificationLabel?: string;
+  verificationOutcome?: VerificationOutcome;
+
+  /**
+   * `REQ-VERIF-COVERAGE-001` / `-002` (`compliance/gap-report.ts`), reused
+   * verbatim — this builder never recomputes a competing coverage verdict.
+   * Absent once the requirement has at least one closed (pass/fail)
+   * verification.
+   */
+  coverageGap?: 'REQ-VERIF-COVERAGE-001' | 'REQ-VERIF-COVERAGE-002';
+}
+
+export interface RequirementVerificationMatrixOptions {
+  /**
+   * Forwarded to `buildGapReport`. Neither coverage gap this matrix surfaces
+   * (`REQ-VERIF-COVERAGE-001`/`-002`) depends on `today` — accepted only for
+   * call-site symmetry with the other compliance-view builders.
+   */
+  today?: string;
+}
+
+export interface RequirementVerificationMatrix {
+  /**
+   * One row per (requirement, verification) pair, plus one gap row per
+   * requirement with zero verifications.
+   *
+   * Ordering (stable, independent of filesystem/Map enumeration order):
+   * requirements sorted by id; within a requirement, its verification rows
+   * sorted by verification id.
+   */
+  rows: RequirementVerificationRow[];
+  summary: {
+    requirements: number;
+    /** Rows carrying a real verification (excludes -001 gap-only rows). */
+    verifications: number;
+    /** Requirements carrying a REQ-VERIF-COVERAGE-001 or -002 gap. */
+    gaps: number;
+  };
+}

package/src/fgca/action-change-ids.ts

@@ -0,0 +1,13 @@
+/**
+ * Action → Change linkage on an element record.
+ *
+ * Canonical field is `delivers_changes` (Action element spec). `changes` is
+ * the pre-rename alias still present on older fixtures and inline docs.
+ */
+export function actionChangeLinkField(
+  el: Record<string, unknown>,
+): 'delivers_changes' | 'changes' {
+  return Object.prototype.hasOwnProperty.call(el, 'delivers_changes')
+    ? 'delivers_changes'
+    : 'changes';
+}

package/src/fgca/parse-canonical.ts

@@ -8,7 +8,7 @@
  * - Typed string IDs per `IDS_AND_REFERENCES.md` (`FACTOR-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`.
+ *   `change.goals`, `action.delivers_changes`, `action.goals`.
  * - Per-notation validation codes `FGCA-001 … FGCA-015`.
  *
  * Returns the validation result plus, on success, an internal `FGCADoc`
@@ -36,10 +36,13 @@ import type {
   ValidationWarning,
   ValidationResult,
 } from '../validation-types.js';
+import { actionChangeLinkField } from './action-change-ids.js';
 
 export interface CanonicalFGCAResult extends ValidationResult {
   /** On success, the internal-form FGCADoc derived from the canonical input. */
   parsed?: FGCADoc;
+  /** True when a goal-scoped projection should show the scope caption. */
+  scopeCaption?: boolean;
 }
 
 // Canonical ID grammars per IDS_AND_REFERENCES.md §1. The TYPE prefix
@@ -64,9 +67,10 @@ function asObjectArray(v: unknown): Array<Record<string, unknown>> | null {
   return v.map((el) => (el && typeof el === 'object' ? (el as Record<string, unknown>) : null) as Record<string, unknown>);
 }
 
-/** DGA mode (`view_config.layers.changes: off`) may omit the changes layer. */
-function isChangesLayerOff(raw: Record<string, unknown>): boolean {
-  const vc = raw['view_config'];
+/** DGA mode (`view_config.layers.changes: off`) omits the Changes column. */
+export function isDgcaChangesLayerOff(input: unknown): boolean {
+  if (!input || typeof input !== 'object') return false;
+  const vc = (input as Record<string, unknown>)['view_config'];
   if (!vc || typeof vc !== 'object') return false;
   const layers = (vc as Record<string, unknown>)['layers'];
   if (!layers || typeof layers !== 'object') return false;
@@ -77,8 +81,20 @@ function isChangesLayerOff(raw: Record<string, unknown>): boolean {
 /**
  * Validate canonical FGCA YAML and, on success, return an internal-form
  * `FGCADoc` ready for `buildFGCALayout`.
+ *
+ * @param input The FGCA document to parse
+ * @param outOfScopeGoalIds When a goal-scoped projection omits goals that exist
+ *        in the catalogue, pass their IDs here to suppress FGCA-011/FGCA-009 errors
+ *        for references to out-of-scope goals. When provided and non-empty, and at least
+ *        one action or change references an out-of-scope goal, `scopeCaption` is set true.
+ * @param outOfScopeFactorIds When a goal-scoped projection omits factors that exist
+ *        in the catalogue, pass their IDs here to suppress FGCA-008 errors.
  */
-export function parseCanonicalFGCA(input: unknown): CanonicalFGCAResult {
+export function parseCanonicalFGCA(
+  input: unknown,
+  outOfScopeGoalIds?: Set<string> | null,
+  outOfScopeFactorIds?: Set<string> | null,
+): CanonicalFGCAResult {
   const errors: ValidationError[] = [];
   const warnings: ValidationWarning[] = [];
 
@@ -125,7 +141,7 @@ export function parseCanonicalFGCA(input: unknown): CanonicalFGCAResult {
   const factorsRaw = asObjectArray(raw['factors']);
   const goalsRaw = asObjectArray(raw['goals']);
   let changesRaw = asObjectArray(raw['changes']);
-  if (changesRaw === null && raw['changes'] === undefined && isChangesLayerOff(raw)) {
+  if (changesRaw === null && raw['changes'] === undefined && isDgcaChangesLayerOff(raw)) {
     changesRaw = [];
   }
   const activitiesRaw = asObjectArray(raw['actions']);
@@ -202,6 +218,9 @@ export function parseCanonicalFGCA(input: unknown): CanonicalFGCAResult {
 
   if (errors.length > 0) return { valid: false, errors, warnings };
 
+  // Track if any out-of-scope goals/factors are referenced (for scope caption).
+  let hasOutOfScopeRef = false;
+
   // Cross-refs.
   function checkRefArray(
     el: Record<string, unknown>,
@@ -210,6 +229,7 @@ export function parseCanonicalFGCA(input: unknown): CanonicalFGCAResult {
     refRe: RegExp,
     code: string,
     path: string,
+    outOfScope?: Set<string> | null,
   ): string[] {
     const ref = el[field];
     if (ref === undefined || ref === null) return [];
@@ -227,6 +247,12 @@ export function parseCanonicalFGCA(input: unknown): CanonicalFGCAResult {
         errors.push({ code: 'FGCA-007', message: `${path}.${field}[] entry "${r}" does not match the expected grammar`, path });
         continue;
       }
+      if (outOfScope?.has(r)) {
+        // Reference is out-of-scope: suppress error and mark that we found an out-of-scope reference (for caption).
+        hasOutOfScopeRef = true;
+        out.push(r);
+        continue;
+      }
       if (!targets.has(r)) {
         errors.push({ code, message: `${path}.${field}[] references undeclared element "${r}"`, path });
         continue;
@@ -245,7 +271,7 @@ export function parseCanonicalFGCA(input: unknown): CanonicalFGCAResult {
   }));
 
   const internalGoals: GoalItem[] = goals.map((el, i) => {
-    const refIds = checkRefArray(el!, 'factors', factorIds, FACTOR_OR_DRIVER_ID_RE, 'FGCA-008', `goals[${i}]`);
+    const refIds = checkRefArray(el!, 'factors', factorIds, FACTOR_OR_DRIVER_ID_RE, 'FGCA-008', `goals[${i}]`, outOfScopeFactorIds);
     return {
       id: String(el!['id']),
       name: String(el!['name'] ?? ''),
@@ -253,11 +279,12 @@ export function parseCanonicalFGCA(input: unknown): CanonicalFGCAResult {
     };
   });
 
-  // Build a reverse mapping: which changes does each activity reference (via
-  // canonical activity.changes)? Used to populate the internal `change.activity_ids`.
+  // Build a reverse mapping: which changes does each action deliver (via
+  // canonical `delivers_changes`, or the pre-rename `changes` alias)?
   const activityChangesByCanonicalActivityId = new Map<string, string[]>();
   activities.forEach((el, i) => {
-    const refIds = checkRefArray(el!, 'changes', changeIds, CHANGE_ID_RE, 'FGCA-010', `activities[${i}]`);
+    const field = actionChangeLinkField(el!);
+    const refIds = checkRefArray(el!, field, changeIds, CHANGE_ID_RE, 'FGCA-010', `activities[${i}]`);
     activityChangesByCanonicalActivityId.set(String(el!['id']), refIds);
   });
 
@@ -272,7 +299,7 @@ export function parseCanonicalFGCA(input: unknown): CanonicalFGCAResult {
   }
 
   const internalChanges: BdnChangeWithActivities[] = changes.map((el, i) => {
-    const goalRefs = checkRefArray(el!, 'goals', goalIds, GOAL_ID_RE, 'FGCA-009', `changes[${i}]`);
+    const goalRefs = checkRefArray(el!, 'goals', goalIds, GOAL_ID_RE, 'FGCA-009', `changes[${i}]`, outOfScopeGoalIds);
     // Internal `change.goal_id` is singular; canonical `change.goals` is plural.
     // First goal wins for the singular field; warn (not error) if multiple.
     if (goalRefs.length > 1) {
@@ -293,7 +320,7 @@ export function parseCanonicalFGCA(input: unknown): CanonicalFGCAResult {
   });
 
   const internalActivities: ActivityItem[] = activities.map((el, i) => {
-    const goalRefs = checkRefArray(el!, 'goals', goalIds, GOAL_ID_RE, 'FGCA-011', `actions[${i}]`);
+    const goalRefs = checkRefArray(el!, 'goals', goalIds, GOAL_ID_RE, 'FGCA-011', `actions[${i}]`, outOfScopeGoalIds);
     const typeVal = typeof el!['type'] === 'string' ? el!['type'] : undefined;
     return {
       id: String(el!['id']),
@@ -331,9 +358,16 @@ export function parseCanonicalFGCA(input: unknown): CanonicalFGCAResult {
     goals: internalGoals,
     changes: internalChanges,
     activities: internalActivities,
+    hideChanges: isDgcaChangesLayerOff(raw),
   };
 
-  return { valid: true, errors, warnings, parsed };
+  return {
+    valid: true,
+    errors,
+    warnings,
+    parsed,
+    scopeCaption: (outOfScopeGoalIds?.size ?? 0) > 0 && hasOutOfScopeRef,
+  };
 }
 
 const FGA_DOC_ID_RE = /^(FGA|DGA)(-[A-Z0-9][A-Z0-9_]*)*-\d+$/;
@@ -341,6 +375,8 @@ const FGA_DOC_ID_RE = /^(FGA|DGA)(-[A-Z0-9][A-Z0-9_]*)*-\d+$/;
 /** On success, the internal-form FGCADoc derived from canonical FGA input. */
 export interface CanonicalFGAResult extends ValidationResult {
   parsed?: FGCADoc;
+  /** True when a goal-scoped projection should show the scope caption. */
+  scopeCaption?: boolean;
 }
 
 /**
@@ -360,7 +396,11 @@ export interface CanonicalFGAResult extends ValidationResult {
  * the canonical FGA path is unit-testable and the library owns the single
  * canon shape — flat form only, no `fga:` wrapper.
  */
-export function parseCanonicalFGA(input: unknown): CanonicalFGAResult {
+export function parseCanonicalFGA(
+  input: unknown,
+  outOfScopeGoalIds?: Set<string> | null,
+  outOfScopeFactorIds?: Set<string> | null,
+): CanonicalFGAResult {
   if (!input || typeof input !== 'object') {
     return { valid: false, errors: [{ code: 'FGA-001', message: 'document root is not an object' }], warnings: [] };
   }
@@ -388,7 +428,7 @@ export function parseCanonicalFGA(input: unknown): CanonicalFGAResult {
   // codes are remapped on the way out. FGCA-009 / 010 / 014 (changes-related)
   // are unreachable here because `changes` is empty.
   const synth = { ...raw, notation: 'dgca', id: 'DGCA-FROM-DGA-1', changes: [] };
-  const r = parseCanonicalFGCA(synth);
+  const r = parseCanonicalFGCA(synth, outOfScopeGoalIds, outOfScopeFactorIds);
   const remap: Record<string, string> = {
     'FGCA-001': 'FGA-001',
     'FGCA-002': 'FGA-002',
@@ -408,5 +448,6 @@ export function parseCanonicalFGA(input: unknown): CanonicalFGAResult {
     errors: r.errors.map((e) => ({ ...e, code: remapCode(e.code) })),
     warnings: r.warnings.map((w) => ({ ...w, code: remapCode(w.code) })),
     parsed: r.parsed,
+    scopeCaption: r.scopeCaption,
   };
 }

package/src/fgca/resolver.ts

@@ -7,6 +7,8 @@
  * string IDs.  Filesystem-free — callable from unit tests without vscode.
  */
 
+import { actionChangeLinkField } from './action-change-ids.js';
+
 export interface FGCAViewConfig {
   goals?: {
     filter?: 'all' | 'ids' | 'tags';
@@ -15,6 +17,8 @@ export interface FGCAViewConfig {
   };
   factors?: { surface?: 'derived' | 'all' };
   changes?: { surface?: 'derived' | 'all' };
+  /** Canonical projection key. `activities` remains a deprecated alias. */
+  actions?: { surface?: 'derived' | 'all' };
   activities?: { surface?: 'derived' | 'all' };
   display?: { depth?: number | null; collapsed?: string[] };
 }
@@ -69,8 +73,8 @@ export function isFGCAViewDoc(parsed: unknown): boolean {
  * to pass to `parseCanonicalFGCA`.
  *
  * Cross-reference fields (`goal.factors[]`, `change.goals[]`,
- * `action.changes[]`) are carried from the canon elements unchanged; the
- * resolver decides which elements to include, not how they are shaped.
+ * `action.delivers_changes[]`) are carried from the canon elements unchanged;
+ * the resolver decides which elements to include, not how they are shaped.
  */
 export function resolveFGCA(
   viewDoc: unknown,
@@ -84,7 +88,11 @@ export function resolveFGCA(
   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 actionsConf = isObject(vc['actions'])
+    ? vc['actions']
+    : isObject(vc['activities'])
+      ? vc['activities']
+      : {};
 
   const factorElemsLegacy = collectByNotation(sources.elements, 'factor');
   const factorElemsNew = collectByNotation(sources.elements, 'driver');
@@ -139,17 +147,39 @@ export function resolveFGCA(
     selectedChanges.map((c) => str(c['id'])).filter((x): x is string => x !== undefined),
   );
 
-  // 4. Select activities: derived = reference ≥1 selected change or goal (degenerate FGA link)
+  // 4. Select actions: derived = delivers ≥1 selected change, or (DGA) a selected goal
   let selectedActivities: Array<Record<string, unknown>>;
-  if (str(activitiesConf['surface']) === 'all') {
+  if (str(actionsConf['surface']) === 'all') {
     selectedActivities = [...activityElems.values()];
   } else {
     selectedActivities = [...activityElems.values()].filter((a) =>
-      strArray(a['changes']).some((cid) => selectedChangeIds.has(cid)) ||
+      strArray(a[actionChangeLinkField(a)]).some((cid) => selectedChangeIds.has(cid)) ||
       strArray(a['goals']).some((gid) => selectedGoalIds.has(gid)),
     );
   }
 
+  // Collect out-of-scope goals (exist in catalogue but not in selected set).
+  // Used by the validator to suppress errors for references to goals that exist
+  // but are outside the scope.
+  let outOfScopeGoalIds: Set<string> | undefined;
+  if (goalsFilter !== 'all') {
+    // Goal scope is restricted; collect goals that exist but aren't selected.
+    outOfScopeGoalIds = new Set(
+      [...goalElems.keys()].filter((id) => !selectedGoalIds.has(id)),
+    );
+  }
+
+  // Collect out-of-scope factors (exist in catalogue but not in selected set).
+  const selectedFactorIds = new Set(
+    selectedFactors.map((f) => str(f['id'])).filter((x): x is string => x !== undefined),
+  );
+  let outOfScopeFactorIds: Set<string> | undefined;
+  if (goalsFilter !== 'all') {
+    outOfScopeFactorIds = new Set(
+      [...factorElems.keys()].filter((id) => !selectedFactorIds.has(id)),
+    );
+  }
+
   return {
     notation: 'dgca',
     id: viewDoc['id'],
@@ -159,5 +189,8 @@ export function resolveFGCA(
     goals: selectedGoals,
     changes: selectedChanges,
     actions: selectedActivities,
+    view_config: viewDoc['view_config'],
+    __outOfScopeGoalIds: outOfScopeGoalIds,
+    __outOfScopeFactorIds: outOfScopeFactorIds,
   };
 }

package/src/fgca/validate.ts

@@ -19,6 +19,8 @@ export interface FGCADoc {
   goals: GoalItem[];
   changes: BdnChangeWithActivities[];
   activities: ActivityItem[];
+  /** DGA mode: omit the Changes column (`view_config.layers.changes: off`). */
+  hideChanges?: boolean;
 }
 
 export function validateFGCADoc(input: unknown): FGCAValidationResult {

package/src/index.ts

@@ -38,6 +38,7 @@ export {
 export * from "./change/index";
 export * from "./compliance/index";
 export * from "./compliance-matrix/index";
+export * from "./compliance-verification-matrix/index";
 export * from "./confidence/index";
 export * from "./factor/index";
 export * from "./fgca/index";

package/src/process-blueprint/index.ts

@@ -27,6 +27,17 @@ export type {
   ValidationError as ProcessBlueprintValidationError,
   ValidationWarning as ProcessBlueprintValidationWarning,
   ValidationResult as ProcessBlueprintValidationResult,
+  ProcessBlueprintValidateOptions,
+  ProcessParentEdge,
 } from './validate.js';
 
 export { layoutProcessBlueprint } from './layout.js';
+export {
+  collectProcessColumnRecords,
+  collectStepHomeProcess,
+  columnIndexesForRealisedVia,
+  isProcessColumnId,
+  isStageColumnId,
+  resolveColumnDisplay,
+} from './resolve-columns.js';
+export type { ProcessColumnRecord } from './resolve-columns.js';