@transitrix/diagrams 1.0.0

package/dist/fgca/index.d.ts

@@ -0,0 +1,16 @@
+export { buildFGCALayout, NODE_WIDTH, NODE_HEIGHT, COLUMN_GAP, ROW_GAP, COLUMN_BG } from "./layout";
+export type { FGCALayoutInput } from "./layout";
+export { layoutFGCAPreview, selectScopedFGCA, FGCA_NODE_W, FGCA_NODE_H, FGCA_HEADER_H, FGCA_PAD, FGCA_DEFAULT_COL_GAP, FGCA_DEFAULT_ROW_GAP, } from "./preview-layout";
+export type { FGCAPreviewColumn, FGCAPreviewDoc, FGCAPreviewLayout, FGCAPreviewLayoutOptions, FGCAPreviewNode, FGCAPreviewEdge, FGCAPreviewColumnPos, } from "./preview-layout";
+export { buildChainTable } from "./chain-table";
+export type { ChainTable, ChainTableCell, ChainColumn, ChainCell, ChainTableOptions } from "./chain-table";
+export { validateFGCADoc } from "./validate";
+export type { FGCADoc, FGCAValidationResult, FGCAValidationError, FGCAValidationWarning } from "./validate";
+export { ALL_FGCA_COLUMNS, FGCA_COLUMN_LABELS, } from "./types";
+export type { FactorItem, GoalItem, BdnChangeWithActivities, ActivityItem, ActivityTypeItem, DiagramStyle, FGCAColumn, } from "./types";
+export { default as FGCAFactorNode } from "./nodes/FGCAFactorNode";
+export { default as FGCAGoalNode } from "./nodes/FGCAGoalNode";
+export { default as FGCAChangeNode } from "./nodes/FGCAChangeNode";
+export { default as FGCAActivityNode } from "./nodes/FGCAActivityNode";
+/** ReactFlow nodeTypes map — pass directly to <ReactFlow nodeTypes={FGCA_NODE_TYPES} /> */
+export { FGCA_NODE_TYPES } from "./nodeTypes";

package/dist/fgca/index.js

@@ -0,0 +1,11 @@
+export { buildFGCALayout, NODE_WIDTH, NODE_HEIGHT, COLUMN_GAP, ROW_GAP, COLUMN_BG } from "./layout";
+export { layoutFGCAPreview, selectScopedFGCA, FGCA_NODE_W, FGCA_NODE_H, FGCA_HEADER_H, FGCA_PAD, FGCA_DEFAULT_COL_GAP, FGCA_DEFAULT_ROW_GAP, } from "./preview-layout";
+export { buildChainTable } from "./chain-table";
+export { validateFGCADoc } from "./validate";
+export { ALL_FGCA_COLUMNS, FGCA_COLUMN_LABELS, } from "./types";
+export { default as FGCAFactorNode } from "./nodes/FGCAFactorNode";
+export { default as FGCAGoalNode } from "./nodes/FGCAGoalNode";
+export { default as FGCAChangeNode } from "./nodes/FGCAChangeNode";
+export { default as FGCAActivityNode } from "./nodes/FGCAActivityNode";
+/** ReactFlow nodeTypes map — pass directly to <ReactFlow nodeTypes={FGCA_NODE_TYPES} /> */
+export { FGCA_NODE_TYPES } from "./nodeTypes";

package/dist/fgca/layout.d.ts

@@ -0,0 +1,27 @@
+import type { Node, Edge } from "reactflow";
+import type { FactorItem, GoalItem, BdnChangeWithActivities, ActivityItem, ActivityTypeItem, DiagramStyle, FGCAColumn } from "./types";
+export declare const NODE_WIDTH = 250;
+export declare const NODE_HEIGHT = 80;
+export declare const COLUMN_GAP = 180;
+export declare const ROW_GAP = 24;
+/** Default background colours per column. */
+export declare const COLUMN_BG: Record<FGCAColumn, string>;
+export interface FGCALayoutInput {
+    factors: FactorItem[];
+    goals: GoalItem[];
+    changes: BdnChangeWithActivities[];
+    activities: ActivityItem[];
+    visibleColumns: Set<FGCAColumn>;
+    diagramStyle?: DiagramStyle;
+    activityTypeList?: ActivityTypeItem[];
+    /** Per-level goal background colours. Fallback used when a level is not in the map. */
+    goalLevelColors?: Record<number, string>;
+}
+/**
+ * Pure layout function: converts raw FGCA data into ReactFlow nodes + edges.
+ * No React, no Redux, no DOM. Safe to call in Node.js or a test environment.
+ */
+export declare function buildFGCALayout({ factors, goals, changes, activities, visibleColumns, diagramStyle, activityTypeList, goalLevelColors, }: FGCALayoutInput): {
+    nodes: Node[];
+    edges: Edge[];
+};

