footprintjs 4.17.2 → 6.0.0

package/dist/lib/builder/index.js

@@ -19,4 +19,4 @@ Object.defineProperty(exports, "flowChart", { enumerable: true, get: function ()
 Object.defineProperty(exports, "specToStageNode", { enumerable: true, get: function () { return FlowChartBuilder_js_2.specToStageNode; } });
 var types_js_1 = require("./types.js");
 Object.defineProperty(exports, "ArrayMergeMode", { enumerable: true, get: function () { return types_js_1.ArrayMergeMode; } });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbGliL2J1aWxkZXIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLDBCQUEwQjtBQUMxQjs7Ozs7R0FLRzs7O0FBRUgsVUFBVTtBQUNWLDZEQUFzRjtBQUE3RSxrSEFBQSxXQUFXLE9BQUE7QUFBRSx1SEFBQSxnQkFBZ0IsT0FBQTtBQUFFLHFIQUFBLGNBQWMsT0FBQTtBQUV0RCxzQkFBc0I7QUFDdEIsNkRBQW1FO0FBQTFELGdIQUFBLFNBQVMsT0FBQTtBQUFFLHNIQUFBLGVBQWUsT0FBQTtBQXdCbkMsdUNBQTRDO0FBQW5DLDBHQUFBLGNBQWMsT0FBQSIsInNvdXJjZXNDb250ZW50IjpbIi8qIGlzdGFuYnVsIGlnbm9yZSBmaWxlICovXG4vKipcbiAqIGJ1aWxkZXIvIOKAlCBGbG93Y2hhcnQgY29uc3RydWN0aW9uIGxpYnJhcnkgKHplcm8gZGVwcyBvbiBvbGQgY29kZSlcbiAqXG4gKiBGbHVlbnQgQVBJIGZvciBidWlsZGluZyBTdGFnZU5vZGUgdHJlZXMgYW5kIFNlcmlhbGl6ZWRQaXBlbGluZVN0cnVjdHVyZS5cbiAqIENhbiBiZSB1c2VkIHN0YW5kYWxvbmUgZm9yIGJ1aWxkaW5nIGZsb3djaGFydCBzcGVjcyB3aXRob3V0IGV4ZWN1dGlvbi5cbiAqL1xuXG4vLyBDbGFzc2VzXG5leHBvcnQgeyBEZWNpZGVyTGlzdCwgRmxvd0NoYXJ0QnVpbGRlciwgU2VsZWN0b3JGbkxpc3QgfSBmcm9tICcuL0Zsb3dDaGFydEJ1aWxkZXIuanMnO1xuXG4vLyBGYWN0b3J5ICYgdXRpbGl0aWVzXG5leHBvcnQgeyBmbG93Q2hhcnQsIHNwZWNUb1N0YWdlTm9kZSB9IGZyb20gJy4vRmxvd0NoYXJ0QnVpbGRlci5qcyc7XG5cbi8vIFR5cGVzXG5leHBvcnQgdHlwZSB7XG4gIEJ1aWxkVGltZUV4dHJhY3RvcixcbiAgQnVpbGRUaW1lTm9kZU1ldGFkYXRhLFxuICBFeGVjT3B0aW9ucyxcbiAgRmxvd0NoYXJ0LFxuICBGbG93Q2hhcnRTcGVjLFxuICBJTG9nZ2VyLFxuICBTY29wZVByb3RlY3Rpb25Nb2RlLFxuICBTZXJpYWxpemVkUGlwZWxpbmVTdHJ1Y3R1cmUsXG4gIFNpbXBsaWZpZWRQYXJhbGxlbFNwZWMsXG4gIFN0YWdlRm4sXG4gIFN0YWdlRnVuY3Rpb24sXG4gIFN0YWdlTm9kZSxcbiAgU3RyZWFtQ2FsbGJhY2ssXG4gIFN0cmVhbUhhbmRsZXJzLFxuICBTdHJlYW1MaWZlY3ljbGVIYW5kbGVyLFxuICBTdHJlYW1Ub2tlbkhhbmRsZXIsXG4gIFN1YmZsb3dNb3VudE9wdGlvbnMsXG4gIFN1YmZsb3dSZWYsXG4gIFRyYXZlcnNhbEV4dHJhY3Rvcixcbn0gZnJvbSAnLi90eXBlcy5qcyc7XG5leHBvcnQgeyBBcnJheU1lcmdlTW9kZSB9IGZyb20gJy4vdHlwZXMuanMnO1xuIl19
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/builder/structure/StructureRecorder.js

@@ -0,0 +1,159 @@
+"use strict";
+/**
+ * StructureRecorder — passive observer of BUILD-TIME chart construction events.
+ *
+ * The build-time twin of `FlowRecorder`. Where `FlowRecorder` observes
+ * RUNTIME control-flow transitions (per-execution `runtimeStageId`,
+ * iteration counts, errors, pauses), `StructureRecorder` observes
+ * STATIC chart shape as it's assembled by the builder — every spec
+ * node added, every outgoing edge wired, every decider closed.
+ *
+ * Why two interfaces, not one
+ * ───────────────────────────
+ *   Build and runtime events have different INVARIANTS, not just
+ *   different timing:
+ *
+ *     - Runtime events carry `runtimeStageId` (`[subflowPath/]stageId#N`),
+ *       `iteration`, `traversalContext` — load-bearing for time-travel
+ *       UIs, commit-log indices, and `SequenceRecorder<T>` consumers.
+ *       NONE of these exist at build time.
+ *
+ *     - Build events carry only `stageId` + structural fields. No
+ *       execution index, no iteration, no snapshot.
+ *
+ *     - Some events have no analog across phases: `onPause` /
+ *       `onResume` / `onError` / `onRunStart` are runtime-only;
+ *       `onDeciderComplete` / `onStageAdded` are build-only.
+ *
+ *   A single `FlowRecorder` with `phase: 'static' | 'dynamic'`
+ *   discriminator would force every consumer to write
+ *   `if (e.phase === 'static') ...` branches and would erase the
+ *   least-privilege boundary (a static-only consumer should NOT
+ *   accidentally observe runtime data — e.g., a public docs site
+ *   rendering chart topology must not see scope values).
+ *
+ *   Two interfaces, same mental model, clean separation. Two
+ *   registration sites ship today (pick whichever fits your call
+ *   site):
+ *
+ *     1. **Options-bag** (preferred when the recorder set is known
+ *        at construction time — registers BEFORE `start()` so even
+ *        the seed event fires through the normal dispatcher fan-out):
+ *        ```ts
+ *        flowChart('seed', fn, 'seed', { structureRecorders: [rec] })
+ *          .addFunction('a', fnA, 'a').build();
+ *        ```
+ *
+ *     2. **Fluent** (preferred when attach is conditional, late, or
+ *        in a chain builder — the just-attached recorder gets a
+ *        one-time seed replay so it observes the root stage):
+ *        ```ts
+ *        flowChart('seed', fn, 'seed')
+ *          .attachStructureRecorder(rec)
+ *          .addFunction('a', fnA, 'a').build();
+ *        ```
+ *
+ *   Both deliver the same event stream to the same recorder. See the
+ *   `@example` block below for a fully-fleshed-out implementation.
+ *
+ * Lifecycle + ordering invariants
+ * ───────────────────────────────
+ *   - Fires SYNCHRONOUSLY during builder chain calls (and during
+ *     `.build()` for the terminal node) at the natural moment each
+ *     spec mutation completes.
+ *   - `onStageAdded(A)` and `onStageAdded(B)` fire BEFORE any
+ *     `onEdgeAdded({from: A, to: B})` — endpoint registration
+ *     happens before edge wiring.
+ *   - `onDeciderComplete(D)` fires at sub-builder `.end()` time, AFTER
+ *     every child's `onStageAdded` and every `onEdgeAdded({from: D,
+ *     to: child})`. Marks the decider as no-further-mutation.
+ *   - `onSubflowMounted({subflowId})` fires once per mount.
+ *     **MOUNT-ONLY**: parent recorders do NOT receive a replay of
+ *     the subflow's own internal structure events (those fired
+ *     during the subflow's own `.build()`). Matches the runtime
+ *     `onSubflowEntry` semantics — composition over replay.
+ *
+ * Error isolation (matches FlowRecorder contract)
+ * ───────────────────────────────────────────────
+ *   - A throwing handler is caught, logged via `isDevMode()` warning,
+ *     and accumulated on `builder.getStructureBuildErrors()` for
+ *     post-hoc inspection.
+ *   - Subsequent recorders + subsequent events fire normally; one
+ *     misbehaving recorder cannot THROW its way into blocking
+ *     construction.
+ *   - The errors[] accumulator is soft-capped (~100 entries) with a
+ *     `__truncated__` sentinel record once the cap is hit, to prevent
+ *     unbounded growth on chatty broken recorders.
+ *   - Note: throw isolation does NOT defend against a handler that
+ *     succeeds at runtime but mutates `event.spec` to corrupt the
+ *     chart. See "Spec mutation" below.
+ *
+ * Spec mutation — readonly-by-contract (NOT runtime-enforced)
+ * ────────────────────────────────────────────────────────────
+ *   - Event payloads pass spec references where useful (e.g., `spec`
+ *     on `onStageAdded`). Every field on every event payload is
+ *     marked `readonly` in TypeScript — the type system signals
+ *     consumer intent at author time.
+ *   - There is NO runtime freeze. The builder fires `onStageAdded`
+ *     IMMEDIATELY when a spec node is added, BEFORE the builder
+ *     wires that node's `.next`/`.children`/`.loopTarget` in the
+ *     subsequent `addX` call. Freezing here would break the
+ *     builder's own subsequent mutation.
+ *   - Handler mutation of `event.spec` is DOCUMENTED UNDEFINED
+ *     BEHAVIOR — it will succeed at runtime, but is not supported
+ *     and downstream consumers may break. Specifically, mutating
+ *     `event.spec.fn`, `event.spec.id`, or `event.spec.children`
+ *     can corrupt subsequent runtime behavior of the chart.
+ *   - **Trust model**: attach ONLY recorders from trusted code paths.
+ *     A hostile or buggy recorder can effectively substitute stage
+ *     functions or rewire the chart structure. The `readonly`
+ *     markers cannot defend against intentional mutation.
+ *
+ * @example
+ * ```ts
+ * class TraceStructureRecorder implements StructureRecorder {
+ *   readonly id = 'trace-static';
+ *   nodes: XyflowNode[] = [];
+ *   edges: XyflowEdge[] = [];
+ *
+ *   onStageAdded(e) {
+ *     // Node role: 'stage' is the initial type. If outgoing edges
+ *     // arrive with kind 'fork-branch' / 'decision-branch' the node
+ *     // is functioning as a fork/decider — derive the visual style
+ *     // from those edges, not from `e.type` alone.
+ *     this.nodes.push({ id: e.stageId, type: 'lensStage', data: { label: e.name } });
+ *   }
+ *   onEdgeAdded(e) {
+ *     this.edges.push({ id: `${e.from}->${e.to}`, source: e.from, target: e.to });
+ *   }
+ *   onSubflowMounted(e) {
+ *     this.nodes.push({ id: e.subflowId, type: 'subflow', data: { label: e.subflowName } });
+ *   }
+ *   onDeciderComplete(e) {
+ *     // Optional: finalize node styling now that branch list is sealed.
+ *   }
+ * }
+ *
+ * // Registration option A — options-bag (preferred when recorders
+ * // are known up front; attaches BEFORE the seed event fires):
+ * const rec = new TraceStructureRecorder();
+ * const builder = flowChart('seed', fn, 'seed', {
+ *   structureRecorders: [rec],
+ * }).addFunction('a', fnA, 'a');
+ * const chart = builder.build();
+ *
+ * // Registration option B — fluent chain (preferred for conditional
+ * // or late attach; the just-attached recorder gets a seed replay):
+ * const rec2 = new TraceStructureRecorder();
+ * const builder2 = flowChart('seed', fn, 'seed')
+ *   .attachStructureRecorder(rec2)
+ *   .addFunction('a', fnA, 'a');
+ *
+ * // Inspect any recorder errors (call on the BUILDER, not the chart):
+ * const errors = builder.getStructureBuildErrors();
+ *
+ * <ReactFlow nodes={rec.nodes} edges={rec.edges} />
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"StructureRecorder.js","sourceRoot":"","sources":["../../../../src/lib/builder/structure/StructureRecorder.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2JG","sourcesContent":["/**\n * StructureRecorder — passive observer of BUILD-TIME chart construction events.\n *\n * The build-time twin of `FlowRecorder`. Where `FlowRecorder` observes\n * RUNTIME control-flow transitions (per-execution `runtimeStageId`,\n * iteration counts, errors, pauses), `StructureRecorder` observes\n * STATIC chart shape as it's assembled by the builder — every spec\n * node added, every outgoing edge wired, every decider closed.\n *\n * Why two interfaces, not one\n * ───────────────────────────\n *   Build and runtime events have different INVARIANTS, not just\n *   different timing:\n *\n *     - Runtime events carry `runtimeStageId` (`[subflowPath/]stageId#N`),\n *       `iteration`, `traversalContext` — load-bearing for time-travel\n *       UIs, commit-log indices, and `SequenceRecorder<T>` consumers.\n *       NONE of these exist at build time.\n *\n *     - Build events carry only `stageId` + structural fields. No\n *       execution index, no iteration, no snapshot.\n *\n *     - Some events have no analog across phases: `onPause` /\n *       `onResume` / `onError` / `onRunStart` are runtime-only;\n *       `onDeciderComplete` / `onStageAdded` are build-only.\n *\n *   A single `FlowRecorder` with `phase: 'static' | 'dynamic'`\n *   discriminator would force every consumer to write\n *   `if (e.phase === 'static') ...` branches and would erase the\n *   least-privilege boundary (a static-only consumer should NOT\n *   accidentally observe runtime data — e.g., a public docs site\n *   rendering chart topology must not see scope values).\n *\n *   Two interfaces, same mental model, clean separation. Two\n *   registration sites ship today (pick whichever fits your call\n *   site):\n *\n *     1. **Options-bag** (preferred when the recorder set is known\n *        at construction time — registers BEFORE `start()` so even\n *        the seed event fires through the normal dispatcher fan-out):\n *        ```ts\n *        flowChart('seed', fn, 'seed', { structureRecorders: [rec] })\n *          .addFunction('a', fnA, 'a').build();\n *        ```\n *\n *     2. **Fluent** (preferred when attach is conditional, late, or\n *        in a chain builder — the just-attached recorder gets a\n *        one-time seed replay so it observes the root stage):\n *        ```ts\n *        flowChart('seed', fn, 'seed')\n *          .attachStructureRecorder(rec)\n *          .addFunction('a', fnA, 'a').build();\n *        ```\n *\n *   Both deliver the same event stream to the same recorder. See the\n *   `@example` block below for a fully-fleshed-out implementation.\n *\n * Lifecycle + ordering invariants\n * ───────────────────────────────\n *   - Fires SYNCHRONOUSLY during builder chain calls (and during\n *     `.build()` for the terminal node) at the natural moment each\n *     spec mutation completes.\n *   - `onStageAdded(A)` and `onStageAdded(B)` fire BEFORE any\n *     `onEdgeAdded({from: A, to: B})` — endpoint registration\n *     happens before edge wiring.\n *   - `onDeciderComplete(D)` fires at sub-builder `.end()` time, AFTER\n *     every child's `onStageAdded` and every `onEdgeAdded({from: D,\n *     to: child})`. Marks the decider as no-further-mutation.\n *   - `onSubflowMounted({subflowId})` fires once per mount.\n *     **MOUNT-ONLY**: parent recorders do NOT receive a replay of\n *     the subflow's own internal structure events (those fired\n *     during the subflow's own `.build()`). Matches the runtime\n *     `onSubflowEntry` semantics — composition over replay.\n *\n * Error isolation (matches FlowRecorder contract)\n * ───────────────────────────────────────────────\n *   - A throwing handler is caught, logged via `isDevMode()` warning,\n *     and accumulated on `builder.getStructureBuildErrors()` for\n *     post-hoc inspection.\n *   - Subsequent recorders + subsequent events fire normally; one\n *     misbehaving recorder cannot THROW its way into blocking\n *     construction.\n *   - The errors[] accumulator is soft-capped (~100 entries) with a\n *     `__truncated__` sentinel record once the cap is hit, to prevent\n *     unbounded growth on chatty broken recorders.\n *   - Note: throw isolation does NOT defend against a handler that\n *     succeeds at runtime but mutates `event.spec` to corrupt the\n *     chart. See \"Spec mutation\" below.\n *\n * Spec mutation — readonly-by-contract (NOT runtime-enforced)\n * ────────────────────────────────────────────────────────────\n *   - Event payloads pass spec references where useful (e.g., `spec`\n *     on `onStageAdded`). Every field on every event payload is\n *     marked `readonly` in TypeScript — the type system signals\n *     consumer intent at author time.\n *   - There is NO runtime freeze. The builder fires `onStageAdded`\n *     IMMEDIATELY when a spec node is added, BEFORE the builder\n *     wires that node's `.next`/`.children`/`.loopTarget` in the\n *     subsequent `addX` call. Freezing here would break the\n *     builder's own subsequent mutation.\n *   - Handler mutation of `event.spec` is DOCUMENTED UNDEFINED\n *     BEHAVIOR — it will succeed at runtime, but is not supported\n *     and downstream consumers may break. Specifically, mutating\n *     `event.spec.fn`, `event.spec.id`, or `event.spec.children`\n *     can corrupt subsequent runtime behavior of the chart.\n *   - **Trust model**: attach ONLY recorders from trusted code paths.\n *     A hostile or buggy recorder can effectively substitute stage\n *     functions or rewire the chart structure. The `readonly`\n *     markers cannot defend against intentional mutation.\n *\n * @example\n * ```ts\n * class TraceStructureRecorder implements StructureRecorder {\n *   readonly id = 'trace-static';\n *   nodes: XyflowNode[] = [];\n *   edges: XyflowEdge[] = [];\n *\n *   onStageAdded(e) {\n *     // Node role: 'stage' is the initial type. If outgoing edges\n *     // arrive with kind 'fork-branch' / 'decision-branch' the node\n *     // is functioning as a fork/decider — derive the visual style\n *     // from those edges, not from `e.type` alone.\n *     this.nodes.push({ id: e.stageId, type: 'lensStage', data: { label: e.name } });\n *   }\n *   onEdgeAdded(e) {\n *     this.edges.push({ id: `${e.from}->${e.to}`, source: e.from, target: e.to });\n *   }\n *   onSubflowMounted(e) {\n *     this.nodes.push({ id: e.subflowId, type: 'subflow', data: { label: e.subflowName } });\n *   }\n *   onDeciderComplete(e) {\n *     // Optional: finalize node styling now that branch list is sealed.\n *   }\n * }\n *\n * // Registration option A — options-bag (preferred when recorders\n * // are known up front; attaches BEFORE the seed event fires):\n * const rec = new TraceStructureRecorder();\n * const builder = flowChart('seed', fn, 'seed', {\n *   structureRecorders: [rec],\n * }).addFunction('a', fnA, 'a');\n * const chart = builder.build();\n *\n * // Registration option B — fluent chain (preferred for conditional\n * // or late attach; the just-attached recorder gets a seed replay):\n * const rec2 = new TraceStructureRecorder();\n * const builder2 = flowChart('seed', fn, 'seed')\n *   .attachStructureRecorder(rec2)\n *   .addFunction('a', fnA, 'a');\n *\n * // Inspect any recorder errors (call on the BUILDER, not the chart):\n * const errors = builder.getStructureBuildErrors();\n *\n * <ReactFlow nodes={rec.nodes} edges={rec.edges} />\n * ```\n */\n\nimport type { FlowChartSpec, SerializedPipelineStructure } from '../types.js';\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Event payload types\n// ─────────────────────────────────────────────────────────────────────────────\n\n/**\n * Event payload for `StructureRecorder.onStageAdded`. Fires for every\n * spec node added to the chart, including the seed (added via\n * `flowChart()` factory) and subflow mount nodes. Excludes synthetic\n * loop-reference nodes (those carry `isLoopReference: true` on the\n * spec; consumers see them via the separate `onLoopEdgeAdded` event\n * instead of as fresh stages).\n */\nexport interface StructureStageAddedEvent {\n  /**\n   * Stable identifier for this node. AT EVENT FIRE TIME this is the\n   * builder's LOCAL form (no subflow prefix — the prefix is applied\n   * later by `_prefixNodeTree` when this builder is mounted as a\n   * subflow into a parent).\n   *\n   * Note: `spec.id` is a LIVE reference. If you read it AFTER this\n   * chart has been mounted as a subflow, it may have been rewritten\n   * to the FULL prefixed form. Use `splitStageId(spec.id)` from\n   * `footprintjs/trace` to decompose it back into local + subflowPath.\n   *\n   * Correlating with runtime events:\n   *   - Same builder (no mount) →\n   *     `event.stageId === parseRuntimeStageId(runtime).stageId`\n   *   - This builder mounted as subflow → use `splitStageId` on the\n   *     prefixed form (or `parseRuntimeStageId` on the full\n   *     runtimeStageId) before comparing.\n   */\n  readonly stageId: string;\n  /** Human-readable label for the node. */\n  readonly name: string;\n  /** Spec node `type`. Lets recorders branch on stage vs decider vs\n   *  fork vs subflow without re-deriving from other fields. */\n  readonly type: NonNullable<FlowChartSpec['type']>;\n  /** True for nodes added via `addPausableFunction()` — useful for\n   *  visualisers that want to mark stages that can pause execution. */\n  readonly isPausable?: boolean;\n  /** Live reference to the full spec node, for handlers that want\n   *  details beyond the discriminator fields above. MUST NOT be\n   *  mutated by the handler — readonly is type-level intent; no\n   *  runtime freeze. See \"Spec mutation\" in the file header for the\n   *  trust-model caveats. */\n  readonly spec: FlowChartSpec;\n}\n\n/** Edge kinds the builder produces at structural time. Matches the\n *  footprintjs control-flow vocabulary used at runtime.\n *\n *  Why no `subflow-entry` here: subflow mounts use the lifecycle\n *  event `onSubflowMounted` (not an edge event). If a future use case\n *  needs the parent→subflow-root edge as a distinct kind, it'll be\n *  added then — YAGNI now (Panel 3, L7.2 review). */\nexport type StructureEdgeKind =\n  | 'next' // linear chain: prev.next = curr\n  | 'fork-branch' // fork parent → parallel child\n  | 'decision-branch'; // decider → branch child\n\n/**\n * Event payload for `StructureRecorder.onEdgeAdded`. Fires whenever\n * the builder wires an outgoing edge from one node to another. Both\n * endpoints have already been announced via `onStageAdded` by the\n * time this fires.\n *\n * Loop back-edges have their OWN event (`onLoopEdgeAdded`) so\n * consumers can theme them distinctly and so build-time events stay\n * free of the runtime-only `iteration` field.\n */\nexport interface StructureEdgeAddedEvent {\n  readonly from: string;\n  readonly to: string;\n  readonly kind: StructureEdgeKind;\n  /** Optional human-readable label — used today for decider branch\n   *  keys (e.g., `'low'`, `'high'`, `'high (default)'`) and parallel\n   *  branch ids. */\n  readonly label?: string;\n}\n\n/**\n * Event payload for `StructureRecorder.onLoopEdgeAdded`. Fires when\n * `.loopTo(target)` installs a back-edge. Distinct from\n * `onEdgeAdded` so consumers can theme back-edges differently and\n * because runtime `onLoop` carries `iteration: number` which has no\n * build-time meaning — keeping the events separated avoids forcing\n * an `iteration?: number` lie into the structural shape.\n */\nexport interface StructureLoopEdgeAddedEvent {\n  readonly from: string;\n  readonly to: string;\n}\n\n/**\n * Event payload for `StructureRecorder.onDeciderComplete`. Fires\n * when a decider / selector sub-builder closes via `.end()`. By the\n * time this fires every branch has been announced and the\n * `defaultBranch` (if set via `.setDefault()`) is final. Lets\n * recorders treat the decider as no-further-mutation and snapshot\n * its branch list as final.\n */\nexport interface StructureDeciderCompleteEvent {\n  /** Decider / selector stage id. */\n  readonly decider: string;\n  /** Spec type (`'decider'` vs `'selector'`) — exposed so consumers\n   *  don't need to look up the original `onStageAdded` event. */\n  readonly type: 'decider' | 'selector';\n  /** Branch member ids in declaration order. */\n  readonly branchIds: readonly string[];\n  /** Default branch id when set via `.setDefault()`; undefined when\n   *  no default is configured (e.g., selectors). */\n  readonly defaultBranch?: string;\n}\n\n/**\n * Event payload for `StructureRecorder.onSubflowMounted`. Fires once\n * per subflow mount (`addSubFlowChart` / `addSubFlowChartNext` and\n * their lazy variants).\n *\n * **MOUNT-ONLY semantics** — the subflow's OWN structure events\n * (every `onStageAdded` / `onEdgeAdded` inside the subflow) fired\n * during the subflow's own `.build()`, before the mount. Parent\n * recorders do NOT receive a replay. Instead, this event delivers\n * the subflow's full structure via `subflowSpec`, and consumers can\n * walk it via `walkSubflowSpec` from `footprintjs/trace`.\n *\n * This matches `FlowRecorder.onSubflowEntry` semantics at runtime\n * (parents see the boundary, not a replay of internals) and\n * preserves the \"one purpose per recorder\" convention.\n */\nexport interface StructureSubflowMountedEvent {\n  /** Subflow identifier the parent assigned at mount. */\n  readonly subflowId: string;\n  /** Human-readable subflow name. */\n  readonly subflowName: string;\n  /** Mount node id in the parent's chart. */\n  readonly rootStageId: string;\n  /** True when the mount uses lazy resolution (deferred subflow\n   *  resolution until execution). */\n  readonly isLazy?: boolean;\n\n  /**\n   * The mounted subflow's complete spec — the SAME OBJECT\n   * (=== reference equality) reachable via `subflow.buildTimeStructure`\n   * for the FlowChart the consumer passed to `addSubFlowChartBranch` /\n   * `addSubFlowChart` / `addSubFlowChartNext`.\n   *\n   * UNDEFINED for lazy mounts at build time (`isLazy: true`) — the\n   * subflow's structure hasn't been resolved yet. Consumers waiting on\n   * lazy subflows handle the runtime `onSubflowEntry` event instead.\n   *\n   * Immutable post-build; consumers MUST NOT mutate.\n   *\n   * @internal `SerializedPipelineStructure` is library-internal.\n   *           Use `walkSubflowSpec` from `footprintjs/trace` for the\n   *           stable public contract.\n   */\n  readonly subflowSpec?: SerializedPipelineStructure;\n\n  /**\n   * Local mount id of this subflow within its parent — equal to\n   * `subflowId` for top-level mounts (e.g. `'auth'`), composed\n   * (`'auth/verify'`) for nested mounts whose recorder is attached\n   * to the grandparent. Matches runtime `traversalContext.subflowPath`\n   * semantics — NEVER prefixed with `__root__/`.\n   */\n  readonly subflowPath: string;\n}\n\n// ─────────────────────────────────────────────────────────────────────────────\n// StructureRecorder interface\n// ─────────────────────────────────────────────────────────────────────────────\n\n/**\n * Pluggable observer for BUILD-TIME chart construction events.\n *\n * All methods are optional — implement only the hooks you need.\n * Handlers fire SYNCHRONOUSLY during builder operations and `.build()`.\n * A throwing handler is caught (see \"Error isolation\" in the file\n * header); subsequent dispatch continues.\n *\n * Lifecycle: each `StructureRecorder` instance is registered via\n * EITHER the `flowChart()` options bag (`{ structureRecorders: [rec] }`)\n * OR the fluent `.attachStructureRecorder(rec)` chain — see the file\n * header for the trade-offs. Registration after `.build()` is\n * rejected (chart is sealed).\n */\nexport interface StructureRecorder {\n  /**\n   * Stable identifier — used by the dispatcher to scope error\n   * messages and to support `detach(id)` lookup.\n   *\n   * Convention (matches `FlowRecorder.id` from CLAUDE.md):\n   *   - domain-prefixed kebab-case (`'lens-structure'`,\n   *     `'agentfootprint-composition'`, `'trace-explainable'`)\n   *   - same id → multiple recorders coexist (NOT deduplicated by\n   *     id; the dispatcher fires every attached recorder regardless)\n   *   - `detach(id)` removes EVERY recorder with that id — be\n   *     intentional about reuse if you rely on selective detach\n   *\n   * Choose a stable id at module load and don't randomise it across\n   * runs — it lands in `StructureBuildError.recorderId` so debug\n   * output is greppable.\n   */\n  readonly id: string;\n\n  onStageAdded?(event: StructureStageAddedEvent): void;\n  onEdgeAdded?(event: StructureEdgeAddedEvent): void;\n  onLoopEdgeAdded?(event: StructureLoopEdgeAddedEvent): void;\n  onDeciderComplete?(event: StructureDeciderCompleteEvent): void;\n  onSubflowMounted?(event: StructureSubflowMountedEvent): void;\n}\n"]}

package/dist/lib/builder/structure/StructureRecorderDispatcher.js

@@ -0,0 +1,175 @@
+"use strict";
+/**
+ * StructureRecorderDispatcher — Fans build-time structure events out to N
+ * attached `StructureRecorder` instances.
+ *
+ * Mirrors `FlowRecorderDispatcher` (engine/narrative/) exactly:
+ *
+ *   - `recorders: StructureRecorder[]` — attach order preserved
+ *   - per-event fire methods early-return when no recorders attached
+ *     (zero-allocation fast path)
+ *   - per-recorder try/catch isolates errors; one bad recorder cannot
+ *     cascade into the chain build or sibling recorders
+ *   - errors route to BOTH the dev-mode console warning (matches
+ *     FlowRecorderDispatcher) AND a structured `buildErrors`
+ *     accumulator so consumers can inspect failures post-build
+ *   - spec payloads are NOT frozen at dispatch time — handlers must
+ *     respect the `readonly` markers on event payload types (the
+ *     builder still needs to mutate `spec.next` after the immediate
+ *     `onStageAdded` fires; see `fireStageAdded` for the full note,
+ *     and `StructureRecorder.ts` header "Spec mutation" for the
+ *     trust-model implications)
+ *
+ * The dispatcher itself owns NO chart state. The builder owns the
+ * dispatcher; events fire from the natural mutation points in
+ * FlowChartBuilder (L7.3).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StructureRecorderDispatcher = void 0;
+const detectCircular_js_1 = require("../../scope/detectCircular.js");
+/**
+ * Soft cap on the `errors[]` accumulator. Builds with thousands of
+ * stages and a misbehaving recorder that throws on every event would
+ * otherwise retain unbounded `{recorderId, method, message, error}`
+ * records — each closing over the thrown value (often an Error with
+ * a captured stack), preventing GC of any closure data the throw
+ * captured. The cap is for diagnosis, not forensic completeness;
+ * once exceeded, a single sentinel record signals truncation.
+ */
+const STRUCTURE_BUILD_ERRORS_CAP = 100;
+class StructureRecorderDispatcher {
+    recorders = [];
+    errors = [];
+    _truncated = false;
+    /** Attach a `StructureRecorder`. Multiple recorders with the same
+     *  id are allowed; the convention is one id per logical concern. */
+    attach(recorder) {
+        this.recorders.push(recorder);
+    }
+    /** Detach every recorder with the given id. */
+    detach(id) {
+        this.recorders = this.recorders.filter((r) => r.id !== id);
+    }
+    /** Defensive copy of the attached recorders — used in tests + by
+     *  tooling that wants to inspect what's registered. */
+    getRecorders() {
+        return [...this.recorders];
+    }
+    /** Find one recorder by id. */
+    getRecorderById(id) {
+        return this.recorders.find((r) => r.id === id);
+    }
+    /** Read accumulated errors from this build. Returns a defensive copy. */
+    getErrors() {
+        return [...this.errors];
+    }
+    // ── fire* methods — called by the builder at each event moment ─────
+    fireStageAdded(event) {
+        if (this.recorders.length === 0)
+            return;
+        // NOTE: `event.spec` is NOT frozen here. `onStageAdded` fires
+        // IMMEDIATELY when a spec node is added — the builder still needs
+        // to mutate `spec.next` later (in the subsequent `addX` call).
+        // Freezing here would break the builder. Handler mutation of
+        // `event.spec` is documented as undefined behavior — see the
+        // StructureRecorder type's JSDoc + readonly markers on the
+        // event payload interface.
+        for (const r of this.recorders) {
+            try {
+                r.onStageAdded?.(event);
+            }
+            catch (err) {
+                this.recordError(r.id, 'onStageAdded', err);
+            }
+        }
+    }
+    fireEdgeAdded(event) {
+        if (this.recorders.length === 0)
+            return;
+        // No spec on this event — pass through.
+        for (const r of this.recorders) {
+            try {
+                r.onEdgeAdded?.(event);
+            }
+            catch (err) {
+                this.recordError(r.id, 'onEdgeAdded', err);
+            }
+        }
+    }
+    fireLoopEdgeAdded(event) {
+        if (this.recorders.length === 0)
+            return;
+        for (const r of this.recorders) {
+            try {
+                r.onLoopEdgeAdded?.(event);
+            }
+            catch (err) {
+                this.recordError(r.id, 'onLoopEdgeAdded', err);
+            }
+        }
+    }
+    fireDeciderComplete(event) {
+        if (this.recorders.length === 0)
+            return;
+        for (const r of this.recorders) {
+            try {
+                r.onDeciderComplete?.(event);
+            }
+            catch (err) {
+                this.recordError(r.id, 'onDeciderComplete', err);
+            }
+        }
+    }
+    fireSubflowMounted(event) {
+        if (this.recorders.length === 0)
+            return;
+        for (const r of this.recorders) {
+            try {
+                r.onSubflowMounted?.(event);
+            }
+            catch (err) {
+                this.recordError(r.id, 'onSubflowMounted', err);
+            }
+        }
+    }
+    /**
+     * Externally-callable error capture for events the builder fires
+     * OUTSIDE the normal fire* fan-out path — specifically the seed
+     * replay in `FlowChartBuilder.attachStructureRecorder()`, which
+     * targets one specific recorder rather than every attached recorder.
+     *
+     * Same observability contract as the internal `recordError`:
+     * accumulates on `getErrors()` AND logs in dev mode.
+     */
+    recordErrorForReplay(recorderId, method, err) {
+        this.recordError(recorderId, method, err);
+    }
+    // ── Internals ───────────────────────────────────────────────────────
+    recordError(recorderId, method, err) {
+        const e = err;
+        const message = typeof e?.message === 'string' ? e.message : String(err);
+        // Soft cap to prevent unbounded growth + closure retention. Once
+        // hit, push a single sentinel describing the truncation and drop
+        // further records on the floor (still log in dev mode so the
+        // consumer notices the spam at its source).
+        if (this.errors.length < STRUCTURE_BUILD_ERRORS_CAP) {
+            this.errors.push({ recorderId, method, message, error: err });
+        }
+        else if (!this._truncated) {
+            this._truncated = true;
+            this.errors.push({
+                recorderId: '__truncated__',
+                method: '__truncated__',
+                message: `StructureRecorderDispatcher: error accumulator truncated at ${STRUCTURE_BUILD_ERRORS_CAP} entries; further errors suppressed.`,
+                error: null,
+            });
+        }
+        if ((0, detectCircular_js_1.isDevMode)()) {
+            // eslint-disable-next-line no-console
+            console.warn(`[footprint] StructureRecorderDispatcher: recorder "${recorderId}" threw in ${method}: ${message}. ` +
+                'See builder.getStructureBuildErrors() for the full list.');
+        }
+    }
+}
+exports.StructureRecorderDispatcher = StructureRecorderDispatcher;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"StructureRecorderDispatcher.js","sourceRoot":"","sources":["../../../../src/lib/builder/structure/StructureRecorderDispatcher.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;;;AAEH,qEAA0D;AA2B1D;;;;;;;;GAQG;AACH,MAAM,0BAA0B,GAAG,GAAG,CAAC;AAEvC,MAAa,2BAA2B;IAC9B,SAAS,GAAwB,EAAE,CAAC;IAC3B,MAAM,GAA0B,EAAE,CAAC;IAC5C,UAAU,GAAG,KAAK,CAAC;IAE3B;wEACoE;IACpE,MAAM,CAAC,QAA2B;QAChC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;IAChC,CAAC;IAED,+CAA+C;IAC/C,MAAM,CAAC,EAAU;QACf,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC;IAC7D,CAAC;IAED;2DACuD;IACvD,YAAY;QACV,OAAO,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC;IAC7B,CAAC;IAED,+BAA+B;IAC/B,eAAe,CAAkD,EAAU;QACzE,OAAO,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,CAAkB,CAAC;IAClE,CAAC;IAED,yEAAyE;IACzE,SAAS;QACP,OAAO,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC;IAC1B,CAAC;IAED,sEAAsE;IAEtE,cAAc,CAAC,KAA+B;QAC5C,IAAI,IAAI,CAAC,SAAS,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO;QACxC,8DAA8D;QAC9D,kEAAkE;QAClE,+DAA+D;QAC/D,6DAA6D;QAC7D,6DAA6D;QAC7D,2DAA2D;QAC3D,2BAA2B;QAC3B,KAAK,MAAM,CAAC,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;YAC/B,IAAI,CAAC;gBACH,CAAC,CAAC,YAAY,EAAE,CAAC,KAAK,CAAC,CAAC;YAC1B,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACb,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,EAAE,cAAc,EAAE,GAAG,CAAC,CAAC;YAC9C,CAAC;QACH,CAAC;IACH,CAAC;IAED,aAAa,CAAC,KAA8B;QAC1C,IAAI,IAAI,CAAC,SAAS,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO;QACxC,wCAAwC;QACxC,KAAK,MAAM,CAAC,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;YAC/B,IAAI,CAAC;gBACH,CAAC,CAAC,WAAW,EAAE,CAAC,KAAK,CAAC,CAAC;YACzB,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACb,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,EAAE,aAAa,EAAE,GAAG,CAAC,CAAC;YAC7C,CAAC;QACH,CAAC;IACH,CAAC;IAED,iBAAiB,CAAC,KAAkC;QAClD,IAAI,IAAI,CAAC,SAAS,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO;QACxC,KAAK,MAAM,CAAC,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;YAC/B,IAAI,CAAC;gBACH,CAAC,CAAC,eAAe,EAAE,CAAC,KAAK,CAAC,CAAC;YAC7B,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACb,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,EAAE,iBAAiB,EAAE,GAAG,CAAC,CAAC;YACjD,CAAC;QACH,CAAC;IACH,CAAC;IAED,mBAAmB,CAAC,KAAoC;QACtD,IAAI,IAAI,CAAC,SAAS,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO;QACxC,KAAK,MAAM,CAAC,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;YAC/B,IAAI,CAAC;gBACH,CAAC,CAAC,iBAAiB,EAAE,CAAC,KAAK,CAAC,CAAC;YAC/B,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACb,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,EAAE,mBAAmB,EAAE,GAAG,CAAC,CAAC;YACnD,CAAC;QACH,CAAC;IACH,CAAC;IAED,kBAAkB,CAAC,KAAmC;QACpD,IAAI,IAAI,CAAC,SAAS,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO;QACxC,KAAK,MAAM,CAAC,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;YAC/B,IAAI,CAAC;gBACH,CAAC,CAAC,gBAAgB,EAAE,CAAC,KAAK,CAAC,CAAC;YAC9B,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACb,IAAI,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,EAAE,kBAAkB,EAAE,GAAG,CAAC,CAAC;YAClD,CAAC;QACH,CAAC;IACH,CAAC;IAED;;;;;;;;OAQG;IACH,oBAAoB,CAAC,UAAkB,EAAE,MAAc,EAAE,GAAY;QACnE,IAAI,CAAC,WAAW,CAAC,UAAU,EAAE,MAAM,EAAE,GAAG,CAAC,CAAC;IAC5C,CAAC;IAED,uEAAuE;IAE/D,WAAW,CAAC,UAAkB,EAAE,MAAc,EAAE,GAAY;QAClE,MAAM,CAAC,GAAG,GAAwC,CAAC;QACnD,MAAM,OAAO,GAAG,OAAO,CAAC,EAAE,OAAO,KAAK,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;QACzE,iEAAiE;QACjE,iEAAiE;QACjE,6DAA6D;QAC7D,4CAA4C;QAC5C,IAAI,IAAI,CAAC,MAAM,CAAC,MAAM,GAAG,0BAA0B,EAAE,CAAC;YACpD,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,GAAG,EAAE,CAAC,CAAC;QAChE,CAAC;aAAM,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,CAAC;YAC5B,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;YACvB,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC;gBACf,UAAU,EAAE,eAAe;gBAC3B,MAAM,EAAE,eAAe;gBACvB,OAAO,EAAE,+DAA+D,0BAA0B,sCAAsC;gBACxI,KAAK,EAAE,IAAI;aACZ,CAAC,CAAC;QACL,CAAC;QACD,IAAI,IAAA,6BAAS,GAAE,EAAE,CAAC;YAChB,sCAAsC;YACtC,OAAO,CAAC,IAAI,CACV,sDAAsD,UAAU,cAAc,MAAM,KAAK,OAAO,IAAI;gBAClG,0DAA0D,CAC7D,CAAC;QACJ,CAAC;IACH,CAAC;CACF;AA1ID,kEA0IC","sourcesContent":["/**\n * StructureRecorderDispatcher — Fans build-time structure events out to N\n * attached `StructureRecorder` instances.\n *\n * Mirrors `FlowRecorderDispatcher` (engine/narrative/) exactly:\n *\n *   - `recorders: StructureRecorder[]` — attach order preserved\n *   - per-event fire methods early-return when no recorders attached\n *     (zero-allocation fast path)\n *   - per-recorder try/catch isolates errors; one bad recorder cannot\n *     cascade into the chain build or sibling recorders\n *   - errors route to BOTH the dev-mode console warning (matches\n *     FlowRecorderDispatcher) AND a structured `buildErrors`\n *     accumulator so consumers can inspect failures post-build\n *   - spec payloads are NOT frozen at dispatch time — handlers must\n *     respect the `readonly` markers on event payload types (the\n *     builder still needs to mutate `spec.next` after the immediate\n *     `onStageAdded` fires; see `fireStageAdded` for the full note,\n *     and `StructureRecorder.ts` header \"Spec mutation\" for the\n *     trust-model implications)\n *\n * The dispatcher itself owns NO chart state. The builder owns the\n * dispatcher; events fire from the natural mutation points in\n * FlowChartBuilder (L7.3).\n */\n\nimport { isDevMode } from '../../scope/detectCircular.js';\nimport type { FlowChartSpec } from '../types.js';\nimport type {\n  StructureDeciderCompleteEvent,\n  StructureEdgeAddedEvent,\n  StructureLoopEdgeAddedEvent,\n  StructureRecorder,\n  StructureStageAddedEvent,\n  StructureSubflowMountedEvent,\n} from './StructureRecorder.js';\n\n/** Structured error captured when a recorder throws. Read post-build\n *  via `builder.getStructureBuildErrors()` — call on the BUILDER\n *  reference (NOT the chart returned by `.build()`). Capture the\n *  builder reference before `.build()` if you need post-build access. */\nexport interface StructureBuildError {\n  /** Which recorder's handler threw. */\n  readonly recorderId: string;\n  /** Which event method (`'onStageAdded'`, `'onEdgeAdded'`, ...). */\n  readonly method: string;\n  /** Error message extracted from the thrown value. */\n  readonly message: string;\n  /** The original thrown value — `Error` instance or whatever the\n   *  recorder threw. Useful when diagnosis needs a stack trace. */\n  readonly error: unknown;\n}\n\n/**\n * Soft cap on the `errors[]` accumulator. Builds with thousands of\n * stages and a misbehaving recorder that throws on every event would\n * otherwise retain unbounded `{recorderId, method, message, error}`\n * records — each closing over the thrown value (often an Error with\n * a captured stack), preventing GC of any closure data the throw\n * captured. The cap is for diagnosis, not forensic completeness;\n * once exceeded, a single sentinel record signals truncation.\n */\nconst STRUCTURE_BUILD_ERRORS_CAP = 100;\n\nexport class StructureRecorderDispatcher {\n  private recorders: StructureRecorder[] = [];\n  private readonly errors: StructureBuildError[] = [];\n  private _truncated = false;\n\n  /** Attach a `StructureRecorder`. Multiple recorders with the same\n   *  id are allowed; the convention is one id per logical concern. */\n  attach(recorder: StructureRecorder): void {\n    this.recorders.push(recorder);\n  }\n\n  /** Detach every recorder with the given id. */\n  detach(id: string): void {\n    this.recorders = this.recorders.filter((r) => r.id !== id);\n  }\n\n  /** Defensive copy of the attached recorders — used in tests + by\n   *  tooling that wants to inspect what's registered. */\n  getRecorders(): StructureRecorder[] {\n    return [...this.recorders];\n  }\n\n  /** Find one recorder by id. */\n  getRecorderById<T extends StructureRecorder = StructureRecorder>(id: string): T | undefined {\n    return this.recorders.find((r) => r.id === id) as T | undefined;\n  }\n\n  /** Read accumulated errors from this build. Returns a defensive copy. */\n  getErrors(): StructureBuildError[] {\n    return [...this.errors];\n  }\n\n  // ── fire* methods — called by the builder at each event moment ─────\n\n  fireStageAdded(event: StructureStageAddedEvent): void {\n    if (this.recorders.length === 0) return;\n    // NOTE: `event.spec` is NOT frozen here. `onStageAdded` fires\n    // IMMEDIATELY when a spec node is added — the builder still needs\n    // to mutate `spec.next` later (in the subsequent `addX` call).\n    // Freezing here would break the builder. Handler mutation of\n    // `event.spec` is documented as undefined behavior — see the\n    // StructureRecorder type's JSDoc + readonly markers on the\n    // event payload interface.\n    for (const r of this.recorders) {\n      try {\n        r.onStageAdded?.(event);\n      } catch (err) {\n        this.recordError(r.id, 'onStageAdded', err);\n      }\n    }\n  }\n\n  fireEdgeAdded(event: StructureEdgeAddedEvent): void {\n    if (this.recorders.length === 0) return;\n    // No spec on this event — pass through.\n    for (const r of this.recorders) {\n      try {\n        r.onEdgeAdded?.(event);\n      } catch (err) {\n        this.recordError(r.id, 'onEdgeAdded', err);\n      }\n    }\n  }\n\n  fireLoopEdgeAdded(event: StructureLoopEdgeAddedEvent): void {\n    if (this.recorders.length === 0) return;\n    for (const r of this.recorders) {\n      try {\n        r.onLoopEdgeAdded?.(event);\n      } catch (err) {\n        this.recordError(r.id, 'onLoopEdgeAdded', err);\n      }\n    }\n  }\n\n  fireDeciderComplete(event: StructureDeciderCompleteEvent): void {\n    if (this.recorders.length === 0) return;\n    for (const r of this.recorders) {\n      try {\n        r.onDeciderComplete?.(event);\n      } catch (err) {\n        this.recordError(r.id, 'onDeciderComplete', err);\n      }\n    }\n  }\n\n  fireSubflowMounted(event: StructureSubflowMountedEvent): void {\n    if (this.recorders.length === 0) return;\n    for (const r of this.recorders) {\n      try {\n        r.onSubflowMounted?.(event);\n      } catch (err) {\n        this.recordError(r.id, 'onSubflowMounted', err);\n      }\n    }\n  }\n\n  /**\n   * Externally-callable error capture for events the builder fires\n   * OUTSIDE the normal fire* fan-out path — specifically the seed\n   * replay in `FlowChartBuilder.attachStructureRecorder()`, which\n   * targets one specific recorder rather than every attached recorder.\n   *\n   * Same observability contract as the internal `recordError`:\n   * accumulates on `getErrors()` AND logs in dev mode.\n   */\n  recordErrorForReplay(recorderId: string, method: string, err: unknown): void {\n    this.recordError(recorderId, method, err);\n  }\n\n  // ── Internals ───────────────────────────────────────────────────────\n\n  private recordError(recorderId: string, method: string, err: unknown): void {\n    const e = err as { message?: unknown } | undefined;\n    const message = typeof e?.message === 'string' ? e.message : String(err);\n    // Soft cap to prevent unbounded growth + closure retention. Once\n    // hit, push a single sentinel describing the truncation and drop\n    // further records on the floor (still log in dev mode so the\n    // consumer notices the spam at its source).\n    if (this.errors.length < STRUCTURE_BUILD_ERRORS_CAP) {\n      this.errors.push({ recorderId, method, message, error: err });\n    } else if (!this._truncated) {\n      this._truncated = true;\n      this.errors.push({\n        recorderId: '__truncated__',\n        method: '__truncated__',\n        message: `StructureRecorderDispatcher: error accumulator truncated at ${STRUCTURE_BUILD_ERRORS_CAP} entries; further errors suppressed.`,\n        error: null,\n      });\n    }\n    if (isDevMode()) {\n      // eslint-disable-next-line no-console\n      console.warn(\n        `[footprint] StructureRecorderDispatcher: recorder \"${recorderId}\" threw in ${method}: ${message}. ` +\n          'See builder.getStructureBuildErrors() for the full list.',\n      );\n    }\n  }\n}\n\n/** Re-export the FlowChartSpec type for downstream type completeness. */\nexport type { FlowChartSpec };\n"]}

package/dist/lib/builder/types.js

@@ -13,4 +13,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ArrayMergeMode = void 0;
 var types_js_1 = require("../engine/types.js");
 Object.defineProperty(exports, "ArrayMergeMode", { enumerable: true, get: function () { return types_js_1.ArrayMergeMode; } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/lib/builder/types.ts"],"names":[],"mappings":";AAAA;;;;;;;;;GASG;;;AAoBH,+CAAoD;AAA3C,0GAAA,cAAc,OAAA","sourcesContent":["/**\n * builder/types.ts — All types used by the builder library.\n *\n * Shared types (StageNode, StageFunction, etc.) are imported from the engine.\n * Builder-specific types (FlowChartSpec, FlowChart, SerializedPipelineStructure)\n * are defined locally — they carry builder-only fields (description, outputMapper, etc.).\n *\n * NOTE: All engine imports are `import type` — zero runtime dependency.\n * The builder remains standalone at runtime.\n */\n\nimport type { StageNode } from '../engine/graph/StageNode.js';\nimport type { ILogger, ScopeFactory, StageFunction, TraversalExtractor } from '../engine/types.js';\nimport type { ScopeProtectionMode } from '../scope/protection/types.js';\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Re-exports from engine (canonical definitions)\n// ─────────────────────────────────────────────────────────────────────────────\n\nexport type { ResumeFn, StageNode } from '../engine/graph/StageNode.js';\nexport type {\n  ILogger,\n  StageFunction,\n  StreamCallback,\n  StreamHandlers,\n  StreamLifecycleHandler,\n  StreamTokenHandler,\n  SubflowMountOptions,\n} from '../engine/types.js';\nexport { ArrayMergeMode } from '../engine/types.js';\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Aliases\n// ─────────────────────────────────────────────────────────────────────────────\n\n/** Relaxed-generic alias for builder ergonomics. */\nexport type StageFn = StageFunction<any, any>;\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Scope Protection — canonical definition in scope/protection/types.ts\n// ─────────────────────────────────────────────────────────────────────────────\n\nexport type { ScopeProtectionMode };\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Serialized Pipeline Structure (JSON-safe, for visualization)\n// ─────────────────────────────────────────────────────────────────────────────\n\nexport interface SerializedPipelineStructure {\n  name: string;\n  id: string;\n  type: 'stage' | 'decider' | 'selector' | 'fork' | 'streaming' | 'subflow' | 'loop';\n  /** Semantic icon hint for visualization (e.g., \"llm\", \"tool\", \"rag\", \"agent\", \"start\") */\n  icon?: string;\n  description?: string;\n  children?: SerializedPipelineStructure[];\n  next?: SerializedPipelineStructure;\n  hasDecider?: boolean;\n  hasSelector?: boolean;\n  branchIds?: string[];\n  loopTarget?: string;\n  isStreaming?: boolean;\n  streamId?: string;\n  isParallelChild?: boolean;\n  parallelGroupId?: string;\n  isSubflowRoot?: boolean;\n  subflowId?: string;\n  subflowName?: string;\n  /**\n   * Nested pipeline structure for a subflow node.\n   * WARNING: Any future walker that traverses this field recursively must apply its own\n   * depth guard (see MAX_WALK_DEPTH in contract/openapi.ts). The current `buildDescription`\n   * walk in openapi.ts does NOT traverse subflowStructure — if it ever does, the depth\n   * guard must cover both the `next` chain and this nested structure.\n   */\n  subflowStructure?: SerializedPipelineStructure;\n  iterationCount?: number;\n  /** True when this subflow uses lazy resolution (deferred until execution). */\n  isLazy?: boolean;\n  /** True when this node is a back-edge reference created by loopTo() — not an executable stage. */\n  isLoopReference?: boolean;\n  /** When true, this stage can pause execution (PausableHandler pattern). */\n  isPausable?: boolean;\n}\n\n// ─────────────────────────────────────────────────────────────────────────────\n// FlowChartSpec (pure JSON, no functions — for FE→BE transport)\n// ─────────────────────────────────────────────────────────────────────────────\n\nexport interface FlowChartSpec {\n  name: string;\n  id: string;\n  /** Node type — matches `SerializedPipelineStructure.type` for visualization alignment. */\n  type?: 'stage' | 'decider' | 'selector' | 'fork' | 'streaming' | 'subflow' | 'loop';\n  /** Semantic icon hint for visualization (e.g., \"llm\", \"tool\", \"rag\", \"agent\", \"start\") */\n  icon?: string;\n  description?: string;\n  children?: FlowChartSpec[];\n  next?: FlowChartSpec;\n  hasDecider?: boolean;\n  hasSelector?: boolean;\n  branchIds?: string[];\n  loopTarget?: string;\n  isStreaming?: boolean;\n  streamId?: string;\n  isParallelChild?: boolean;\n  parallelGroupId?: string;\n  isSubflowRoot?: boolean;\n  subflowId?: string;\n  subflowName?: string;\n  /** True when this node is a back-edge reference created by loopTo() — not an executable stage. */\n  isLoopReference?: boolean;\n}\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Build-Time Extractor\n// ─────────────────────────────────────────────────────────────────────────────\n\n/** Metadata provided to the build-time extractor for each node. */\nexport type BuildTimeNodeMetadata = FlowChartSpec;\n\nexport type BuildTimeExtractor<TResult = FlowChartSpec> = (metadata: BuildTimeNodeMetadata) => TResult;\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Traversal Extractor (runtime) — canonical definition lives in engine/types.\n// Re-exported here so callers don't need two import paths.\n// ─────────────────────────────────────────────────────────────────────────────\n\nexport type { TraversalExtractor } from '../engine/types.js';\n\n// ─────────────────────────────────────────────────────────────────────────────\n// FlowChart — compiled output of build()\n// ─────────────────────────────────────────────────────────────────────────────\n\nexport type FlowChart<TOut = any, TScope = any> = {\n  root: StageNode<TOut, TScope>;\n  stageMap: Map<string, StageFunction<TOut, TScope>>;\n  extractor?: TraversalExtractor;\n  subflows?: Record<string, { root: StageNode<TOut, TScope> }>;\n  buildTimeStructure: SerializedPipelineStructure;\n  enableNarrative?: boolean;\n  logger?: ILogger;\n  description: string;\n  stageDescriptions: Map<string, string>;\n  /** Input schema (Zod or JSON Schema) — declared via setInputSchema() or .contract(). */\n  inputSchema?: unknown;\n  /** Output schema (Zod or JSON Schema) — declared via setOutputSchema() or .contract(). */\n  outputSchema?: unknown;\n  /** Output mapper — extracts response from final scope. */\n  outputMapper?: (finalScope: Record<string, unknown>) => unknown;\n  /** Scope factory — auto-embedded by flowChart<T>(). Executor reads this if no factory param. */\n  scopeFactory?: ScopeFactory<TScope>;\n};\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Simplified Parallel Spec (for addListOfFunction)\n// ─────────────────────────────────────────────────────────────────────────────\n\nexport type SimplifiedParallelSpec<TOut = any, TScope = any> = {\n  id: string;\n  name: string;\n  fn?: StageFunction<TOut, TScope>;\n};\n\n// ─────────────────────────────────────────────────────────────────────────────\n// ExecOptions (for execute() convenience — used by runner layer)\n// ─────────────────────────────────────────────────────────────────────────────\n\nexport type ExecOptions = {\n  defaults?: unknown;\n  initial?: unknown;\n  readOnly?: unknown;\n  throttlingErrorChecker?: (e: unknown) => boolean;\n  scopeProtectionMode?: ScopeProtectionMode;\n  enableNarrative?: boolean;\n};\n\n// ─────────────────────────────────────────────────────────────────────────────\n// SubflowRef\n// ─────────────────────────────────────────────────────────────────────────────\n\nexport interface SubflowRef {\n  $ref: string;\n  mountId: string;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/lib/builder/types.ts"],"names":[],"mappings":";AAAA;;;;;;;;;GASG;;;AAqBH,+CAAoD;AAA3C,0GAAA,cAAc,OAAA","sourcesContent":["/**\n * builder/types.ts — All types used by the builder library.\n *\n * Shared types (StageNode, StageFunction, etc.) are imported from the engine.\n * Builder-specific types (FlowChartSpec, FlowChart, SerializedPipelineStructure)\n * are defined locally — they carry builder-only fields (description, outputMapper, etc.).\n *\n * NOTE: All engine imports are `import type` — zero runtime dependency.\n * The builder remains standalone at runtime.\n */\n\nimport type { StageNode } from '../engine/graph/StageNode.js';\nimport type { ILogger, ScopeFactory, StageFunction } from '../engine/types.js';\nimport type { ScopeProtectionMode } from '../scope/protection/types.js';\nimport type { StructureRecorder } from './structure/StructureRecorder.js';\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Re-exports from engine (canonical definitions)\n// ─────────────────────────────────────────────────────────────────────────────\n\nexport type { ResumeFn, StageNode } from '../engine/graph/StageNode.js';\nexport type {\n  ILogger,\n  StageFunction,\n  StreamCallback,\n  StreamHandlers,\n  StreamLifecycleHandler,\n  StreamTokenHandler,\n  SubflowMountOptions,\n} from '../engine/types.js';\nexport { ArrayMergeMode } from '../engine/types.js';\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Aliases\n// ─────────────────────────────────────────────────────────────────────────────\n\n/** Relaxed-generic alias for builder ergonomics. */\nexport type StageFn = StageFunction<any, any>;\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Scope Protection — canonical definition in scope/protection/types.ts\n// ─────────────────────────────────────────────────────────────────────────────\n\nexport type { ScopeProtectionMode };\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Serialized Pipeline Structure (JSON-safe, for visualization)\n// ─────────────────────────────────────────────────────────────────────────────\n\nexport interface SerializedPipelineStructure {\n  name: string;\n  id: string;\n  type: 'stage' | 'decider' | 'selector' | 'fork' | 'streaming' | 'subflow' | 'loop';\n  /** Semantic icon hint for visualization (e.g., \"llm\", \"tool\", \"rag\", \"agent\", \"start\") */\n  icon?: string;\n  description?: string;\n  children?: SerializedPipelineStructure[];\n  next?: SerializedPipelineStructure;\n  hasDecider?: boolean;\n  hasSelector?: boolean;\n  branchIds?: string[];\n  loopTarget?: string;\n  isStreaming?: boolean;\n  streamId?: string;\n  isParallelChild?: boolean;\n  parallelGroupId?: string;\n  isSubflowRoot?: boolean;\n  subflowId?: string;\n  subflowName?: string;\n  /**\n   * Nested pipeline structure for a subflow node.\n   * WARNING: Any future walker that traverses this field recursively must apply its own\n   * depth guard (see MAX_WALK_DEPTH in contract/openapi.ts). The current `buildDescription`\n   * walk in openapi.ts does NOT traverse subflowStructure — if it ever does, the depth\n   * guard must cover both the `next` chain and this nested structure.\n   */\n  subflowStructure?: SerializedPipelineStructure;\n  iterationCount?: number;\n  /** True when this subflow uses lazy resolution (deferred until execution). */\n  isLazy?: boolean;\n  /** True when this node is a back-edge reference created by loopTo() — not an executable stage. */\n  isLoopReference?: boolean;\n  /** When true, this stage can pause execution (PausableHandler pattern). */\n  isPausable?: boolean;\n}\n\n// ─────────────────────────────────────────────────────────────────────────────\n// FlowChartSpec (pure JSON, no functions — for FE→BE transport)\n// ─────────────────────────────────────────────────────────────────────────────\n\nexport interface FlowChartSpec {\n  name: string;\n  id: string;\n  /** Node type — matches `SerializedPipelineStructure.type` for visualization alignment. */\n  type?: 'stage' | 'decider' | 'selector' | 'fork' | 'streaming' | 'subflow' | 'loop';\n  /** Semantic icon hint for visualization (e.g., \"llm\", \"tool\", \"rag\", \"agent\", \"start\") */\n  icon?: string;\n  description?: string;\n  children?: FlowChartSpec[];\n  next?: FlowChartSpec;\n  hasDecider?: boolean;\n  hasSelector?: boolean;\n  branchIds?: string[];\n  loopTarget?: string;\n  isStreaming?: boolean;\n  streamId?: string;\n  isParallelChild?: boolean;\n  parallelGroupId?: string;\n  isSubflowRoot?: boolean;\n  subflowId?: string;\n  subflowName?: string;\n  /** True when this node is a back-edge reference created by loopTo() — not an executable stage. */\n  isLoopReference?: boolean;\n}\n\n// ─────────────────────────────────────────────────────────────────────────────\n// flowChart() options bag\n// ─────────────────────────────────────────────────────────────────────────────\n\n/**\n * Options-bag argument shape for the `flowChart()` factory.\n */\nexport interface FlowChartOptions {\n  /**\n   * Build-time recorders to attach BEFORE `start()` fires. Equivalent\n   * to chaining `.attachStructureRecorder(rec)` immediately after the\n   * factory returns — but registered EARLIER, so even the seed event\n   * fires through the dispatcher without needing the seed-replay path.\n   *\n   * Multiple recorders attach in array order (same as\n   * `.attachStructureRecorder` repeated). See `StructureRecorder` JSDoc\n   * for event semantics, ordering invariants, and the trust model.\n   */\n  structureRecorders?: StructureRecorder[];\n  /** Free-form description shown on the root spec node. */\n  description?: string;\n}\n\n// ─────────────────────────────────────────────────────────────────────────────\n// FlowChart — compiled output of build()\n// ─────────────────────────────────────────────────────────────────────────────\n\nexport type FlowChart<TOut = any, TScope = any> = {\n  root: StageNode<TOut, TScope>;\n  stageMap: Map<string, StageFunction<TOut, TScope>>;\n  subflows?: Record<string, { root: StageNode<TOut, TScope> }>;\n  buildTimeStructure: SerializedPipelineStructure;\n  enableNarrative?: boolean;\n  logger?: ILogger;\n  description: string;\n  stageDescriptions: Map<string, string>;\n  /** Input schema (Zod or JSON Schema) — declared via setInputSchema() or .contract(). */\n  inputSchema?: unknown;\n  /** Output schema (Zod or JSON Schema) — declared via setOutputSchema() or .contract(). */\n  outputSchema?: unknown;\n  /** Output mapper — extracts response from final scope. */\n  outputMapper?: (finalScope: Record<string, unknown>) => unknown;\n  /** Scope factory — auto-embedded by flowChart<T>(). Executor reads this if no factory param. */\n  scopeFactory?: ScopeFactory<TScope>;\n};\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Simplified Parallel Spec (for addListOfFunction)\n// ─────────────────────────────────────────────────────────────────────────────\n\nexport type SimplifiedParallelSpec<TOut = any, TScope = any> = {\n  id: string;\n  name: string;\n  fn?: StageFunction<TOut, TScope>;\n};\n\n// ─────────────────────────────────────────────────────────────────────────────\n// ExecOptions (for execute() convenience — used by runner layer)\n// ─────────────────────────────────────────────────────────────────────────────\n\nexport type ExecOptions = {\n  defaults?: unknown;\n  initial?: unknown;\n  readOnly?: unknown;\n  throttlingErrorChecker?: (e: unknown) => boolean;\n  scopeProtectionMode?: ScopeProtectionMode;\n  enableNarrative?: boolean;\n};\n\n// ─────────────────────────────────────────────────────────────────────────────\n// SubflowRef\n// ─────────────────────────────────────────────────────────────────────────────\n\nexport interface SubflowRef {\n  $ref: string;\n  mountId: string;\n}\n"]}

package/dist/lib/decide/decide.js

@@ -18,18 +18,18 @@ const types_js_1 = require("./types.js");
 // -- Scope accessor helpers --------------------------------------------------
 function getAttachFn(scope) {
     const s = scope;
-    if (typeof s.$attachRecorder === 'function')
-        return s.$attachRecorder.bind(s);
-    if (typeof s.attachRecorder === 'function')
-        return s.attachRecorder.bind(s);
+    if (typeof s.$attachScopeRecorder === 'function')
+        return s.$attachScopeRecorder.bind(s);
+    if (typeof s.attachScopeRecorder === 'function')
+        return s.attachScopeRecorder.bind(s);
     return undefined;
 }
 function getDetachFn(scope) {
     const s = scope;
-    if (typeof s.$detachRecorder === 'function')
-        return s.$detachRecorder.bind(s);
-    if (typeof s.detachRecorder === 'function')
-        return s.detachRecorder.bind(s);
+    if (typeof s.$detachScopeRecorder === 'function')
+        return s.$detachScopeRecorder.bind(s);
+    if (typeof s.detachScopeRecorder === 'function')
+        return s.detachScopeRecorder.bind(s);
     return undefined;
 }
 function getValueFn(scope) {
@@ -201,4 +201,4 @@ function select(scope, rules) {
     return { branches: selectedBranches, [types_js_1.DECISION_RESULT]: true, evidence };
 }
 exports.select = select;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"decide.js","sourceRoot":"","sources":["../../../src/lib/decide/decide.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * decide/decide -- Core decide() and select() helper functions.\n *\n * decide() evaluates rules in order (first-match) and returns a DecisionResult.\n * select() evaluates ALL rules and returns a SelectionResult with all matches.\n *\n * Each rule's `when` can be:\n * - A function: (s) => s.creditScore > 700  (auto-captures reads via temp recorder)\n * - A filter:   { creditScore: { gt: 700 } } (captures reads + operators + thresholds)\n */\n\nimport { isDevMode } from '../scope/detectCircular.js';\nimport type { Recorder } from '../scope/types.js';\nimport { evaluateFilter } from './evaluator.js';\nimport { EvidenceCollector } from './evidence.js';\nimport type {\n  DecideRule,\n  DecisionEvidence,\n  DecisionResult,\n  FilterCondition,\n  FilterRuleEvidence,\n  FunctionRuleEvidence,\n  RuleEvidence,\n  SelectionEvidence,\n  SelectionResult,\n  WhereFilter,\n} from './types.js';\nimport { DECISION_RESULT } from './types.js';\n\n// -- Scope accessor helpers --------------------------------------------------\n\nfunction getAttachFn(scope: unknown): ((r: Recorder) => void) | undefined {\n  const s = scope as Record<string, unknown>;\n  if (typeof s.$attachRecorder === 'function') return s.$attachRecorder.bind(s);\n  if (typeof s.attachRecorder === 'function') return s.attachRecorder.bind(s);\n  return undefined;\n}\n\nfunction getDetachFn(scope: unknown): ((id: string) => void) | undefined {\n  const s = scope as Record<string, unknown>;\n  if (typeof s.$detachRecorder === 'function') return s.$detachRecorder.bind(s);\n  if (typeof s.detachRecorder === 'function') return s.detachRecorder.bind(s);\n  return undefined;\n}\n\nfunction getValueFn(scope: unknown): (key: string) => unknown {\n  const s = scope as Record<string, unknown>;\n  // Check $getValue first: on TypedScope, accessing .getValue triggers a spurious\n  // onRead for key \"getValue\" via the Proxy get trap. $getValue routes through\n  // SCOPE_METHOD_NAMES and avoids the state-read path.\n  if (typeof s.$getValue === 'function') return s.$getValue.bind(s);\n  if (typeof s.getValue === 'function') return s.getValue.bind(s);\n  return () => undefined;\n}\n\nfunction getRedactedFn(scope: unknown): (key: string) => boolean {\n  const s = scope as Record<string, unknown>;\n  // Try $toRaw() first (TypedScope), then direct\n  const raw = typeof s.$toRaw === 'function' ? s.$toRaw() : s;\n  const r = raw as Record<string, unknown>;\n  if (typeof r.getRedactedKeys === 'function') {\n    const keys = r.getRedactedKeys() as Set<string>;\n    return (key: string) => keys.has(key);\n  }\n  return () => false;\n}\n\n// -- evaluate a single rule --------------------------------------------------\n\nfunction evaluateRule<S extends object>(\n  scope: S,\n  rule: DecideRule<S>,\n  index: number,\n  attachFn?: (r: Recorder) => void,\n  detachFn?: (id: string) => void,\n  valueFn?: (key: string) => unknown,\n  redactedFn?: (key: string) => boolean,\n): RuleEvidence {\n  if (typeof rule.when === 'function') {\n    // FUNCTION PATH: temp recorder captures reads (lazy — skip if no recorder support)\n    const hasRecorderSupport = Boolean(attachFn);\n    const collector = hasRecorderSupport ? new EvidenceCollector() : undefined;\n    if (collector && attachFn) attachFn(collector);\n\n    let matched: boolean;\n    let matchError: string | undefined;\n    try {\n      matched = rule.when(scope);\n    } catch (e) {\n      matched = false;\n      // Capture the error for debugging — surface it in evidence instead of swallowing silently\n      matchError = e instanceof Error ? e.message : String(e);\n      if (isDevMode()) {\n        const label = rule.label ? ` ('${rule.label}')` : '';\n        // eslint-disable-next-line no-console\n        console.warn(`[footprint] decide() rule ${index}${label} threw during evaluation: ${matchError}`);\n      }\n    } finally {\n      if (collector && detachFn) detachFn(collector.id);\n    }\n\n    const evidence: FunctionRuleEvidence = {\n      type: 'function',\n      ruleIndex: index,\n      branch: rule.then,\n      matched,\n      label: rule.label,\n      // Partial reads: if rule threw after some getValue() calls, collector holds reads up to the throw point\n      inputs: collector?.getInputs() ?? [],\n      ...(matchError !== undefined && { matchError }),\n    };\n    return evidence;\n  } else {\n    // FILTER PATH: reads values directly via callbacks (no recorder); exceptions treated as non-match\n    const resolvedValueFn = valueFn ?? (() => undefined);\n    const resolvedRedactedFn = redactedFn ?? (() => false);\n    let filterMatched = false;\n    let filterConditions: FilterCondition[] = [];\n    let matchError: string | undefined;\n    try {\n      const result = evaluateFilter(resolvedValueFn, resolvedRedactedFn, rule.when as WhereFilter<S>);\n      filterMatched = result.matched;\n      filterConditions = result.conditions;\n    } catch (e) {\n      filterMatched = false;\n      filterConditions = [];\n      // Capture the error for debugging — surface it in evidence instead of swallowing silently\n      matchError = e instanceof Error ? e.message : String(e);\n      if (isDevMode()) {\n        const label = rule.label ? ` ('${rule.label}')` : '';\n        // eslint-disable-next-line no-console\n        console.warn(`[footprint] decide() filter rule ${index}${label} threw during evaluation: ${matchError}`);\n      }\n    }\n\n    const evidence: FilterRuleEvidence = {\n      type: 'filter',\n      ruleIndex: index,\n      branch: rule.then,\n      matched: filterMatched,\n      label: rule.label,\n      conditions: filterConditions,\n      ...(matchError !== undefined && { matchError }),\n    };\n    return evidence;\n  }\n}\n\n// -- decide() ----------------------------------------------------------------\n\n/**\n * Evaluates rules in order (first-match). Returns a branded DecisionResult.\n *\n * @param scope - TypedScope or ScopeFacade\n * @param rules - Array of DecideRule (function or filter when clauses)\n * @param defaultBranch - Branch ID if no rule matches\n *\n * **Error behavior:** If a `when` function throws during evaluation, the rule is\n * treated as non-matching (`matched: false`) and the error message is captured in\n * `matchError` on that rule's `RuleEvidence` entry. Execution continues with\n * subsequent rules; errors do not propagate to the caller.\n */\nexport function decide<S extends object>(scope: S, rules: DecideRule<S>[], defaultBranch: string): DecisionResult {\n  const attachFn = getAttachFn(scope);\n  const detachFn = getDetachFn(scope);\n  const valueFn = getValueFn(scope);\n  const redactedFn = getRedactedFn(scope);\n\n  const evaluatedRules: RuleEvidence[] = [];\n\n  for (const [index, rule] of rules.entries()) {\n    const ruleEvidence = evaluateRule(scope, rule, index, attachFn, detachFn, valueFn, redactedFn);\n    evaluatedRules.push(ruleEvidence);\n\n    if (ruleEvidence.matched) {\n      const evidence: DecisionEvidence = {\n        rules: evaluatedRules,\n        chosen: rule.then,\n        default: defaultBranch,\n      };\n      return { branch: rule.then, [DECISION_RESULT]: true, evidence };\n    }\n  }\n\n  // Default: no rule matched\n  const evidence: DecisionEvidence = {\n    rules: evaluatedRules,\n    chosen: defaultBranch,\n    default: defaultBranch,\n  };\n  return { branch: defaultBranch, [DECISION_RESULT]: true, evidence };\n}\n\n// -- select() ----------------------------------------------------------------\n\n/**\n * Evaluates ALL rules (not first-match). Returns a branded SelectionResult.\n *\n * @param scope - TypedScope or ScopeFacade\n * @param rules - Array of DecideRule (function or filter when clauses)\n *\n * **Error behavior:** If a `when` function throws during evaluation, the rule is\n * treated as non-matching (`matched: false`) and the error message is captured in\n * `matchError` on that rule's `RuleEvidence` entry. Evaluation continues with\n * remaining rules; errors do not propagate to the caller.\n */\nexport function select<S extends object>(scope: S, rules: DecideRule<S>[]): SelectionResult {\n  const attachFn = getAttachFn(scope);\n  const detachFn = getDetachFn(scope);\n  const valueFn = getValueFn(scope);\n  const redactedFn = getRedactedFn(scope);\n\n  const evaluatedRules: RuleEvidence[] = [];\n  const selectedBranches: string[] = [];\n\n  for (const [index, rule] of rules.entries()) {\n    const ruleEvidence = evaluateRule(scope, rule, index, attachFn, detachFn, valueFn, redactedFn);\n    evaluatedRules.push(ruleEvidence);\n\n    if (ruleEvidence.matched) {\n      selectedBranches.push(rule.then);\n    }\n  }\n\n  const evidence: SelectionEvidence = {\n    rules: evaluatedRules,\n    selected: selectedBranches,\n  };\n  return { branches: selectedBranches, [DECISION_RESULT]: true, evidence };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"decide.js","sourceRoot":"","sources":["../../../src/lib/decide/decide.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * decide/decide -- Core decide() and select() helper functions.\n *\n * decide() evaluates rules in order (first-match) and returns a DecisionResult.\n * select() evaluates ALL rules and returns a SelectionResult with all matches.\n *\n * Each rule's `when` can be:\n * - A function: (s) => s.creditScore > 700  (auto-captures reads via temp recorder)\n * - A filter:   { creditScore: { gt: 700 } } (captures reads + operators + thresholds)\n */\n\nimport { isDevMode } from '../scope/detectCircular.js';\nimport type { ScopeRecorder } from '../scope/types.js';\nimport { evaluateFilter } from './evaluator.js';\nimport { EvidenceCollector } from './evidence.js';\nimport type {\n  DecideRule,\n  DecisionEvidence,\n  DecisionResult,\n  FilterCondition,\n  FilterRuleEvidence,\n  FunctionRuleEvidence,\n  RuleEvidence,\n  SelectionEvidence,\n  SelectionResult,\n  WhereFilter,\n} from './types.js';\nimport { DECISION_RESULT } from './types.js';\n\n// -- Scope accessor helpers --------------------------------------------------\n\nfunction getAttachFn(scope: unknown): ((r: ScopeRecorder) => void) | undefined {\n  const s = scope as Record<string, unknown>;\n  if (typeof s.$attachScopeRecorder === 'function') return s.$attachScopeRecorder.bind(s);\n  if (typeof s.attachScopeRecorder === 'function') return s.attachScopeRecorder.bind(s);\n  return undefined;\n}\n\nfunction getDetachFn(scope: unknown): ((id: string) => void) | undefined {\n  const s = scope as Record<string, unknown>;\n  if (typeof s.$detachScopeRecorder === 'function') return s.$detachScopeRecorder.bind(s);\n  if (typeof s.detachScopeRecorder === 'function') return s.detachScopeRecorder.bind(s);\n  return undefined;\n}\n\nfunction getValueFn(scope: unknown): (key: string) => unknown {\n  const s = scope as Record<string, unknown>;\n  // Check $getValue first: on TypedScope, accessing .getValue triggers a spurious\n  // onRead for key \"getValue\" via the Proxy get trap. $getValue routes through\n  // SCOPE_METHOD_NAMES and avoids the state-read path.\n  if (typeof s.$getValue === 'function') return s.$getValue.bind(s);\n  if (typeof s.getValue === 'function') return s.getValue.bind(s);\n  return () => undefined;\n}\n\nfunction getRedactedFn(scope: unknown): (key: string) => boolean {\n  const s = scope as Record<string, unknown>;\n  // Try $toRaw() first (TypedScope), then direct\n  const raw = typeof s.$toRaw === 'function' ? s.$toRaw() : s;\n  const r = raw as Record<string, unknown>;\n  if (typeof r.getRedactedKeys === 'function') {\n    const keys = r.getRedactedKeys() as Set<string>;\n    return (key: string) => keys.has(key);\n  }\n  return () => false;\n}\n\n// -- evaluate a single rule --------------------------------------------------\n\nfunction evaluateRule<S extends object>(\n  scope: S,\n  rule: DecideRule<S>,\n  index: number,\n  attachFn?: (r: ScopeRecorder) => void,\n  detachFn?: (id: string) => void,\n  valueFn?: (key: string) => unknown,\n  redactedFn?: (key: string) => boolean,\n): RuleEvidence {\n  if (typeof rule.when === 'function') {\n    // FUNCTION PATH: temp recorder captures reads (lazy — skip if no recorder support)\n    const hasRecorderSupport = Boolean(attachFn);\n    const collector = hasRecorderSupport ? new EvidenceCollector() : undefined;\n    if (collector && attachFn) attachFn(collector);\n\n    let matched: boolean;\n    let matchError: string | undefined;\n    try {\n      matched = rule.when(scope);\n    } catch (e) {\n      matched = false;\n      // Capture the error for debugging — surface it in evidence instead of swallowing silently\n      matchError = e instanceof Error ? e.message : String(e);\n      if (isDevMode()) {\n        const label = rule.label ? ` ('${rule.label}')` : '';\n        // eslint-disable-next-line no-console\n        console.warn(`[footprint] decide() rule ${index}${label} threw during evaluation: ${matchError}`);\n      }\n    } finally {\n      if (collector && detachFn) detachFn(collector.id);\n    }\n\n    const evidence: FunctionRuleEvidence = {\n      type: 'function',\n      ruleIndex: index,\n      branch: rule.then,\n      matched,\n      label: rule.label,\n      // Partial reads: if rule threw after some getValue() calls, collector holds reads up to the throw point\n      inputs: collector?.getInputs() ?? [],\n      ...(matchError !== undefined && { matchError }),\n    };\n    return evidence;\n  } else {\n    // FILTER PATH: reads values directly via callbacks (no recorder); exceptions treated as non-match\n    const resolvedValueFn = valueFn ?? (() => undefined);\n    const resolvedRedactedFn = redactedFn ?? (() => false);\n    let filterMatched = false;\n    let filterConditions: FilterCondition[] = [];\n    let matchError: string | undefined;\n    try {\n      const result = evaluateFilter(resolvedValueFn, resolvedRedactedFn, rule.when as WhereFilter<S>);\n      filterMatched = result.matched;\n      filterConditions = result.conditions;\n    } catch (e) {\n      filterMatched = false;\n      filterConditions = [];\n      // Capture the error for debugging — surface it in evidence instead of swallowing silently\n      matchError = e instanceof Error ? e.message : String(e);\n      if (isDevMode()) {\n        const label = rule.label ? ` ('${rule.label}')` : '';\n        // eslint-disable-next-line no-console\n        console.warn(`[footprint] decide() filter rule ${index}${label} threw during evaluation: ${matchError}`);\n      }\n    }\n\n    const evidence: FilterRuleEvidence = {\n      type: 'filter',\n      ruleIndex: index,\n      branch: rule.then,\n      matched: filterMatched,\n      label: rule.label,\n      conditions: filterConditions,\n      ...(matchError !== undefined && { matchError }),\n    };\n    return evidence;\n  }\n}\n\n// -- decide() ----------------------------------------------------------------\n\n/**\n * Evaluates rules in order (first-match). Returns a branded DecisionResult.\n *\n * @param scope - TypedScope or ScopeFacade\n * @param rules - Array of DecideRule (function or filter when clauses)\n * @param defaultBranch - Branch ID if no rule matches\n *\n * **Error behavior:** If a `when` function throws during evaluation, the rule is\n * treated as non-matching (`matched: false`) and the error message is captured in\n * `matchError` on that rule's `RuleEvidence` entry. Execution continues with\n * subsequent rules; errors do not propagate to the caller.\n */\nexport function decide<S extends object>(scope: S, rules: DecideRule<S>[], defaultBranch: string): DecisionResult {\n  const attachFn = getAttachFn(scope);\n  const detachFn = getDetachFn(scope);\n  const valueFn = getValueFn(scope);\n  const redactedFn = getRedactedFn(scope);\n\n  const evaluatedRules: RuleEvidence[] = [];\n\n  for (const [index, rule] of rules.entries()) {\n    const ruleEvidence = evaluateRule(scope, rule, index, attachFn, detachFn, valueFn, redactedFn);\n    evaluatedRules.push(ruleEvidence);\n\n    if (ruleEvidence.matched) {\n      const evidence: DecisionEvidence = {\n        rules: evaluatedRules,\n        chosen: rule.then,\n        default: defaultBranch,\n      };\n      return { branch: rule.then, [DECISION_RESULT]: true, evidence };\n    }\n  }\n\n  // Default: no rule matched\n  const evidence: DecisionEvidence = {\n    rules: evaluatedRules,\n    chosen: defaultBranch,\n    default: defaultBranch,\n  };\n  return { branch: defaultBranch, [DECISION_RESULT]: true, evidence };\n}\n\n// -- select() ----------------------------------------------------------------\n\n/**\n * Evaluates ALL rules (not first-match). Returns a branded SelectionResult.\n *\n * @param scope - TypedScope or ScopeFacade\n * @param rules - Array of DecideRule (function or filter when clauses)\n *\n * **Error behavior:** If a `when` function throws during evaluation, the rule is\n * treated as non-matching (`matched: false`) and the error message is captured in\n * `matchError` on that rule's `RuleEvidence` entry. Evaluation continues with\n * remaining rules; errors do not propagate to the caller.\n */\nexport function select<S extends object>(scope: S, rules: DecideRule<S>[]): SelectionResult {\n  const attachFn = getAttachFn(scope);\n  const detachFn = getDetachFn(scope);\n  const valueFn = getValueFn(scope);\n  const redactedFn = getRedactedFn(scope);\n\n  const evaluatedRules: RuleEvidence[] = [];\n  const selectedBranches: string[] = [];\n\n  for (const [index, rule] of rules.entries()) {\n    const ruleEvidence = evaluateRule(scope, rule, index, attachFn, detachFn, valueFn, redactedFn);\n    evaluatedRules.push(ruleEvidence);\n\n    if (ruleEvidence.matched) {\n      selectedBranches.push(rule.then);\n    }\n  }\n\n  const evidence: SelectionEvidence = {\n    rules: evaluatedRules,\n    selected: selectedBranches,\n  };\n  return { branches: selectedBranches, [DECISION_RESULT]: true, evidence };\n}\n"]}