footprintjs 5.0.0 → 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":"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","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/engine/errors/errorInfo.js

@@ -7,8 +7,9 @@
  * a single extraction point that preserves structured details while still
  * producing a human-readable message.
  *
- * Consumers (narrative recorders, extractors, diagnostic collectors) receive
- * StructuredErrorInfo instead of a flat string, and can decide how to render it.
+ * Consumers (narrative recorders, FlowRecorder.onError handlers, diagnostic
+ * collectors) receive StructuredErrorInfo instead of a flat string, and can
+ * decide how to render it.
  * String-ification happens only at the final rendering boundary.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
@@ -87,4 +88,4 @@ function formatErrorInfo(info) {
     return `${info.message}\n${issueLines.join('\n')}`;
 }
 exports.formatErrorInfo = formatErrorInfo;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZXJyb3JJbmZvLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vc3JjL2xpYi9lbmdpbmUvZXJyb3JzL2Vycm9ySW5mby50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUE7Ozs7Ozs7Ozs7OztHQVlHOzs7QUFHSCxzREFBOEQ7QUFxQjlEOzs7Ozs7R0FNRztBQUNILFNBQWdCLGdCQUFnQixDQUFDLEtBQWM7SUFDN0MsSUFBSSxLQUFLLFlBQVksZ0NBQW9CLEVBQUUsQ0FBQztRQUMxQyxPQUFPO1lBQ0wsT0FBTyxFQUFFLEtBQUssQ0FBQyxPQUFPO1lBQ3RCLElBQUksRUFBRSxLQUFLLENBQUMsSUFBSTtZQUNoQixNQUFNLEVBQUUsS0FBSyxDQUFDLE1BQU0sQ0FBQyxHQUFHLENBQUMsQ0FBQyxLQUFLLEVBQUUsRUFBRSxDQUFDLENBQUMsRUFBRSxHQUFHLEtBQUssRUFBRSxJQUFJLEVBQUUsQ0FBQyxHQUFHLEtBQUssQ0FBQyxJQUFJLENBQUMsRUFBRSxDQUFDLENBQUM7WUFDMUUsSUFBSSxFQUFFLHdCQUF3QjtZQUM5QixHQUFHLEVBQUUsS0FBSztTQUNYLENBQUM7SUFDSixDQUFDO0lBRUQsSUFBSSxLQUFLLFlBQVksS0FBSyxFQUFFLENBQUM7UUFDM0IsaUZBQWlGO1FBQ2pGLElBQUksQ0FBQztZQUNILE1BQU0sSUFBSSxHQUF3QjtnQkFDaEMsT0FBTyxFQUFFLEtBQUssQ0FBQyxPQUFPO2dCQUN0QixJQUFJLEVBQUUsS0FBSyxDQUFDLElBQUk7Z0JBQ2hCLEdBQUcsRUFBRSxLQUFLO2FBQ1gsQ0FBQztZQUVGLGtFQUFrRTtZQUNsRSxJQUFJLENBQUM7Z0JBQ0gsTUFBTSxTQUFTLEdBQUksS0FBNEMsQ0FBQyxJQUFJLENBQUM7Z0JBQ3JFLElBQUksT0FBTyxTQUFTLEtBQUssUUFBUSxFQUFFLENBQUM7b0JBQ2xDLElBQUksQ0FBQyxJQUFJLEdBQUcsU0FBUyxDQUFDO2dCQUN4QixDQUFDO1lBQ0gsQ0FBQztZQUFDLE1BQU0sQ0FBQztnQkFDUCxvQ0FBb0M7WUFDdEMsQ0FBQztZQUVELE9BQU8sSUFBSSxDQUFDO1FBQ2QsQ0FBQztRQUFDLE1BQU0sQ0FBQztZQUNQLG1FQUFtRTtRQUNyRSxDQUFDO0lBQ0gsQ0FBQztJQUVELHdEQUF3RDtJQUN4RCxJQUFJLENBQUM7UUFDSCxPQUFPO1lBQ0wsT0FBTyxFQUFFLE1BQU0sQ0FBQyxLQUFLLENBQUM7WUFDdEIsR0FBRyxFQUFFLEtBQUs7U0FDWCxDQUFDO0lBQ0osQ0FBQztJQUFDLE1BQU0sQ0FBQztRQUNQLHFFQUFxRTtRQUNyRSxPQUFPO1lBQ0wsT0FBTyxFQUFFLHdCQUF3QjtZQUNqQyxHQUFHLEVBQUUsS0FBSztTQUNYLENBQUM7SUFDSixDQUFDO0FBQ0gsQ0FBQztBQWpERCw0Q0FpREM7QUFFRDs7OztHQUlHO0FBQ0gsU0FBZ0IsZUFBZSxDQUFDLElBQXlCO0lBQ3ZELElBQUksQ0FBQyxJQUFJLENBQUMsTUFBTSxJQUFJLElBQUksQ0FBQyxNQUFNLENBQUMsTUFBTSxLQUFLLENBQUMsRUFBRSxDQUFDO1FBQzdDLE9BQU8sSUFBSSxDQUFDLE9BQU8sQ0FBQztJQUN0QixDQUFDO0lBRUQsTUFBTSxVQUFVLEdBQUcsSUFBSSxDQUFDLE1BQU0sQ0FBQyxHQUFHLENBQUMsQ0FBQyxLQUFLLEVBQUUsRUFBRTtRQUMzQyxNQUFNLElBQUksR0FBRyxLQUFLLENBQUMsSUFBSSxDQUFDLE1BQU0sR0FBRyxDQUFDLENBQUMsQ0FBQyxDQUFDLEtBQUssQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsQ0FBQyxRQUFRLENBQUM7UUFDckUsT0FBTyxPQUFPLElBQUksS0FBSyxLQUFLLENBQUMsT0FBTyxFQUFFLENBQUM7SUFDekMsQ0FBQyxDQUFDLENBQUM7SUFFSCxPQUFPLEdBQUcsSUFBSSxDQUFDLE9BQU8sS0FBSyxVQUFVLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxFQUFFLENBQUM7QUFDckQsQ0FBQztBQVhELDBDQVdDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBlcnJvckluZm8udHMg4oCUIEV4dHJhY3Qgc3RydWN0dXJlZCBpbmZvcm1hdGlvbiBmcm9tIGFueSBlcnJvciB0eXBlLlxuICpcbiAqIFRoZSBlbmdpbmUncyBlcnJvciBjYXRjaCBibG9ja3MgY3VycmVudGx5IGNhbGwgZXJyb3IudG9TdHJpbmcoKSwgZGVzdHJveWluZ1xuICogc3RydWN0dXJlZCBkYXRhIChlLmcuIElucHV0VmFsaWRhdGlvbkVycm9yLmlzc3VlcykuIFRoaXMgbW9kdWxlIHByb3ZpZGVzXG4gKiBhIHNpbmdsZSBleHRyYWN0aW9uIHBvaW50IHRoYXQgcHJlc2VydmVzIHN0cnVjdHVyZWQgZGV0YWlscyB3aGlsZSBzdGlsbFxuICogcHJvZHVjaW5nIGEgaHVtYW4tcmVhZGFibGUgbWVzc2FnZS5cbiAqXG4gKiBDb25zdW1lcnMgKG5hcnJhdGl2ZSByZWNvcmRlcnMsIEZsb3dSZWNvcmRlci5vbkVycm9yIGhhbmRsZXJzLCBkaWFnbm9zdGljXG4gKiBjb2xsZWN0b3JzKSByZWNlaXZlIFN0cnVjdHVyZWRFcnJvckluZm8gaW5zdGVhZCBvZiBhIGZsYXQgc3RyaW5nLCBhbmQgY2FuXG4gKiBkZWNpZGUgaG93IHRvIHJlbmRlciBpdC5cbiAqIFN0cmluZy1pZmljYXRpb24gaGFwcGVucyBvbmx5IGF0IHRoZSBmaW5hbCByZW5kZXJpbmcgYm91bmRhcnkuXG4gKi9cblxuaW1wb3J0IHR5cGUgeyBWYWxpZGF0aW9uSXNzdWUgfSBmcm9tICcuLi8uLi9zY2hlbWEvZXJyb3JzLmpzJztcbmltcG9ydCB7IElucHV0VmFsaWRhdGlvbkVycm9yIH0gZnJvbSAnLi4vLi4vc2NoZW1hL2Vycm9ycy5qcyc7XG5cbi8qKiBTdHJ1Y3R1cmVkIHJlcHJlc2VudGF0aW9uIG9mIGFueSBlcnJvciBjYXVnaHQgZHVyaW5nIHN0YWdlIGV4ZWN1dGlvbi4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgU3RydWN0dXJlZEVycm9ySW5mbyB7XG4gIC8qKiBIdW1hbi1yZWFkYWJsZSBlcnJvciBtZXNzYWdlIChhbHdheXMgcHJlc2VudCkuICovXG4gIG1lc3NhZ2U6IHN0cmluZztcbiAgLyoqIEVycm9yIGNsYXNzIG5hbWUgd2hlbiBhdmFpbGFibGUgKGUuZy4gJ0lucHV0VmFsaWRhdGlvbkVycm9yJywgJ1R5cGVFcnJvcicpLiAqL1xuICBuYW1lPzogc3RyaW5nO1xuICAvKiogRmllbGQtbGV2ZWwgdmFsaWRhdGlvbiBpc3N1ZXMgKHByZXNlbnQgZm9yIElucHV0VmFsaWRhdGlvbkVycm9yKS4gKi9cbiAgaXNzdWVzPzogVmFsaWRhdGlvbklzc3VlW107XG4gIC8qKiBNYWNoaW5lLXJlYWRhYmxlIGVycm9yIGNvZGUgaWYgdGhlIGVycm9yIGNhcnJpZXMgb25lLiAqL1xuICBjb2RlPzogc3RyaW5nO1xuICAvKipcbiAgICogVGhlIG9yaWdpbmFsIGVycm9yIG9iamVjdCwgZm9yIGNvbnN1bWVycyB0aGF0IG5lZWQgZnVsbCBhY2Nlc3MuXG4gICAqIE5vdCBzYWZlIHRvIHNlcmlhbGl6ZSBkaXJlY3RseSDigJQgbWF5IGNvbnRhaW4gY2lyY3VsYXIgcmVmZXJlbmNlcyxcbiAgICogc3RhY2sgdHJhY2VzLCBvciBzZW5zaXRpdmUgaW50ZXJuYWxzLiBVc2UgYGZvcm1hdEVycm9ySW5mbygpYCBmb3JcbiAgICogc2FmZSBzdHJpbmcgb3V0cHV0LlxuICAgKi9cbiAgcmF3OiB1bmtub3duO1xufVxuXG4vKipcbiAqIEV4dHJhY3Qgc3RydWN0dXJlZCBlcnJvciBpbmZvIGZyb20gYW55IHRocm93biB2YWx1ZS5cbiAqXG4gKiAtIElucHV0VmFsaWRhdGlvbkVycm9yIOKGkiBwcmVzZXJ2ZXMgLmlzc3VlcyBhcnJheVxuICogLSBTdGFuZGFyZCBFcnJvciDihpIgcHJlc2VydmVzIC5uYW1lLCAubWVzc2FnZVxuICogLSBOb24tRXJyb3IgdGhyb3duIHZhbHVlcyDihpIgY29lcmNlcyB0byBzdHJpbmdcbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGV4dHJhY3RFcnJvckluZm8oZXJyb3I6IHVua25vd24pOiBTdHJ1Y3R1cmVkRXJyb3JJbmZvIHtcbiAgaWYgKGVycm9yIGluc3RhbmNlb2YgSW5wdXRWYWxpZGF0aW9uRXJyb3IpIHtcbiAgICByZXR1cm4ge1xuICAgICAgbWVzc2FnZTogZXJyb3IubWVzc2FnZSxcbiAgICAgIG5hbWU6IGVycm9yLm5hbWUsXG4gICAgICBpc3N1ZXM6IGVycm9yLmlzc3Vlcy5tYXAoKGlzc3VlKSA9PiAoeyAuLi5pc3N1ZSwgcGF0aDogWy4uLmlzc3VlLnBhdGhdIH0pKSxcbiAgICAgIGNvZGU6ICdJTlBVVF9WQUxJREFUSU9OX0VSUk9SJyxcbiAgICAgIHJhdzogZXJyb3IsXG4gICAgfTtcbiAgfVxuXG4gIGlmIChlcnJvciBpbnN0YW5jZW9mIEVycm9yKSB7XG4gICAgLy8gR3VhcmQgYWdhaW5zdCBhZHZlcnNhcmlhbCBlcnJvcnMgd2l0aCB0aHJvd2luZyBnZXR0ZXJzIG9uIC5tZXNzYWdlLy5uYW1lLy5jb2RlXG4gICAgdHJ5IHtcbiAgICAgIGNvbnN0IGluZm86IFN0cnVjdHVyZWRFcnJvckluZm8gPSB7XG4gICAgICAgIG1lc3NhZ2U6IGVycm9yLm1lc3NhZ2UsXG4gICAgICAgIG5hbWU6IGVycm9yLm5hbWUsXG4gICAgICAgIHJhdzogZXJyb3IsXG4gICAgICB9O1xuXG4gICAgICAvLyBQcmVzZXJ2ZSAuY29kZSBpZiBwcmVzZW50IChjb21tb24gTm9kZS5qcyBwYXR0ZXJuLCBlLmcuIEVOT0VOVClcbiAgICAgIHRyeSB7XG4gICAgICAgIGNvbnN0IG1heWJlQ29kZSA9IChlcnJvciBhcyB1bmtub3duIGFzIFJlY29yZDxzdHJpbmcsIHVua25vd24+KS5jb2RlO1xuICAgICAgICBpZiAodHlwZW9mIG1heWJlQ29kZSA9PT0gJ3N0cmluZycpIHtcbiAgICAgICAgICBpbmZvLmNvZGUgPSBtYXliZUNvZGU7XG4gICAgICAgIH1cbiAgICAgIH0gY2F0Y2gge1xuICAgICAgICAvKiAuY29kZSBhY2Nlc3NvciB0aHJldyDigJQgc2tpcCBpdCAqL1xuICAgICAgfVxuXG4gICAgICByZXR1cm4gaW5mbztcbiAgICB9IGNhdGNoIHtcbiAgICAgIC8vIC5tZXNzYWdlIG9yIC5uYW1lIGdldHRlciB0aHJldyDigJQgZmFsbCB0aHJvdWdoIHRvIHN0cmluZyBjb2VyY2lvblxuICAgIH1cbiAgfVxuXG4gIC8vIE5vbi1FcnJvciB0aHJvd24gdmFsdWUgKHN0cmluZywgbnVtYmVyLCBvYmplY3QsIGV0Yy4pXG4gIHRyeSB7XG4gICAgcmV0dXJuIHtcbiAgICAgIG1lc3NhZ2U6IFN0cmluZyhlcnJvciksXG4gICAgICByYXc6IGVycm9yLFxuICAgIH07XG4gIH0gY2F0Y2gge1xuICAgIC8vIFN0cmluZygpIGZhaWxlZCAoZS5nLiBudWxsLXByb3RvdHlwZSBvYmplY3QsIHRocm93aW5nIC50b1N0cmluZygpKVxuICAgIHJldHVybiB7XG4gICAgICBtZXNzYWdlOiAnW3Vuc2VyaWFsaXphYmxlIGVycm9yXScsXG4gICAgICByYXc6IGVycm9yLFxuICAgIH07XG4gIH1cbn1cblxuLyoqXG4gKiBGb3JtYXQgYSBTdHJ1Y3R1cmVkRXJyb3JJbmZvIGJhY2sgdG8gYSBodW1hbi1yZWFkYWJsZSBzdHJpbmcuXG4gKiBVc2UgdGhpcyBhdCByZW5kZXJpbmcgYm91bmRhcmllcyAobmFycmF0aXZlIG91dHB1dCwgbG9nIGxpbmVzKS5cbiAqIEluY2x1ZGVzIGZpZWxkLWxldmVsIGRldGFpbHMgd2hlbiBpc3N1ZXMgYXJlIHByZXNlbnQuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBmb3JtYXRFcnJvckluZm8oaW5mbzogU3RydWN0dXJlZEVycm9ySW5mbyk6IHN0cmluZyB7XG4gIGlmICghaW5mby5pc3N1ZXMgfHwgaW5mby5pc3N1ZXMubGVuZ3RoID09PSAwKSB7XG4gICAgcmV0dXJuIGluZm8ubWVzc2FnZTtcbiAgfVxuXG4gIGNvbnN0IGlzc3VlTGluZXMgPSBpbmZvLmlzc3Vlcy5tYXAoKGlzc3VlKSA9PiB7XG4gICAgY29uc3QgcGF0aCA9IGlzc3VlLnBhdGgubGVuZ3RoID4gMCA/IGlzc3VlLnBhdGguam9pbignLicpIDogJyhyb290KSc7XG4gICAgcmV0dXJuIGAgIC0gJHtwYXRofTogJHtpc3N1ZS5tZXNzYWdlfWA7XG4gIH0pO1xuXG4gIHJldHVybiBgJHtpbmZvLm1lc3NhZ2V9XFxuJHtpc3N1ZUxpbmVzLmpvaW4oJ1xcbicpfWA7XG59XG4iXX0=