package/dist/fgca/layout.js

@@ -0,0 +1,156 @@
+import { Position, MarkerType } from "reactflow";
+import { ALL_FGCA_COLUMNS } from "./types";
+export const NODE_WIDTH = 250;
+export const NODE_HEIGHT = 80;
+export const COLUMN_GAP = 180;
+export const ROW_GAP = 24;
+/** Default background colours per column. */
+export const COLUMN_BG = {
+    factor: "#fef3c7",
+    goal: "#e0e7ff",
+    change: "#dbeafe",
+    activity: "#d4edda",
+};
+/**
+ * Pure layout function: converts raw FGCA data into ReactFlow nodes + edges.
+ * No React, no Redux, no DOM. Safe to call in Node.js or a test environment.
+ */
+export function buildFGCALayout({ factors, goals, changes, activities, visibleColumns, diagramStyle = {}, activityTypeList = [], goalLevelColors = {}, }) {
+    const nodes = [];
+    const edges = [];
+    const { edgeColor = "#94a3b8", edgeWidth = 1, nodeBorderColor = "#94a3b8", nodeBorderWidth = 1 } = diagramStyle;
+    const visibleCols = ALL_FGCA_COLUMNS.filter((c) => visibleColumns.has(c));
+    const colX = {};
+    visibleCols.forEach((col, idx) => {
+        colX[col] = idx * (NODE_WIDTH + COLUMN_GAP);
+    });
+    const goalIds = new Set(goals.map((g) => g.id));
+    const edgeStyle = { strokeWidth: edgeWidth, stroke: edgeColor };
+    const baseNodeStyle = { borderColor: nodeBorderColor, borderWidth: nodeBorderWidth, borderStyle: "solid" };
+    if (visibleColumns.has("factor")) {
+        factors.forEach((f, i) => {
+            nodes.push({
+                id: `factor_${f.id}`,
+                type: "fgcaFactor",
+                position: { x: colX["factor"], y: i * (NODE_HEIGHT + ROW_GAP) },
+                data: { id: f.id, name: f.name, ...baseNodeStyle },
+                sourcePosition: Position.Right,
+                targetPosition: Position.Left,
+                width: NODE_WIDTH,
+                height: NODE_HEIGHT,
+            });
+        });
+    }
+    if (visibleColumns.has("goal")) {
+        goals.forEach((g, i) => {
+            const level = g.level ?? 0;
+            const bgColor = goalLevelColors[level] ?? COLUMN_BG.goal;
+            nodes.push({
+                id: `goal_${g.id}`,
+                type: "fgcaGoal",
+                position: { x: colX["goal"], y: i * (NODE_HEIGHT + ROW_GAP) },
+                data: { id: g.id, name: g.name, level, bgColor, ...baseNodeStyle },
+                sourcePosition: Position.Right,
+                targetPosition: Position.Left,
+                width: NODE_WIDTH,
+                height: NODE_HEIGHT,
+            });
+        });
+    }
+    if (visibleColumns.has("change")) {
+        changes.forEach((c, i) => {
+            nodes.push({
+                id: `change_${c.id}`,
+                type: "fgcaChange",
+                position: { x: colX["change"], y: i * (NODE_HEIGHT + ROW_GAP) },
+                data: { id: c.id, name: c.name, ...baseNodeStyle },
+                sourcePosition: Position.Right,
+                targetPosition: Position.Left,
+                width: NODE_WIDTH,
+                height: NODE_HEIGHT,
+            });
+        });
+    }
+    if (visibleColumns.has("activity")) {
+        activities.forEach((a, i) => {
+            const activityTypeName = (a.activity_type_id != null &&
+                activityTypeList.find((t) => t.id === a.activity_type_id)?.name) ||
+                "Activity";
+            nodes.push({
+                id: `activity_${a.id}`,
+                type: "fgcaActivity",
+                position: { x: colX["activity"], y: i * (NODE_HEIGHT + ROW_GAP) },
+                data: { id: a.id, name: a.name, activityTypeName, ...baseNodeStyle },
+                sourcePosition: Position.Right,
+                targetPosition: Position.Left,
+                width: NODE_WIDTH,
+                height: NODE_HEIGHT,
+            });
+        });
+    }
+    // Factor→Goal edges (via embedded factor[] on each goal)
+    if (visibleColumns.has("factor") && visibleColumns.has("goal")) {
+        goals.forEach((g) => {
+            g.factor?.forEach((f) => {
+                edges.push({
+                    id: `edge_f${f.id}_g${g.id}`,
+                    source: `factor_${f.id}`,
+                    target: `goal_${g.id}`,
+                    markerEnd: { type: MarkerType.ArrowClosed },
+                    type: "smoothstep",
+                    style: edgeStyle,
+                });
+            });
+        });
+    }
+    // Goal→Change edges
+    if (visibleColumns.has("goal") && visibleColumns.has("change")) {
+        changes.forEach((c) => {
+            if (goalIds.has(c.goal_id)) {
+                edges.push({
+                    id: `edge_g${c.goal_id}_c${c.id}`,
+                    source: `goal_${c.goal_id}`,
+                    target: `change_${c.id}`,
+                    markerEnd: { type: MarkerType.ArrowClosed },
+                    type: "smoothstep",
+                    style: edgeStyle,
+                });
+            }
+        });
+    }
+    // Change→Activity edges
+    if (visibleColumns.has("change") && visibleColumns.has("activity")) {
+        changes.forEach((c) => {
+            (c.activity_ids ?? []).forEach((aid) => {
+                edges.push({
+                    id: `edge_c${c.id}_a${aid}`,
+                    source: `change_${c.id}`,
+                    target: `activity_${aid}`,
+                    markerEnd: { type: MarkerType.ArrowClosed },
+                    type: "smoothstep",
+                    style: edgeStyle,
+                });
+            });
+        });
+    }
+    // Goal→Activity direct edges (only for activities not already covered via a Change link)
+    if (visibleColumns.has("goal") && visibleColumns.has("activity")) {
+        const coveredActivityIds = visibleColumns.has("change")
+            ? new Set(changes.flatMap((c) => c.activity_ids ?? []))
+            : new Set();
+        activities.forEach((a) => {
+            const gid = a.goal_id;
+            if (gid != null && goalIds.has(gid) && !coveredActivityIds.has(a.id)) {
+                edges.push({
+                    id: `edge_g${gid}_a${a.id}`,
+                    source: `goal_${gid}`,
+                    target: `activity_${a.id}`,
+                    markerEnd: { type: MarkerType.ArrowClosed },
+                    type: "smoothstep",
+                    style: edgeStyle,
+                });
+            }
+        });
+    }
+    return { nodes, edges };
+}

package/dist/fgca/nodeTypes.d.ts

@@ -0,0 +1,6 @@
+export declare const FGCA_NODE_TYPES: {
+    readonly fgcaFactor: import("react").MemoExoticComponent<({ data, isConnectable }: import("./nodes/FGCAFactorNode").FGCAFactorNodeProps) => import("react/jsx-runtime").JSX.Element>;
+    readonly fgcaGoal: import("react").MemoExoticComponent<({ data, isConnectable }: import("./nodes/FGCAGoalNode").FGCAGoalNodeProps) => import("react/jsx-runtime").JSX.Element>;
+    readonly fgcaChange: import("react").MemoExoticComponent<({ data, isConnectable }: import("./nodes/FGCAChangeNode").FGCAChangeNodeProps) => import("react/jsx-runtime").JSX.Element>;
+    readonly fgcaActivity: import("react").MemoExoticComponent<({ data, isConnectable }: import("./nodes/FGCAActivityNode").FGCAActivityNodeProps) => import("react/jsx-runtime").JSX.Element>;
+};

package/dist/fgca/nodeTypes.js

@@ -0,0 +1,10 @@
+import FGCAFactorNode from "./nodes/FGCAFactorNode";
+import FGCAGoalNode from "./nodes/FGCAGoalNode";
+import FGCAChangeNode from "./nodes/FGCAChangeNode";
+import FGCAActivityNode from "./nodes/FGCAActivityNode";
+export const FGCA_NODE_TYPES = {
+    fgcaFactor: FGCAFactorNode,
+    fgcaGoal: FGCAGoalNode,
+    fgcaChange: FGCAChangeNode,
+    fgcaActivity: FGCAActivityNode,
+};

package/dist/fgca/nodes/FGCAActivityNode.d.ts

@@ -0,0 +1,13 @@
+import React from "react";
+export interface FGCAActivityNodeProps {
+    data: {
+        id: number;
+        name: string;
+        activityTypeName?: string;
+        borderColor?: string;
+        borderWidth?: number;
+    };
+    isConnectable?: boolean;
+}
+declare const FGCAActivityNode: React.MemoExoticComponent<({ data, isConnectable }: FGCAActivityNodeProps) => import("react/jsx-runtime").JSX.Element>;
+export default FGCAActivityNode;

package/dist/fgca/nodes/FGCAActivityNode.js

@@ -0,0 +1,35 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { memo } from "react";
+import { Handle, Position } from "reactflow";
+const NODE_WIDTH = 250;
+const NODE_HEIGHT = 80;
+const FGCAActivityNode = memo(({ data, isConnectable }) => (_jsxs("div", { style: {
+        background: "var(--ts-layer-activity)",
+        width: NODE_WIDTH,
+        height: NODE_HEIGHT,
+        padding: "6px 8px",
+        fontSize: "12px",
+        borderColor: data.borderColor ?? "var(--ts-node-stroke)",
+        borderWidth: data.borderWidth ?? 1,
+        borderStyle: "solid",
+        borderRadius: "0.75rem",
+        boxShadow: "0 1px 4px rgba(0,0,0,0.12)",
+        display: "flex",
+        flexDirection: "column",
+        justifyContent: "center",
+        alignItems: "center",
+        textAlign: "center",
+        color: "var(--ts-text-primary)",
+    }, children: [_jsx(Handle, { type: "target", position: Position.Left, isConnectable: isConnectable, style: { background: "var(--ts-node-stroke)" } }), _jsx(Handle, { type: "source", position: Position.Right, isConnectable: false, style: { background: "var(--ts-node-stroke)" } }), _jsx("div", { style: {
+                fontWeight: 600,
+                lineHeight: 1.2,
+                overflow: "hidden",
+                display: "-webkit-box",
+                WebkitLineClamp: 2,
+                WebkitBoxOrient: "vertical",
+                wordBreak: "break-word",
+                padding: "0 4px",
+                width: "100%",
+            }, title: data.name, children: data.name }), _jsxs("div", { style: { fontSize: "10px", color: "var(--ts-text-secondary)", marginTop: 2 }, children: [data.activityTypeName ?? "Activity", " | A-", String(data.id).padStart(3, "0")] })] })));
+FGCAActivityNode.displayName = "FGCAActivityNode";
+export default FGCAActivityNode;

package/dist/fgca/nodes/FGCAChangeNode.d.ts

@@ -0,0 +1,12 @@
+import React from "react";
+export interface FGCAChangeNodeProps {
+    data: {
+        id: number;
+        name: string;
+        borderColor?: string;
+        borderWidth?: number;
+    };
+    isConnectable?: boolean;
+}
+declare const FGCAChangeNode: React.MemoExoticComponent<({ data, isConnectable }: FGCAChangeNodeProps) => import("react/jsx-runtime").JSX.Element>;
+export default FGCAChangeNode;

package/dist/fgca/nodes/FGCAChangeNode.js

@@ -0,0 +1,35 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { memo } from "react";
+import { Handle, Position } from "reactflow";
+const NODE_WIDTH = 250;
+const NODE_HEIGHT = 80;
+const FGCAChangeNode = memo(({ data, isConnectable }) => (_jsxs("div", { style: {
+        background: "var(--ts-layer-change)",
+        width: NODE_WIDTH,
+        height: NODE_HEIGHT,
+        padding: "6px 8px",
+        fontSize: "12px",
+        borderColor: data.borderColor ?? "var(--ts-node-stroke)",
+        borderWidth: data.borderWidth ?? 1,
+        borderStyle: "solid",
+        borderRadius: "0.75rem",
+        boxShadow: "0 1px 4px rgba(0,0,0,0.12)",
+        display: "flex",
+        flexDirection: "column",
+        justifyContent: "center",
+        alignItems: "center",
+        textAlign: "center",
+        color: "var(--ts-text-primary)",
+    }, children: [_jsx(Handle, { type: "target", position: Position.Left, isConnectable: isConnectable, style: { background: "var(--ts-node-stroke)" } }), _jsx(Handle, { type: "source", position: Position.Right, isConnectable: false, style: { background: "var(--ts-node-stroke)" } }), _jsx("div", { style: {
+                fontWeight: 600,
+                lineHeight: 1.2,
+                overflow: "hidden",
+                display: "-webkit-box",
+                WebkitLineClamp: 2,
+                WebkitBoxOrient: "vertical",
+                wordBreak: "break-word",
+                padding: "0 4px",
+                width: "100%",
+            }, title: data.name, children: data.name }), _jsxs("div", { style: { fontSize: "10px", color: "var(--ts-text-secondary)", marginTop: 2 }, children: ["C-", String(data.id).padStart(3, "0")] })] })));
+FGCAChangeNode.displayName = "FGCAChangeNode";
+export default FGCAChangeNode;

package/dist/fgca/nodes/FGCAFactorNode.d.ts

@@ -0,0 +1,12 @@
+import React from "react";
+export interface FGCAFactorNodeProps {
+    data: {
+        id: number;
+        name: string;
+        borderColor?: string;
+        borderWidth?: number;
+    };
+    isConnectable?: boolean;
+}
+declare const FGCAFactorNode: React.MemoExoticComponent<({ data, isConnectable }: FGCAFactorNodeProps) => import("react/jsx-runtime").JSX.Element>;
+export default FGCAFactorNode;

package/dist/fgca/nodes/FGCAFactorNode.js

@@ -0,0 +1,35 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { memo } from "react";
+import { Handle, Position } from "reactflow";
+const NODE_WIDTH = 250;
+const NODE_HEIGHT = 80;
+const FGCAFactorNode = memo(({ data, isConnectable }) => (_jsxs("div", { style: {
+        background: "var(--ts-layer-factor)",
+        width: NODE_WIDTH,
+        height: NODE_HEIGHT,
+        padding: "6px 8px",
+        fontSize: "12px",
+        borderColor: data.borderColor ?? "var(--ts-node-stroke)",
+        borderWidth: data.borderWidth ?? 1,
+        borderStyle: "solid",
+        borderRadius: "0.75rem",
+        boxShadow: "0 1px 4px rgba(0,0,0,0.12)",
+        display: "flex",
+        flexDirection: "column",
+        justifyContent: "center",
+        alignItems: "center",
+        textAlign: "center",
+        color: "var(--ts-text-primary)",
+    }, children: [_jsx(Handle, { type: "target", position: Position.Left, isConnectable: false, style: { background: "var(--ts-node-stroke)" } }), _jsx(Handle, { type: "source", position: Position.Right, isConnectable: isConnectable, style: { background: "var(--ts-node-stroke)" } }), _jsx("div", { style: {
+                fontWeight: 600,
+                lineHeight: 1.2,
+                overflow: "hidden",
+                display: "-webkit-box",
+                WebkitLineClamp: 2,
+                WebkitBoxOrient: "vertical",
+                wordBreak: "break-word",
+                padding: "0 4px",
+                width: "100%",
+            }, title: data.name, children: data.name }), _jsxs("div", { style: { fontSize: "10px", color: "var(--ts-text-secondary)", marginTop: 2 }, children: ["F-", String(data.id).padStart(4, "0")] })] })));
+FGCAFactorNode.displayName = "FGCAFactorNode";
+export default FGCAFactorNode;

package/dist/fgca/nodes/FGCAGoalNode.d.ts

@@ -0,0 +1,14 @@
+import React from "react";
+export interface FGCAGoalNodeProps {
+    data: {
+        id: number;
+        name: string;
+        level?: number;
+        bgColor?: string;
+        borderColor?: string;
+        borderWidth?: number;
+    };
+    isConnectable?: boolean;
+}
+declare const FGCAGoalNode: React.MemoExoticComponent<({ data, isConnectable }: FGCAGoalNodeProps) => import("react/jsx-runtime").JSX.Element>;
+export default FGCAGoalNode;

package/dist/fgca/nodes/FGCAGoalNode.js

@@ -0,0 +1,40 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { memo } from "react";
+import { Handle, Position } from "reactflow";
+const NODE_WIDTH = 250;
+const NODE_HEIGHT = 80;
+const DEFAULT_BG = "var(--ts-layer-goal)";
+const FGCAGoalNode = memo(({ data, isConnectable }) => {
+    const level = data.level ?? 0;
+    const bg = data.bgColor ?? DEFAULT_BG;
+    return (_jsxs("div", { style: {
+            background: bg,
+            width: NODE_WIDTH,
+            height: NODE_HEIGHT,
+            padding: "6px 8px",
+            fontSize: "12px",
+            borderColor: data.borderColor ?? "var(--ts-node-stroke)",
+            borderWidth: data.borderWidth ?? 1,
+            borderStyle: "solid",
+            borderRadius: "0.75rem",
+            boxShadow: "0 1px 4px rgba(0,0,0,0.12)",
+            display: "flex",
+            flexDirection: "column",
+            justifyContent: "center",
+            alignItems: "center",
+            textAlign: "center",
+            color: "var(--ts-text-primary)",
+        }, children: [_jsx(Handle, { type: "target", position: Position.Left, isConnectable: false, style: { background: "var(--ts-node-stroke)" } }), _jsx(Handle, { type: "source", position: Position.Right, isConnectable: isConnectable, style: { background: "var(--ts-node-stroke)" } }), _jsx("div", { style: {
+                    fontWeight: 600,
+                    lineHeight: 1.2,
+                    overflow: "hidden",
+                    display: "-webkit-box",
+                    WebkitLineClamp: 2,
+                    WebkitBoxOrient: "vertical",
+                    wordBreak: "break-word",
+                    padding: "0 4px",
+                    width: "100%",
+                }, title: data.name, children: data.name }), _jsxs("div", { style: { fontSize: "10px", color: "var(--ts-text-secondary)", marginTop: 2 }, children: ["G-", String(data.id).padStart(4, "0"), " | Lvl: ", level] })] }));
+});
+FGCAGoalNode.displayName = "FGCAGoalNode";
+export default FGCAGoalNode;

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

@@ -0,0 +1,58 @@
+/**
+ * Canonical-form FGCA parser + validator.
+ *
+ * Accepts the methodology's canonical FGCA YAML shape (see
+ * `transitrix/methodology` `notations/02-fgca.md`):
+ *
+ * - 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`).
+ * - Plural canonical-direction cross-references: `goal.factors`,
+ *   `change.goals`, `activity.changes`, `activity.goals`.
+ * - Per-notation validation codes `FGCA-001 … FGCA-015`.
+ *
+ * Returns the validation result plus, on success, an internal `FGCADoc`
+ * representation built from the canonical input — string IDs are kept
+ * as strings; the existing `buildFGCALayout` consumes `id: number`
+ * historically but the layout code only uses IDs as opaque keys, so
+ * string IDs work fine.
+ *
+ * Strategy hub #63: this lives at the input boundary so the library's
+ * internal types (currently using DSM-API form — numeric IDs and
+ * singular cross-refs) can stay where they are. A follow-up task can
+ * unify the internal types with the canonical form across all sister
+ * modules.
+ */
+import type { FGCADoc } from './validate.js';
+import type { ValidationResult } from '../validation-types.js';
+export interface CanonicalFGCAResult extends ValidationResult {
+    /** On success, the internal-form FGCADoc derived from the canonical input. */
+    parsed?: FGCADoc;
+}
+/**
+ * Validate canonical FGCA YAML and, on success, return an internal-form
+ * `FGCADoc` ready for `buildFGCALayout`.
+ */
+export declare function parseCanonicalFGCA(input: unknown): CanonicalFGCAResult;
+/** On success, the internal-form FGCADoc derived from canonical FGA input. */
+export interface CanonicalFGAResult extends ValidationResult {
+    parsed?: FGCADoc;
+}
+/**
+ * Canonical-form FGA parser + validator.
+ *
+ * FGA is the canonical FGCA chain minus the `changes[]` layer — flat
+ * top-level `factors[]` + `goals[]` + `activities[]`, with `activity.goals[]`
+ * linking activities straight to goals (no intermediate change). It reuses
+ * `parseCanonicalFGCA` by injecting an empty `changes` array and remapping
+ * the FGCA-NNN codes to the FGA-NNN registry (`notations/03-fga.md`,
+ * FGA-001..011). The resulting internal `FGCADoc` carries `activity.goal_id`,
+ * which is exactly what the renderer needs to draw goal → activity edges —
+ * the field whose absence produced the "FGA nodes render, no edges" bug
+ * (transitrix/methodology#65 / vkgeorgia/strategy#65).
+ *
+ * Lives beside `parseCanonicalFGCA` (rather than inline in the extension) so
+ * the canonical FGA path is unit-testable and the library owns the single
+ * canon shape — flat form only, no `fga:` wrapper.
+ */
+export declare function parseCanonicalFGA(input: unknown): CanonicalFGAResult;