footprintjs 9.26.0 → 9.28.0

package/dist/esm/lib/engine/handlers/ResumeEntry.js

@@ -0,0 +1,471 @@
+/**
+ * ResumeEntry — the resume's ONE-SHOT re-entry (M2, pause/resume).
+ *
+ * A resume has to get back to a stage in the middle of a chart. It does that
+ * with a small synthetic structure: a stand-in for the paused stage (the
+ * stage's own node with its function swapped for the resume half — or, for an
+ * `interrupt()` pause, for its own function with the answer deposited), and,
+ * for a pause inside subflows, the checkpoint's capture of each subflow's
+ * state on the way down.
+ *
+ * THE LAW: that structure is used EXACTLY ONCE, for the re-entry. The stand-in
+ * is where the resumed traversal STARTS (or where the leaf subflow's traversal
+ * starts) — it is never a node any id can resolve to. Each subflow on the pause
+ * path takes its seed and its entry point on its FIRST entry and never again.
+ * After that the run belongs to the real chart: every loop target, every later
+ * subflow entry (real root, inputMapper runs), every re-visit of the paused
+ * stage (which pauses again) resolves against the chart as built.
+ *
+ * ONE RULE AT EVERY LEVEL — what runs after the entry. On the original run,
+ * whatever DISPATCHED the paused stage (or the mount of the next subflow on
+ * the path) — a decider, a selector, a fork — ran its own continuation once
+ * that child's chain ended: the decider's `next`, the fork's join. A resume
+ * enters AT the child, so that continuation must be carried: the entry is
+ * the child with the enclosing dispatcher's continuation attached at the end
+ * of its own chain (`{ ...child, next: dispatcher.next }` for a chart the
+ * builder made). It is read from the CHART, level by level — never from the
+ * checkpoint, so an edited checkpoint cannot redirect a run — and it lands
+ * at the level it belongs to: a top-level decider's `next` runs at the top
+ * level, after the subflow's outputMapper, not inside the subflow.
+ *
+ * PARALLEL SIBLINGS THAT PAUSED TOO (9.28.0). When two children of one
+ * fan-out paused, the checkpoint asks the first and carries the others
+ * (`FlowchartCheckpoint.pendingPauses`). At that fan-out's level the entry is
+ * the child's own chain only — no join — and once it ends, the next sibling's
+ * pause is raised again as it was (its question, its captured state), without
+ * re-running anything. The join runs only when the last sibling is resumed.
+ *
+ * Before 9.28.0 the structure stayed in force for the whole resumed run — the
+ * traversal was ROOTED at the stand-in (so a loop back to the paused id re-ran
+ * the resume half, and a loop target upstream of the resume point was
+ * unreachable: one stage ran, then the run ended silently), and the leaf
+ * subflow's root was SWAPPED for the stand-in in the subflow dictionary (so a
+ * later entry into it would re-run the resume half on a stale seed).
+ *
+ * @example
+ * ```typescript
+ * // What FlowChartExecutor.resume() builds for a pause at 'sf-a/sf-b/ask'
+ * // (subflowPath ['sf-a', 'sf-a/sf-b']), 'sf-a/sf-b' mounted as a decider
+ * // branch inside sf-a whose decider continues to 'sf-a/after':
+ * const entry = ResumeEntry.plan({ root, subflows, path, captures, standIn });
+ * entry.start;                     // the top-level mount of 'sf-a'
+ * entry.enterSubflow('sf-a');      // { seed: sf-a's capture, entry: { ...mount of 'sf-a/sf-b', next: sf-a/after } }
+ * entry.enterSubflow('sf-a/sf-b'); // { seed: sf-b's capture, entry: the stand-in }
+ * entry.enterSubflow('sf-a/sf-b'); // undefined — a later entry is an ordinary one
+ * ```
+ *
+ * A pause two (or more) subflows deep therefore re-enters each outer subflow
+ * AT the mount of the next one — the outer subflow's stages before that mount
+ * do not run again (they did before 9.28.0). The one exception is a degraded
+ * checkpoint missing an outer subflow's capture: that subflow re-runs from its
+ * root with its inputMapper (its earlier stages recompute what the capture
+ * would have held), exactly as 9.27.0 did.
+ */
+import { PauseSignal } from '../../pause/types.js';
+export class ResumeEntry {
+    /**
+     * Where the resumed TOP-LEVEL traversal starts: the stand-in (a top-level
+     * pause) or the mount of the first subflow on the path — each with its
+     * dispatcher's continuation attached. `undefined` for a seed-only entry —
+     * the traversal starts at its root.
+     */
+    start;
+    /** Sibling pauses whose fan-out sits at the TOP level — raised once `start`'s chain ends. */
+    startPendingPauses;
+    /**
+     * How many stage executions the resumed run makes before the stand-in runs
+     * — one per subflow on the path, each entered at its mount — so the
+     * executor's `onResume` names the stand-in's own `runtimeStageId`.
+     * `undefined` when it cannot be known before the run: an outer subflow
+     * missing its capture re-runs from its root.
+     */
+    stepsBeforeStandIn;
+    /** Hops not taken yet, by subflow id. A hop leaves this map when it is taken. */
+    pending;
+    constructor(start, hops, startPendingPauses, stepsBeforeStandIn) {
+        this.start = start;
+        this.startPendingPauses = startPendingPauses;
+        this.stepsBeforeStandIn = stepsBeforeStandIn;
+        this.pending = new Map(hops.map((hop) => [hop.subflowId, hop]));
+    }
+    /**
+     * Plan the re-entry of a paused chart. Every mount on the path, every
+     * dispatcher continuation and every waiting sibling is resolved HERE,
+     * against the chart as built, before a single stage runs — so a checkpoint
+     * whose path the chart cannot walk is refused up front instead of resuming
+     * into the wrong shape.
+     *
+     * @param args - `root` and `subflows`: the chart as built
+     *   (`FlowChart.root`, `FlowChart.subflows`); `path`:
+     *   `checkpoint.subflowPath`, outermost first; `captures`:
+     *   `checkpoint.subflowStates` (a detached copy); `standIn`: the node that
+     *   runs the resume half — the paused stage's own node, function swapped
+     *   (its continuation is attached here); `pendingPauses`:
+     *   `checkpoint.pendingPauses` (a detached copy).
+     * @throws when a subflow on the path is missing, mounted more than once, or
+     *   its mount cannot be reached from the enclosing graph; or when a pending
+     *   pause is malformed or is not a parallel sibling of the paused stage
+     */
+    static plan(args) {
+        const { root, subflows, path, captures, standIn } = args;
+        const chart = new ChartIndex();
+        // 1. Walk the path: the graph of every level, the mount of every subflow.
+        const graphs = [root];
+        const mounts = [];
+        for (let i = 0; i < path.length; i++) {
+            const subflowId = path[i];
+            mounts.push(chart.onlyMount(graphs[i], subflowId, i === 0 ? 'the flowchart' : `subflow '${path[i - 1]}'`));
+            // Own entries only: a path segment is data from a stored checkpoint,
+            // and `'__proto__'` must not resolve through the prototype chain.
+            const definition = ownEntry(subflows, subflowId);
+            if (!definition) {
+                throw new Error(`Cannot resume: subflow '${subflowId}' is not registered in the flowchart. ` +
+                    'The chart may have changed since the checkpoint was created.');
+            }
+            graphs.push(definition.root);
+        }
+        const leafLevel = path.length;
+        // The paused stage's REAL node — whose dispatcher the stand-in's
+        // continuation comes from. (The executor already found it; a direct
+        // caller's stand-in that is not in the leaf graph simply has none.)
+        const paused = chart.stage(graphs[leafLevel], standIn.id);
+        // 2. Queue every waiting sibling pause at the level of its fan-out.
+        const queues = queueSiblingPauses(args.pendingPauses, { chart, subflows, root, path, graphs, mounts, paused });
+        // 3. The one-shot entry of every level: the child, then its dispatcher's
+        //    continuation — up to the fan-out when siblings wait there.
+        const childAt = (level) => (level < leafLevel ? mounts[level] : paused);
+        const entryAt = (level) => {
+            const child = childAt(level);
+            const replacement = level < leafLevel ? mounts[level] : standIn;
+            if (!child)
+                return replacement;
+            return chart.entry(graphs[level], child, replacement, queues[level]?.fanOut);
+        };
+        // 4. The hops. A subflow with no capture is entered at its ROOT with its
+        //    inputMapper (its earlier stages recompute what the capture held) —
+        //    except the leaf, whose entry is always the stand-in: re-running it
+        //    from its root would ask again and lose the answer.
+        const hops = [];
+        let everyLevelAtItsEntry = true;
+        for (let i = 0; i < path.length; i++) {
+            const subflowId = path[i];
+            const seed = ownEntry(captures, subflowId);
+            const isLeafHop = i === path.length - 1;
+            if (seed === undefined && !isLeafHop) {
+                everyLevelAtItsEntry = false;
+                hops.push({ subflowId });
+                continue;
+            }
+            const waiting = queues[i + 1]?.pauses;
+            hops.push({
+                subflowId,
+                ...(seed !== undefined && { seed }),
+                entry: entryAt(i + 1),
+                ...(waiting && { pendingPauses: waiting }),
+            });
+        }
+        // Every level entered at its entry: one execution (the mount) per level
+        // runs before the stand-in.
+        return new ResumeEntry(entryAt(0), hops, queues[0]?.pauses, everyLevelAtItsEntry ? path.length : undefined);
+    }
+    /**
+     * A seed-only entry: each capture seeds the FIRST entry into its subflow,
+     * which then starts at its own root. What the deprecated
+     * `subflowStatesForResume` option (TraverserOptions / HandlerDeps) means
+     * since 9.28.0 — the same one-shot law, without a stand-in or a path.
+     */
+    static fromCaptures(captures) {
+        return new ResumeEntry(undefined, Object.entries(captures).map(([subflowId, seed]) => ({ subflowId, seed })));
+    }
+    /**
+     * The re-entry into `subflowId`, taken — or `undefined` when this entry is
+     * an ordinary one (the subflow is off the pause path, or its hop was already
+     * taken). ONE-SHOT: a hop is returned at most once, so a second entry into
+     * the same subflow (a loop passing its mount again) runs the real subflow
+     * from its real root with its inputMapper.
+     */
+    enterSubflow(subflowId) {
+        const hop = this.pending.get(subflowId);
+        if (hop !== undefined)
+            this.pending.delete(subflowId);
+        return hop;
+    }
+    /** `true` once every hop has been taken — the rest of the run is ordinary. */
+    get spent() {
+        return this.pending.size === 0;
+    }
+}
+// ── Raising a waiting sibling's pause ────────────────────────────────────────
+/**
+ * Queue `queue` behind a pause passing through its level: a pause raised
+ * while siblings still wait must carry them to its checkpoint. Each path is
+ * cut to that level — the bubble-up prepends the levels above.
+ */
+export function queueBehind(signal, queue) {
+    for (const { pause, level } of queue) {
+        signal.addPendingPause({ ...pause, subflowPath: pause.subflowPath.slice(level) });
+    }
+}
+/**
+ * The first waiting sibling's pause, raised again at its fan-out's level —
+ * exactly as it bubbled up to that level the first time (its stage, its
+ * question, its own subflow captures), nothing re-run; the rest of the queue
+ * waits behind it. The subflows ABOVE the fan-out capture themselves afresh
+ * as it bubbles up, so they carry what the resumed child wrote.
+ */
+export function raiseQueuedPause(queue) {
+    const [first, ...rest] = queue;
+    const { pause, level } = first;
+    const signal = new PauseSignal(pause.pauseData, pause.pausedStageId, pause.pausedBy);
+    const below = pause.subflowPath.slice(level);
+    for (let i = below.length - 1; i >= 0; i--) {
+        const state = ownEntry(pause.subflowStates, below[i]);
+        if (state !== undefined)
+            signal.captureSubflowScope(below[i], state);
+        signal.prependSubflow(below[i]);
+    }
+    queueBehind(signal, rest);
+    return signal;
+}
+// ── Reading the chart ────────────────────────────────────────────────────────
+/**
+ * The node that mounts `subflowId`, found by DFS from `start` over `next` and
+ * `children` (loop-ref stubs skipped — they share their target's id and carry
+ * nothing). Cycle-safe (visited by identity, so an absent id terminates too);
+ * first match in DFS pre-order (children before `next`, like the builder).
+ */
+export function findMount(start, subflowId) {
+    for (const node of dispatcherIndex(start).keys()) {
+        if (node.subflowId === subflowId)
+            return node;
+    }
+    return undefined;
+}
+/**
+ * Every real node of one level's graph, in DFS pre-order, mapped to the
+ * DISPATCHER whose child-chain holds it — the node whose `children` it
+ * descends from (a decider, a selector, a fork) — or `undefined` for a node
+ * on the level's own spine. Loop stubs are skipped; visited by identity, so
+ * two mounts sharing an id are both indexed and a cycle terminates.
+ */
+function dispatcherIndex(root) {
+    const index = new Map();
+    const stack = [[root, undefined]];
+    for (let top = stack.pop(); top !== undefined; top = stack.pop()) {
+        const [node, dispatcher] = top;
+        if (node.isLoopRef || index.has(node))
+            continue;
+        index.set(node, dispatcher);
+        // LIFO: push `next` first and children reversed, so children are visited
+        // before `next` and the first child first — pre-order, like the builder.
+        if (node.next)
+            stack.push([node.next, dispatcher]);
+        if (node.children) {
+            for (let i = node.children.length - 1; i >= 0; i--)
+                stack.push([node.children[i], node]);
+        }
+    }
+    return index;
+}
+/** One plan's view of the chart: each level's index built once. */
+class ChartIndex {
+    indexes = new Map();
+    of(root) {
+        let index = this.indexes.get(root);
+        if (!index) {
+            index = dispatcherIndex(root);
+            this.indexes.set(root, index);
+        }
+        return index;
+    }
+    /** Every mount of `subflowId` in `root`'s graph, in DFS pre-order. */
+    mountsOf(root, subflowId) {
+        return [...this.of(root).keys()].filter((node) => node.subflowId === subflowId);
+    }
+    /** The one mount of `subflowId` in `root`'s graph — refused when absent or ambiguous. */
+    onlyMount(root, subflowId, graphName) {
+        const found = this.mountsOf(root, subflowId);
+        if (found.length === 0) {
+            throw new Error(`Cannot resume: the mount of subflow '${subflowId}' is not reachable from ${graphName}. ` +
+                "The checkpoint's subflowPath does not match this chart — it may have changed since the checkpoint was created.");
+        }
+        if (found.length > 1) {
+            throw new Error(`Cannot resume: subflow '${subflowId}' is mounted more than once in ${graphName} ` +
+                `(${found.map((node) => `'${node.name}'`).join(', ')}), and a checkpoint's subflowPath cannot say which ` +
+                'mount paused. Give each mount its own subflow id to make a pause inside it resumable.');
+        }
+        return found[0];
+    }
+    /** The real stage `id` in `root`'s graph (first in DFS pre-order), if any. */
+    stage(root, id) {
+        for (const node of this.of(root).keys())
+            if (node.id === id)
+                return node;
+        return undefined;
+    }
+    /** The dispatcher whose child-chain holds `node` in `root`'s graph (`undefined` on the spine). */
+    dispatcherOf(root, node) {
+        return this.of(root).get(node);
+    }
+    /**
+     * The one-shot entry for `child` (a mount on the path, or the paused stage)
+     * in `root`'s graph: `replacement` (the node that runs — the mount itself,
+     * or the stand-in) with what ran after `child`'s chain on the original run
+     * attached where that chain ends — `{ ...child, next: dispatcher.next }` for
+     * a chart the builder made:
+     *
+     *   • on the level's spine: nothing to attach — the spine goes on by itself;
+     *   • a DECIDER's or SELECTOR's branch: the dispatcher's `next`;
+     *   • a FORK child: the fork's `next` — its join.
+     *
+     * Past a dispatcher with no `next`, the walk goes on OUTWARD to the one
+     * enclosing it. It stops at `stopAt` — the fan-out where siblings still
+     * wait, whose join must not run yet. Nothing to attach: `replacement`
+     * itself.
+     */
+    entry(root, child, replacement, stopAt) {
+        return appendAtChainEnd(replacement, this.after(root, child, stopAt));
+    }
+    /**
+     * What runs once `node`'s chain ends: its dispatcher's `next` chain, then —
+     * where THAT ends — the continuation of the dispatcher enclosing it, outward,
+     * up to `stopAt` (exclusive). `undefined` on the spine.
+     */
+    after(root, node, stopAt) {
+        const dispatcher = this.dispatcherOf(root, node);
+        if (dispatcher === undefined || dispatcher === stopAt)
+            return undefined;
+        const outer = this.after(root, dispatcher, stopAt);
+        return dispatcher.next ? appendAtChainEnd(dispatcher.next, outer) : outer;
+    }
+}
+/**
+ * `start`'s chain with `after` attached where it ends — the chain's nodes
+ * copied on the way (never registered anywhere: ids still resolve to the real
+ * nodes). A chain that ends in a loop stub (or loops back on itself) is
+ * returned as is: control leaves it through the loop, never "after" it.
+ */
+function appendAtChainEnd(start, after) {
+    if (after === undefined)
+        return start;
+    const chain = [];
+    const seen = new Set();
+    for (let node = start; node !== undefined; node = node.next) {
+        if (node.isLoopRef || seen.has(node))
+            return start;
+        seen.add(node);
+        chain.push(node);
+    }
+    let next = after;
+    for (let i = chain.length - 1; i >= 0; i--)
+        next = { ...chain[i], next };
+    return next;
+}
+/**
+ * Validate `checkpoint.pendingPauses` (untrusted input) and queue each at the
+ * level of its fan-out: the depth where its path parts from the paused
+ * stage's. There, the paused stage's child (a mount on the path, or the stage
+ * itself) and the sibling's must both hang off ONE parallel dispatcher — a
+ * fork or a selector — or the record is not a sibling and the resume is
+ * refused rather than asked a question the chart could not have raised.
+ */
+function queueSiblingPauses(pending, at) {
+    const queues = [];
+    if (pending === undefined)
+        return queues;
+    if (!Array.isArray(pending))
+        throw new Error('Invalid checkpoint: pendingPauses must be an array.');
+    const { chart, subflows, root, path, graphs, mounts, paused } = at;
+    const seen = new Set();
+    pending.forEach((raw, n) => {
+        const pause = validPendingPause(raw, n);
+        // One record per paused sibling: a repeat would ask the same question twice.
+        const key = JSON.stringify([pause.subflowPath, pause.pausedStageId]);
+        if (seen.has(key)) {
+            throw new Error(`Cannot resume: checkpoint.pendingPauses[${n}] ('${pause.pausedStageId}') repeats an earlier entry.`);
+        }
+        seen.add(key);
+        let level = 0;
+        while (level < path.length && level < pause.subflowPath.length && path[level] === pause.subflowPath[level])
+            level++;
+        const graph = graphs[level];
+        const ours = level < path.length ? mounts[level] : paused;
+        const theirMounts = level < pause.subflowPath.length ? chart.mountsOf(graph, pause.subflowPath[level]) : [];
+        const theirs = level < pause.subflowPath.length
+            ? theirMounts.length === 1
+                ? theirMounts[0]
+                : undefined
+            : chart.stage(graph, pause.pausedStageId);
+        const fanOut = ours ? chart.dispatcherOf(graph, ours) : undefined;
+        const isSibling = ours !== undefined &&
+            theirs !== undefined &&
+            ours !== theirs &&
+            fanOut !== undefined &&
+            chart.dispatcherOf(graph, theirs) === fanOut &&
+            !fanOut.deciderFn &&
+            (queues[level] === undefined || queues[level].fanOut === fanOut);
+        if (!isSibling || !walksToItsStage(chart, subflows, graph, pause, level)) {
+            throw new Error(`Cannot resume: checkpoint.pendingPauses[${n}] ('${pause.pausedStageId}') is not a parallel sibling of ` +
+                `the paused stage '${paused?.id ?? '?'}' in this chart — no fork or selector runs them both, or its ` +
+                'path does not lead to that stage. The chart may have changed since the checkpoint was created.');
+        }
+        const leafRoot = pause.subflowPath.length === 0 ? root : ownEntry(subflows, pause.subflowPath[pause.subflowPath.length - 1])?.root;
+        const stageName = (leafRoot && chart.stage(leafRoot, pause.pausedStageId)?.name) ?? pause.pausedStageId;
+        const queue = (queues[level] ??= { fanOut: fanOut, pauses: [] });
+        queue.pauses.push({ pause, level, stageName });
+    });
+    return queues;
+}
+/**
+ * Whether a waiting sibling's WHOLE path below its fan-out walks this chart:
+ * every segment the only mount of its subflow in the enclosing graph, every
+ * subflow registered, and the paused stage in the last graph — checked at
+ * the FIRST resume, so a tampered record is refused up front, not when its
+ * turn comes.
+ */
+function walksToItsStage(chart, subflows, fanOutGraph, pause, level) {
+    let graph = fanOutGraph;
+    for (let i = level; i < pause.subflowPath.length; i++) {
+        if (chart.mountsOf(graph, pause.subflowPath[i]).length !== 1)
+            return false;
+        const definition = ownEntry(subflows, pause.subflowPath[i]);
+        if (!definition)
+            return false;
+        graph = definition.root;
+    }
+    return chart.stage(graph, pause.pausedStageId) !== undefined;
+}
+/** One `pendingPauses` entry, checked field by field — it comes from stored, untrusted data. */
+function validPendingPause(raw, n) {
+    const refuse = (what) => {
+        throw new Error(`Invalid checkpoint: pendingPauses[${n}] ${what}.`);
+    };
+    if (raw === null || typeof raw !== 'object' || Array.isArray(raw))
+        refuse('must be an object');
+    const record = raw;
+    if (typeof record.pausedStageId !== 'string' || record.pausedStageId === '') {
+        refuse('must name its paused stage (pausedStageId, a non-empty string)');
+    }
+    const subflowPath = record.subflowPath;
+    if (!Array.isArray(subflowPath) || !subflowPath.every((s) => typeof s === 'string')) {
+        refuse('must carry its subflowPath (an array of strings)');
+    }
+    const states = record.subflowStates;
+    if (states !== undefined && (states === null || typeof states !== 'object' || Array.isArray(states))) {
+        refuse('must carry its subflowStates as an object');
+    }
+    if (record.pausedBy !== undefined && record.pausedBy !== 'interrupt')
+        refuse("has an unknown pausedBy (only 'interrupt')");
+    return {
+        pausedStageId: record.pausedStageId,
+        subflowPath: subflowPath,
+        subflowStates: states ?? {},
+        ...(record.pauseData !== undefined && { pauseData: record.pauseData }),
+        ...(record.pausedBy === 'interrupt' && { pausedBy: 'interrupt' }),
+    };
+}
+/** `record[key]` only when it is the record's OWN property — never through the prototype chain. */
+function ownEntry(record, key) {
+    return record && Object.prototype.hasOwnProperty.call(record, key) ? record[key] : undefined;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ResumeEntry.js","sourceRoot":"","sources":["../../../../../src/lib/engine/handlers/ResumeEntry.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8DG;AAGH,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AA8CnD,MAAM,OAAO,WAAW;IACtB;;;;;OAKG;IACM,KAAK,CAAsC;IACpD,6FAA6F;IACpF,kBAAkB,CAAqC;IAChE;;;;;;OAMG;IACM,kBAAkB,CAAqB;IAChD,iFAAiF;IAChE,OAAO,CAAuC;IAE/D,YACE,KAA0C,EAC1C,IAAwC,EACxC,kBAA2C,EAC3C,kBAA2B;QAE3B,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,CAAC,kBAAkB,GAAG,kBAAkB,CAAC;QAC7C,IAAI,CAAC,kBAAkB,GAAG,kBAAkB,CAAC;QAC7C,IAAI,CAAC,OAAO,GAAG,IAAI,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,SAAS,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC;IAClE,CAAC;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,MAAM,CAAC,IAAI,CAAe,IAOzB;QACC,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,GAAG,IAAI,CAAC;QACzD,MAAM,KAAK,GAAG,IAAI,UAAU,EAAgB,CAAC;QAE7C,0EAA0E;QAC1E,MAAM,MAAM,GAA8B,CAAC,IAAI,CAAC,CAAC;QACjD,MAAM,MAAM,GAA8B,EAAE,CAAC;QAC7C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YACrC,MAAM,SAAS,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;YAC1B,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,SAAS,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,eAAe,CAAC,CAAC,CAAC,YAAY,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;YAC3G,qEAAqE;YACrE,kEAAkE;YAClE,MAAM,UAAU,GAAG,QAAQ,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAC;YACjD,IAAI,CAAC,UAAU,EAAE,CAAC;gBAChB,MAAM,IAAI,KAAK,CACb,2BAA2B,SAAS,wCAAwC;oBAC1E,8DAA8D,CACjE,CAAC;YACJ,CAAC;YACD,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;QAC/B,CAAC;QACD,MAAM,SAAS,GAAG,IAAI,CAAC,MAAM,CAAC;QAC9B,iEAAiE;QACjE,oEAAoE;QACpE,oEAAoE;QACpE,MAAM,MAAM,GAAG,KAAK,CAAC,KAAK,CAAC,MAAM,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC,EAAE,CAAC,CAAC;QAE1D,oEAAoE;QACpE,MAAM,MAAM,GAAG,kBAAkB,CAAC,IAAI,CAAC,aAAa,EAAE,EAAE,KAAK,EAAE,QAAQ,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;QAE/G,yEAAyE;QACzE,gEAAgE;QAChE,MAAM,OAAO,GAAG,CAAC,KAAa,EAAE,EAAE,CAAC,CAAC,KAAK,GAAG,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;QAChF,MAAM,OAAO,GAAG,CAAC,KAAa,EAA2B,EAAE;YACzD,MAAM,KAAK,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;YAC7B,MAAM,WAAW,GAAG,KAAK,GAAG,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC;YAChE,IAAI,CAAC,KAAK;gBAAE,OAAO,WAAW,CAAC;YAC/B,OAAO,KAAK,CAAC,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC,CAAC;QAC/E,CAAC,CAAC;QACF,yEAAyE;QACzE,wEAAwE;QACxE,wEAAwE;QACxE,wDAAwD;QACxD,MAAM,IAAI,GAA8B,EAAE,CAAC;QAC3C,IAAI,oBAAoB,GAAG,IAAI,CAAC;QAChC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YACrC,MAAM,SAAS,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;YAC1B,MAAM,IAAI,GAAG,QAAQ,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAC;YAC3C,MAAM,SAAS,GAAG,CAAC,KAAK,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC;YACxC,IAAI,IAAI,KAAK,SAAS,IAAI,CAAC,SAAS,EAAE,CAAC;gBACrC,oBAAoB,GAAG,KAAK,CAAC;gBAC7B,IAAI,CAAC,IAAI,CAAC,EAAE,SAAS,EAAE,CAAC,CAAC;gBACzB,SAAS;YACX,CAAC;YACD,MAAM,OAAO,GAAG,MAAM,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,CAAC;YACtC,IAAI,CAAC,IAAI,CAAC;gBACR,SAAS;gBACT,GAAG,CAAC,IAAI,KAAK,SAAS,IAAI,EAAE,IAAI,EAAE,CAAC;gBACnC,KAAK,EAAE,OAAO,CAAC,CAAC,GAAG,CAAC,CAAC;gBACrB,GAAG,CAAC,OAAO,IAAI,EAAE,aAAa,EAAE,OAAO,EAAE,CAAC;aAC3C,CAAC,CAAC;QACL,CAAC;QACD,wEAAwE;QACxE,4BAA4B;QAC5B,OAAO,IAAI,WAAW,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,oBAAoB,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;IAC9G,CAAC;IAED;;;;;OAKG;IACH,MAAM,CAAC,YAAY,CAAe,QAAiD;QACjF,OAAO,IAAI,WAAW,CACpB,SAAS,EACT,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,SAAS,EAAE,IAAI,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC,CAC3E,CAAC;IACJ,CAAC;IAED;;;;;;OAMG;IACH,YAAY,CAAC,SAAiB;QAC5B,MAAM,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;QACxC,IAAI,GAAG,KAAK,SAAS;YAAE,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;QACtD,OAAO,GAAG,CAAC;IACb,CAAC;IAED,8EAA8E;IAC9E,IAAI,KAAK;QACP,OAAO,IAAI,CAAC,OAAO,CAAC,IAAI,KAAK,CAAC,CAAC;IACjC,CAAC;CACF;AAED,gFAAgF;AAEhF;;;;GAIG;AACH,MAAM,UAAU,WAAW,CAAC,MAAmB,EAAE,KAA6B;IAC5E,KAAK,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,KAAK,EAAE,CAAC;QACrC,MAAM,CAAC,eAAe,CAAC,EAAE,GAAG,KAAK,EAAE,WAAW,EAAE,KAAK,CAAC,WAAW,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;IACpF,CAAC;AACH,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,gBAAgB,CAAC,KAA6B;IAC5D,MAAM,CAAC,KAAK,EAAE,GAAG,IAAI,CAAC,GAAG,KAAK,CAAC;IAC/B,MAAM,EAAE,KAAK,EAAE,KAAK,EAAE,GAAG,KAAK,CAAC;IAC/B,MAAM,MAAM,GAAG,IAAI,WAAW,CAAC,KAAK,CAAC,SAAS,EAAE,KAAK,CAAC,aAAa,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAC;IACrF,MAAM,KAAK,GAAG,KAAK,CAAC,WAAW,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IAC7C,KAAK,IAAI,CAAC,GAAG,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;QAC3C,MAAM,KAAK,GAAG,QAAQ,CAAC,KAAK,CAAC,aAAa,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;QACtD,IAAI,KAAK,KAAK,SAAS;YAAE,MAAM,CAAC,mBAAmB,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;QACrE,MAAM,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;IAClC,CAAC;IACD,WAAW,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;IAC1B,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,gFAAgF;AAEhF;;;;;GAKG;AACH,MAAM,UAAU,SAAS,CACvB,KAA8B,EAC9B,SAAiB;IAEjB,KAAK,MAAM,IAAI,IAAI,eAAe,CAAC,KAAK,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC;QACjD,IAAI,IAAI,CAAC,SAAS,KAAK,SAAS;YAAE,OAAO,IAAI,CAAC;IAChD,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC;AAED;;;;;;GAMG;AACH,SAAS,eAAe,CACtB,IAA6B;IAE7B,MAAM,KAAK,GAAG,IAAI,GAAG,EAAgE,CAAC;IACtF,MAAM,KAAK,GAA0E,CAAC,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC,CAAC;IACzG,KAAK,IAAI,GAAG,GAAG,KAAK,CAAC,GAAG,EAAE,EAAE,GAAG,KAAK,SAAS,EAAE,GAAG,GAAG,KAAK,CAAC,GAAG,EAAE,EAAE,CAAC;QACjE,MAAM,CAAC,IAAI,EAAE,UAAU,CAAC,GAAG,GAAG,CAAC;QAC/B,IAAI,IAAI,CAAC,SAAS,IAAI,KAAK,CAAC,GAAG,CAAC,IAAI,CAAC;YAAE,SAAS;QAChD,KAAK,CAAC,GAAG,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC;QAC5B,yEAAyE;QACzE,yEAAyE;QACzE,IAAI,IAAI,CAAC,IAAI;YAAE,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC;QACnD,IAAI,IAAI,CAAC,QAAQ,EAAE,CAAC;YAClB,KAAK,IAAI,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE;gBAAE,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC;QAC3F,CAAC;IACH,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED,mEAAmE;AACnE,MAAM,UAAU;IACG,OAAO,GAAG,IAAI,GAAG,EAG/B,CAAC;IAEI,EAAE,CAAC,IAA6B;QACtC,IAAI,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QACnC,IAAI,CAAC,KAAK,EAAE,CAAC;YACX,KAAK,GAAG,eAAe,CAAC,IAAI,CAAC,CAAC;YAC9B,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;QAChC,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IAED,sEAAsE;IACtE,QAAQ,CAAC,IAA6B,EAAE,SAAiB;QACvD,OAAO,CAAC,GAAG,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,SAAS,KAAK,SAAS,CAAC,CAAC;IAClF,CAAC;IAED,yFAAyF;IACzF,SAAS,CAAC,IAA6B,EAAE,SAAiB,EAAE,SAAiB;QAC3E,MAAM,KAAK,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC;QAC7C,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACvB,MAAM,IAAI,KAAK,CACb,wCAAwC,SAAS,2BAA2B,SAAS,IAAI;gBACvF,gHAAgH,CACnH,CAAC;QACJ,CAAC;QACD,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACrB,MAAM,IAAI,KAAK,CACb,2BAA2B,SAAS,kCAAkC,SAAS,GAAG;gBAChF,IAAI,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,IAAI,CAAC,IAAI,GAAG,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,qDAAqD;gBACzG,uFAAuF,CAC1F,CAAC;QACJ,CAAC;QACD,OAAO,KAAK,CAAC,CAAC,CAAC,CAAC;IAClB,CAAC;IAED,8EAA8E;IAC9E,KAAK,CAAC,IAA6B,EAAE,EAAU;QAC7C,KAAK,MAAM,IAAI,IAAI,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE;YAAE,IAAI,IAAI,CAAC,EAAE,KAAK,EAAE;gBAAE,OAAO,IAAI,CAAC;QACzE,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,kGAAkG;IAClG,YAAY,CAAC,IAA6B,EAAE,IAA6B;QACvE,OAAO,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IACjC,CAAC;IAED;;;;;;;;;;;;;;;OAeG;IACH,KAAK,CACH,IAA6B,EAC7B,KAA8B,EAC9B,WAAoC,EACpC,MAA2C;QAE3C,OAAO,gBAAgB,CAAC,WAAW,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,KAAK,EAAE,MAAM,CAAC,CAAC,CAAC;IACxE,CAAC;IAED;;;;OAIG;IACK,KAAK,CACX,IAA6B,EAC7B,IAA6B,EAC7B,MAA2C;QAE3C,MAAM,UAAU,GAAG,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;QACjD,IAAI,UAAU,KAAK,SAAS,IAAI,UAAU,KAAK,MAAM;YAAE,OAAO,SAAS,CAAC;QACxE,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,UAAU,EAAE,MAAM,CAAC,CAAC;QACnD,OAAO,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,gBAAgB,CAAC,UAAU,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;IAC5E,CAAC;CACF;AAED;;;;;GAKG;AACH,SAAS,gBAAgB,CACvB,KAA8B,EAC9B,KAA0C;IAE1C,IAAI,KAAK,KAAK,SAAS;QAAE,OAAO,KAAK,CAAC;IACtC,MAAM,KAAK,GAA8B,EAAE,CAAC;IAC5C,MAAM,IAAI,GAAG,IAAI,GAAG,EAA2B,CAAC;IAChD,KAAK,IAAI,IAAI,GAAwC,KAAK,EAAE,IAAI,KAAK,SAAS,EAAE,IAAI,GAAG,IAAI,CAAC,IAAI,EAAE,CAAC;QACjG,IAAI,IAAI,CAAC,SAAS,IAAI,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC;YAAE,OAAO,KAAK,CAAC;QACnD,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QACf,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACnB,CAAC;IACD,IAAI,IAAI,GAAG,KAAK,CAAC;IACjB,KAAK,IAAI,CAAC,GAAG,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE;QAAE,IAAI,GAAG,EAAE,GAAG,KAAK,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC;IACzE,OAAO,IAAI,CAAC;AACd,CAAC;AAUD;;;;;;;GAOG;AACH,SAAS,kBAAkB,CACzB,OAA4C,EAC5C,EAQC;IAED,MAAM,MAAM,GAAgD,EAAE,CAAC;IAC/D,IAAI,OAAO,KAAK,SAAS;QAAE,OAAO,MAAM,CAAC;IACzC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC;QAAE,MAAM,IAAI,KAAK,CAAC,qDAAqD,CAAC,CAAC;IACpG,MAAM,EAAE,KAAK,EAAE,QAAQ,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC;IACnE,MAAM,IAAI,GAAG,IAAI,GAAG,EAAU,CAAC;IAE/B,OAAO,CAAC,OAAO,CAAC,CAAC,GAAY,EAAE,CAAC,EAAE,EAAE;QAClC,MAAM,KAAK,GAAG,iBAAiB,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC;QACxC,6EAA6E;QAC7E,MAAM,GAAG,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC,KAAK,CAAC,WAAW,EAAE,KAAK,CAAC,aAAa,CAAC,CAAC,CAAC;QACrE,IAAI,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;YAClB,MAAM,IAAI,KAAK,CACb,2CAA2C,CAAC,OAAO,KAAK,CAAC,aAAa,8BAA8B,CACrG,CAAC;QACJ,CAAC;QACD,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QACd,IAAI,KAAK,GAAG,CAAC,CAAC;QACd,OAAO,KAAK,GAAG,IAAI,CAAC,MAAM,IAAI,KAAK,GAAG,KAAK,CAAC,WAAW,CAAC,MAAM,IAAI,IAAI,CAAC,KAAK,CAAC,KAAK,KAAK,CAAC,WAAW,CAAC,KAAK,CAAC;YAAE,KAAK,EAAE,CAAC;QACpH,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;QAC5B,MAAM,IAAI,GAAG,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC;QAC1D,MAAM,WAAW,GAAG,KAAK,GAAG,KAAK,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;QAC5G,MAAM,MAAM,GACV,KAAK,GAAG,KAAK,CAAC,WAAW,CAAC,MAAM;YAC9B,CAAC,CAAC,WAAW,CAAC,MAAM,KAAK,CAAC;gBACxB,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC;gBAChB,CAAC,CAAC,SAAS;YACb,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,KAAK,EAAE,KAAK,CAAC,aAAa,CAAC,CAAC;QAC9C,MAAM,MAAM,GAAG,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,YAAY,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;QAClE,MAAM,SAAS,GACb,IAAI,KAAK,SAAS;YAClB,MAAM,KAAK,SAAS;YACpB,IAAI,KAAK,MAAM;YACf,MAAM,KAAK,SAAS;YACpB,KAAK,CAAC,YAAY,CAAC,KAAK,EAAE,MAAM,CAAC,KAAK,MAAM;YAC5C,CAAC,MAAM,CAAC,SAAS;YACjB,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,SAAS,IAAI,MAAM,CAAC,KAAK,CAAE,CAAC,MAAM,KAAK,MAAM,CAAC,CAAC;QACpE,IAAI,CAAC,SAAS,IAAI,CAAC,eAAe,CAAC,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,CAAC,EAAE,CAAC;YACzE,MAAM,IAAI,KAAK,CACb,2CAA2C,CAAC,OAAO,KAAK,CAAC,aAAa,kCAAkC;gBACtG,qBAAqB,MAAM,EAAE,EAAE,IAAI,GAAG,+DAA+D;gBACrG,gGAAgG,CACnG,CAAC;QACJ,CAAC;QACD,MAAM,QAAQ,GACZ,KAAK,CAAC,WAAW,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,QAAQ,EAAE,KAAK,CAAC,WAAW,CAAC,KAAK,CAAC,WAAW,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC;QACpH,MAAM,SAAS,GAAG,CAAC,QAAQ,IAAI,KAAK,CAAC,KAAK,CAAC,QAAQ,EAAE,KAAK,CAAC,aAAa,CAAC,EAAE,IAAI,CAAC,IAAI,KAAK,CAAC,aAAa,CAAC;QACxG,MAAM,KAAK,GAAG,CAAC,MAAM,CAAC,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,MAAO,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,CAAC;QAClE,KAAK,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC,CAAC;IACjD,CAAC,CAAC,CAAC;IACH,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;;;;;GAMG;AACH,SAAS,eAAe,CACtB,KAA+B,EAC/B,QAAuE,EACvE,WAAoC,EACpC,KAAmB,EACnB,KAAa;IAEb,IAAI,KAAK,GAAG,WAAW,CAAC;IACxB,KAAK,IAAI,CAAC,GAAG,KAAK,EAAE,CAAC,GAAG,KAAK,CAAC,WAAW,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACtD,IAAI,KAAK,CAAC,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO,KAAK,CAAC;QAC3E,MAAM,UAAU,GAAG,QAAQ,CAAC,QAAQ,EAAE,KAAK,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC;QAC5D,IAAI,CAAC,UAAU;YAAE,OAAO,KAAK,CAAC;QAC9B,KAAK,GAAG,UAAU,CAAC,IAAI,CAAC;IAC1B,CAAC;IACD,OAAO,KAAK,CAAC,KAAK,CAAC,KAAK,EAAE,KAAK,CAAC,aAAa,CAAC,KAAK,SAAS,CAAC;AAC/D,CAAC;AAED,gGAAgG;AAChG,SAAS,iBAAiB,CAAC,GAAY,EAAE,CAAS;IAChD,MAAM,MAAM,GAAG,CAAC,IAAY,EAAS,EAAE;QACrC,MAAM,IAAI,KAAK,CAAC,qCAAqC,CAAC,KAAK,IAAI,GAAG,CAAC,CAAC;IACtE,CAAC,CAAC;IACF,IAAI,GAAG,KAAK,IAAI,IAAI,OAAO,GAAG,KAAK,QAAQ,IAAI,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC;QAAE,MAAM,CAAC,mBAAmB,CAAC,CAAC;IAC/F,MAAM,MAAM,GAAG,GAA8B,CAAC;IAC9C,IAAI,OAAO,MAAM,CAAC,aAAa,KAAK,QAAQ,IAAI,MAAM,CAAC,aAAa,KAAK,EAAE,EAAE,CAAC;QAC5E,MAAM,CAAC,gEAAgE,CAAC,CAAC;IAC3E,CAAC;IACD,MAAM,WAAW,GAAG,MAAM,CAAC,WAAW,CAAC;IACvC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,WAAW,CAAC,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,OAAO,CAAC,KAAK,QAAQ,CAAC,EAAE,CAAC;QACpF,MAAM,CAAC,kDAAkD,CAAC,CAAC;IAC7D,CAAC;IACD,MAAM,MAAM,GAAG,MAAM,CAAC,aAAa,CAAC;IACpC,IAAI,MAAM,KAAK,SAAS,IAAI,CAAC,MAAM,KAAK,IAAI,IAAI,OAAO,MAAM,KAAK,QAAQ,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC;QACrG,MAAM,CAAC,2CAA2C,CAAC,CAAC;IACtD,CAAC;IACD,IAAI,MAAM,CAAC,QAAQ,KAAK,SAAS,IAAI,MAAM,CAAC,QAAQ,KAAK,WAAW;QAClE,MAAM,CAAC,4CAA4C,CAAC,CAAC;IACvD,OAAO;QACL,aAAa,EAAE,MAAM,CAAC,aAAuB;QAC7C,WAAW,EAAE,WAAuB;QACpC,aAAa,EAAG,MAA8D,IAAI,EAAE;QACpF,GAAG,CAAC,MAAM,CAAC,SAAS,KAAK,SAAS,IAAI,EAAE,SAAS,EAAE,MAAM,CAAC,SAAS,EAAE,CAAC;QACtE,GAAG,CAAC,MAAM,CAAC,QAAQ,KAAK,WAAW,IAAI,EAAE,QAAQ,EAAE,WAAoB,EAAE,CAAC;KAC3E,CAAC;AACJ,CAAC;AAED,mGAAmG;AACnG,SAAS,QAAQ,CAAI,MAAqC,EAAE,GAAW;IACrE,OAAO,MAAM,IAAI,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;AAC/F,CAAC","sourcesContent":["/**\n * ResumeEntry — the resume's ONE-SHOT re-entry (M2, pause/resume).\n *\n * A resume has to get back to a stage in the middle of a chart. It does that\n * with a small synthetic structure: a stand-in for the paused stage (the\n * stage's own node with its function swapped for the resume half — or, for an\n * `interrupt()` pause, for its own function with the answer deposited), and,\n * for a pause inside subflows, the checkpoint's capture of each subflow's\n * state on the way down.\n *\n * THE LAW: that structure is used EXACTLY ONCE, for the re-entry. The stand-in\n * is where the resumed traversal STARTS (or where the leaf subflow's traversal\n * starts) — it is never a node any id can resolve to. Each subflow on the pause\n * path takes its seed and its entry point on its FIRST entry and never again.\n * After that the run belongs to the real chart: every loop target, every later\n * subflow entry (real root, inputMapper runs), every re-visit of the paused\n * stage (which pauses again) resolves against the chart as built.\n *\n * ONE RULE AT EVERY LEVEL — what runs after the entry. On the original run,\n * whatever DISPATCHED the paused stage (or the mount of the next subflow on\n * the path) — a decider, a selector, a fork — ran its own continuation once\n * that child's chain ended: the decider's `next`, the fork's join. A resume\n * enters AT the child, so that continuation must be carried: the entry is\n * the child with the enclosing dispatcher's continuation attached at the end\n * of its own chain (`{ ...child, next: dispatcher.next }` for a chart the\n * builder made). It is read from the CHART, level by level — never from the\n * checkpoint, so an edited checkpoint cannot redirect a run — and it lands\n * at the level it belongs to: a top-level decider's `next` runs at the top\n * level, after the subflow's outputMapper, not inside the subflow.\n *\n * PARALLEL SIBLINGS THAT PAUSED TOO (9.28.0). When two children of one\n * fan-out paused, the checkpoint asks the first and carries the others\n * (`FlowchartCheckpoint.pendingPauses`). At that fan-out's level the entry is\n * the child's own chain only — no join — and once it ends, the next sibling's\n * pause is raised again as it was (its question, its captured state), without\n * re-running anything. The join runs only when the last sibling is resumed.\n *\n * Before 9.28.0 the structure stayed in force for the whole resumed run — the\n * traversal was ROOTED at the stand-in (so a loop back to the paused id re-ran\n * the resume half, and a loop target upstream of the resume point was\n * unreachable: one stage ran, then the run ended silently), and the leaf\n * subflow's root was SWAPPED for the stand-in in the subflow dictionary (so a\n * later entry into it would re-run the resume half on a stale seed).\n *\n * @example\n * ```typescript\n * // What FlowChartExecutor.resume() builds for a pause at 'sf-a/sf-b/ask'\n * // (subflowPath ['sf-a', 'sf-a/sf-b']), 'sf-a/sf-b' mounted as a decider\n * // branch inside sf-a whose decider continues to 'sf-a/after':\n * const entry = ResumeEntry.plan({ root, subflows, path, captures, standIn });\n * entry.start;                     // the top-level mount of 'sf-a'\n * entry.enterSubflow('sf-a');      // { seed: sf-a's capture, entry: { ...mount of 'sf-a/sf-b', next: sf-a/after } }\n * entry.enterSubflow('sf-a/sf-b'); // { seed: sf-b's capture, entry: the stand-in }\n * entry.enterSubflow('sf-a/sf-b'); // undefined — a later entry is an ordinary one\n * ```\n *\n * A pause two (or more) subflows deep therefore re-enters each outer subflow\n * AT the mount of the next one — the outer subflow's stages before that mount\n * do not run again (they did before 9.28.0). The one exception is a degraded\n * checkpoint missing an outer subflow's capture: that subflow re-runs from its\n * root with its inputMapper (its earlier stages recompute what the capture\n * would have held), exactly as 9.27.0 did.\n */\n\nimport type { PendingPause } from '../../pause/types.js';\nimport { PauseSignal } from '../../pause/types.js';\nimport type { StageNode } from '../graph/StageNode.js';\n\n/**\n * A parallel sibling's pause, queued at the level of its fan-out: raised\n * again there once the resumed child's chain ends (see {@link raiseQueuedPause}).\n */\nexport interface QueuedPause {\n  /** The sibling's pause as the checkpoint carries it — its path from the top. */\n  readonly pause: PendingPause;\n  /** How many subflows deep the fan-out sits (0 = the top level). */\n  readonly level: number;\n  /** The sibling's paused stage's name, for the `onPause` event. */\n  readonly stageName: string;\n}\n\n/** One subflow boundary on the way back to a paused stage. */\nexport interface ResumeHop<TOut = any, TScope = any> {\n  /** The path-prefixed subflow id (a `FlowchartCheckpoint.subflowPath` entry). */\n  readonly subflowId: string;\n  /**\n   * The subflow's state at the pause (`checkpoint.subflowStates[subflowId]`).\n   * Seeds the nested runtime INSTEAD of the inputMapper's values — the capture\n   * already holds the post-input, pre-pause memory (the inputMapper still\n   * runs, for the stages' read-only args only). Absent when the checkpoint\n   * holds no capture for this subflow; the inputMapper then seeds it, as on\n   * any entry.\n   */\n  readonly seed?: Record<string, unknown>;\n  /**\n   * Where this subflow's traversal starts on the re-entry: the mount of the\n   * next subflow on the path, or — on the last hop — the paused stage's\n   * stand-in, each with its dispatcher's continuation attached (see the\n   * module doc). Absent: the subflow's own root — a seed-only hop (see\n   * {@link ResumeEntry.fromCaptures}), or an outer subflow whose capture the\n   * checkpoint lacks.\n   */\n  readonly entry?: StageNode<TOut, TScope>;\n  /**\n   * Pauses of parallel siblings whose fan-out sits in THIS subflow, raised in\n   * order once `entry`'s chain ends (the first is raised, the rest wait\n   * behind it). Absent when no sibling is waiting here.\n   */\n  readonly pendingPauses?: readonly QueuedPause[];\n}\n\nexport class ResumeEntry<TOut = any, TScope = any> {\n  /**\n   * Where the resumed TOP-LEVEL traversal starts: the stand-in (a top-level\n   * pause) or the mount of the first subflow on the path — each with its\n   * dispatcher's continuation attached. `undefined` for a seed-only entry —\n   * the traversal starts at its root.\n   */\n  readonly start: StageNode<TOut, TScope> | undefined;\n  /** Sibling pauses whose fan-out sits at the TOP level — raised once `start`'s chain ends. */\n  readonly startPendingPauses: readonly QueuedPause[] | undefined;\n  /**\n   * How many stage executions the resumed run makes before the stand-in runs\n   * — one per subflow on the path, each entered at its mount — so the\n   * executor's `onResume` names the stand-in's own `runtimeStageId`.\n   * `undefined` when it cannot be known before the run: an outer subflow\n   * missing its capture re-runs from its root.\n   */\n  readonly stepsBeforeStandIn: number | undefined;\n  /** Hops not taken yet, by subflow id. A hop leaves this map when it is taken. */\n  private readonly pending: Map<string, ResumeHop<TOut, TScope>>;\n\n  private constructor(\n    start: StageNode<TOut, TScope> | undefined,\n    hops: readonly ResumeHop<TOut, TScope>[],\n    startPendingPauses?: readonly QueuedPause[],\n    stepsBeforeStandIn?: number,\n  ) {\n    this.start = start;\n    this.startPendingPauses = startPendingPauses;\n    this.stepsBeforeStandIn = stepsBeforeStandIn;\n    this.pending = new Map(hops.map((hop) => [hop.subflowId, hop]));\n  }\n\n  /**\n   * Plan the re-entry of a paused chart. Every mount on the path, every\n   * dispatcher continuation and every waiting sibling is resolved HERE,\n   * against the chart as built, before a single stage runs — so a checkpoint\n   * whose path the chart cannot walk is refused up front instead of resuming\n   * into the wrong shape.\n   *\n   * @param args - `root` and `subflows`: the chart as built\n   *   (`FlowChart.root`, `FlowChart.subflows`); `path`:\n   *   `checkpoint.subflowPath`, outermost first; `captures`:\n   *   `checkpoint.subflowStates` (a detached copy); `standIn`: the node that\n   *   runs the resume half — the paused stage's own node, function swapped\n   *   (its continuation is attached here); `pendingPauses`:\n   *   `checkpoint.pendingPauses` (a detached copy).\n   * @throws when a subflow on the path is missing, mounted more than once, or\n   *   its mount cannot be reached from the enclosing graph; or when a pending\n   *   pause is malformed or is not a parallel sibling of the paused stage\n   */\n  static plan<TOut, TScope>(args: {\n    root: StageNode<TOut, TScope>;\n    subflows: Record<string, { root: StageNode<TOut, TScope> }> | undefined;\n    path: readonly string[];\n    captures: Record<string, Record<string, unknown>> | undefined;\n    standIn: StageNode<TOut, TScope>;\n    pendingPauses?: readonly PendingPause[];\n  }): ResumeEntry<TOut, TScope> {\n    const { root, subflows, path, captures, standIn } = args;\n    const chart = new ChartIndex<TOut, TScope>();\n\n    // 1. Walk the path: the graph of every level, the mount of every subflow.\n    const graphs: StageNode<TOut, TScope>[] = [root];\n    const mounts: StageNode<TOut, TScope>[] = [];\n    for (let i = 0; i < path.length; i++) {\n      const subflowId = path[i];\n      mounts.push(chart.onlyMount(graphs[i], subflowId, i === 0 ? 'the flowchart' : `subflow '${path[i - 1]}'`));\n      // Own entries only: a path segment is data from a stored checkpoint,\n      // and `'__proto__'` must not resolve through the prototype chain.\n      const definition = ownEntry(subflows, subflowId);\n      if (!definition) {\n        throw new Error(\n          `Cannot resume: subflow '${subflowId}' is not registered in the flowchart. ` +\n            'The chart may have changed since the checkpoint was created.',\n        );\n      }\n      graphs.push(definition.root);\n    }\n    const leafLevel = path.length;\n    // The paused stage's REAL node — whose dispatcher the stand-in's\n    // continuation comes from. (The executor already found it; a direct\n    // caller's stand-in that is not in the leaf graph simply has none.)\n    const paused = chart.stage(graphs[leafLevel], standIn.id);\n\n    // 2. Queue every waiting sibling pause at the level of its fan-out.\n    const queues = queueSiblingPauses(args.pendingPauses, { chart, subflows, root, path, graphs, mounts, paused });\n\n    // 3. The one-shot entry of every level: the child, then its dispatcher's\n    //    continuation — up to the fan-out when siblings wait there.\n    const childAt = (level: number) => (level < leafLevel ? mounts[level] : paused);\n    const entryAt = (level: number): StageNode<TOut, TScope> => {\n      const child = childAt(level);\n      const replacement = level < leafLevel ? mounts[level] : standIn;\n      if (!child) return replacement;\n      return chart.entry(graphs[level], child, replacement, queues[level]?.fanOut);\n    };\n    // 4. The hops. A subflow with no capture is entered at its ROOT with its\n    //    inputMapper (its earlier stages recompute what the capture held) —\n    //    except the leaf, whose entry is always the stand-in: re-running it\n    //    from its root would ask again and lose the answer.\n    const hops: ResumeHop<TOut, TScope>[] = [];\n    let everyLevelAtItsEntry = true;\n    for (let i = 0; i < path.length; i++) {\n      const subflowId = path[i];\n      const seed = ownEntry(captures, subflowId);\n      const isLeafHop = i === path.length - 1;\n      if (seed === undefined && !isLeafHop) {\n        everyLevelAtItsEntry = false;\n        hops.push({ subflowId });\n        continue;\n      }\n      const waiting = queues[i + 1]?.pauses;\n      hops.push({\n        subflowId,\n        ...(seed !== undefined && { seed }),\n        entry: entryAt(i + 1),\n        ...(waiting && { pendingPauses: waiting }),\n      });\n    }\n    // Every level entered at its entry: one execution (the mount) per level\n    // runs before the stand-in.\n    return new ResumeEntry(entryAt(0), hops, queues[0]?.pauses, everyLevelAtItsEntry ? path.length : undefined);\n  }\n\n  /**\n   * A seed-only entry: each capture seeds the FIRST entry into its subflow,\n   * which then starts at its own root. What the deprecated\n   * `subflowStatesForResume` option (TraverserOptions / HandlerDeps) means\n   * since 9.28.0 — the same one-shot law, without a stand-in or a path.\n   */\n  static fromCaptures<TOut, TScope>(captures: Record<string, Record<string, unknown>>): ResumeEntry<TOut, TScope> {\n    return new ResumeEntry<TOut, TScope>(\n      undefined,\n      Object.entries(captures).map(([subflowId, seed]) => ({ subflowId, seed })),\n    );\n  }\n\n  /**\n   * The re-entry into `subflowId`, taken — or `undefined` when this entry is\n   * an ordinary one (the subflow is off the pause path, or its hop was already\n   * taken). ONE-SHOT: a hop is returned at most once, so a second entry into\n   * the same subflow (a loop passing its mount again) runs the real subflow\n   * from its real root with its inputMapper.\n   */\n  enterSubflow(subflowId: string): ResumeHop<TOut, TScope> | undefined {\n    const hop = this.pending.get(subflowId);\n    if (hop !== undefined) this.pending.delete(subflowId);\n    return hop;\n  }\n\n  /** `true` once every hop has been taken — the rest of the run is ordinary. */\n  get spent(): boolean {\n    return this.pending.size === 0;\n  }\n}\n\n// ── Raising a waiting sibling's pause ────────────────────────────────────────\n\n/**\n * Queue `queue` behind a pause passing through its level: a pause raised\n * while siblings still wait must carry them to its checkpoint. Each path is\n * cut to that level — the bubble-up prepends the levels above.\n */\nexport function queueBehind(signal: PauseSignal, queue: readonly QueuedPause[]): void {\n  for (const { pause, level } of queue) {\n    signal.addPendingPause({ ...pause, subflowPath: pause.subflowPath.slice(level) });\n  }\n}\n\n/**\n * The first waiting sibling's pause, raised again at its fan-out's level —\n * exactly as it bubbled up to that level the first time (its stage, its\n * question, its own subflow captures), nothing re-run; the rest of the queue\n * waits behind it. The subflows ABOVE the fan-out capture themselves afresh\n * as it bubbles up, so they carry what the resumed child wrote.\n */\nexport function raiseQueuedPause(queue: readonly QueuedPause[]): PauseSignal {\n  const [first, ...rest] = queue;\n  const { pause, level } = first;\n  const signal = new PauseSignal(pause.pauseData, pause.pausedStageId, pause.pausedBy);\n  const below = pause.subflowPath.slice(level);\n  for (let i = below.length - 1; i >= 0; i--) {\n    const state = ownEntry(pause.subflowStates, below[i]);\n    if (state !== undefined) signal.captureSubflowScope(below[i], state);\n    signal.prependSubflow(below[i]);\n  }\n  queueBehind(signal, rest);\n  return signal;\n}\n\n// ── Reading the chart ────────────────────────────────────────────────────────\n\n/**\n * The node that mounts `subflowId`, found by DFS from `start` over `next` and\n * `children` (loop-ref stubs skipped — they share their target's id and carry\n * nothing). Cycle-safe (visited by identity, so an absent id terminates too);\n * first match in DFS pre-order (children before `next`, like the builder).\n */\nexport function findMount<TOut, TScope>(\n  start: StageNode<TOut, TScope>,\n  subflowId: string,\n): StageNode<TOut, TScope> | undefined {\n  for (const node of dispatcherIndex(start).keys()) {\n    if (node.subflowId === subflowId) return node;\n  }\n  return undefined;\n}\n\n/**\n * Every real node of one level's graph, in DFS pre-order, mapped to the\n * DISPATCHER whose child-chain holds it — the node whose `children` it\n * descends from (a decider, a selector, a fork) — or `undefined` for a node\n * on the level's own spine. Loop stubs are skipped; visited by identity, so\n * two mounts sharing an id are both indexed and a cycle terminates.\n */\nfunction dispatcherIndex<TOut, TScope>(\n  root: StageNode<TOut, TScope>,\n): Map<StageNode<TOut, TScope>, StageNode<TOut, TScope> | undefined> {\n  const index = new Map<StageNode<TOut, TScope>, StageNode<TOut, TScope> | undefined>();\n  const stack: Array<[StageNode<TOut, TScope>, StageNode<TOut, TScope> | undefined]> = [[root, undefined]];\n  for (let top = stack.pop(); top !== undefined; top = stack.pop()) {\n    const [node, dispatcher] = top;\n    if (node.isLoopRef || index.has(node)) continue;\n    index.set(node, dispatcher);\n    // LIFO: push `next` first and children reversed, so children are visited\n    // before `next` and the first child first — pre-order, like the builder.\n    if (node.next) stack.push([node.next, dispatcher]);\n    if (node.children) {\n      for (let i = node.children.length - 1; i >= 0; i--) stack.push([node.children[i], node]);\n    }\n  }\n  return index;\n}\n\n/** One plan's view of the chart: each level's index built once. */\nclass ChartIndex<TOut, TScope> {\n  private readonly indexes = new Map<\n    StageNode<TOut, TScope>,\n    Map<StageNode<TOut, TScope>, StageNode<TOut, TScope> | undefined>\n  >();\n\n  private of(root: StageNode<TOut, TScope>) {\n    let index = this.indexes.get(root);\n    if (!index) {\n      index = dispatcherIndex(root);\n      this.indexes.set(root, index);\n    }\n    return index;\n  }\n\n  /** Every mount of `subflowId` in `root`'s graph, in DFS pre-order. */\n  mountsOf(root: StageNode<TOut, TScope>, subflowId: string): StageNode<TOut, TScope>[] {\n    return [...this.of(root).keys()].filter((node) => node.subflowId === subflowId);\n  }\n\n  /** The one mount of `subflowId` in `root`'s graph — refused when absent or ambiguous. */\n  onlyMount(root: StageNode<TOut, TScope>, subflowId: string, graphName: string): StageNode<TOut, TScope> {\n    const found = this.mountsOf(root, subflowId);\n    if (found.length === 0) {\n      throw new Error(\n        `Cannot resume: the mount of subflow '${subflowId}' is not reachable from ${graphName}. ` +\n          \"The checkpoint's subflowPath does not match this chart — it may have changed since the checkpoint was created.\",\n      );\n    }\n    if (found.length > 1) {\n      throw new Error(\n        `Cannot resume: subflow '${subflowId}' is mounted more than once in ${graphName} ` +\n          `(${found.map((node) => `'${node.name}'`).join(', ')}), and a checkpoint's subflowPath cannot say which ` +\n          'mount paused. Give each mount its own subflow id to make a pause inside it resumable.',\n      );\n    }\n    return found[0];\n  }\n\n  /** The real stage `id` in `root`'s graph (first in DFS pre-order), if any. */\n  stage(root: StageNode<TOut, TScope>, id: string): StageNode<TOut, TScope> | undefined {\n    for (const node of this.of(root).keys()) if (node.id === id) return node;\n    return undefined;\n  }\n\n  /** The dispatcher whose child-chain holds `node` in `root`'s graph (`undefined` on the spine). */\n  dispatcherOf(root: StageNode<TOut, TScope>, node: StageNode<TOut, TScope>): StageNode<TOut, TScope> | undefined {\n    return this.of(root).get(node);\n  }\n\n  /**\n   * The one-shot entry for `child` (a mount on the path, or the paused stage)\n   * in `root`'s graph: `replacement` (the node that runs — the mount itself,\n   * or the stand-in) with what ran after `child`'s chain on the original run\n   * attached where that chain ends — `{ ...child, next: dispatcher.next }` for\n   * a chart the builder made:\n   *\n   *   • on the level's spine: nothing to attach — the spine goes on by itself;\n   *   • a DECIDER's or SELECTOR's branch: the dispatcher's `next`;\n   *   • a FORK child: the fork's `next` — its join.\n   *\n   * Past a dispatcher with no `next`, the walk goes on OUTWARD to the one\n   * enclosing it. It stops at `stopAt` — the fan-out where siblings still\n   * wait, whose join must not run yet. Nothing to attach: `replacement`\n   * itself.\n   */\n  entry(\n    root: StageNode<TOut, TScope>,\n    child: StageNode<TOut, TScope>,\n    replacement: StageNode<TOut, TScope>,\n    stopAt: StageNode<TOut, TScope> | undefined,\n  ): StageNode<TOut, TScope> {\n    return appendAtChainEnd(replacement, this.after(root, child, stopAt));\n  }\n\n  /**\n   * What runs once `node`'s chain ends: its dispatcher's `next` chain, then —\n   * where THAT ends — the continuation of the dispatcher enclosing it, outward,\n   * up to `stopAt` (exclusive). `undefined` on the spine.\n   */\n  private after(\n    root: StageNode<TOut, TScope>,\n    node: StageNode<TOut, TScope>,\n    stopAt: StageNode<TOut, TScope> | undefined,\n  ): StageNode<TOut, TScope> | undefined {\n    const dispatcher = this.dispatcherOf(root, node);\n    if (dispatcher === undefined || dispatcher === stopAt) return undefined;\n    const outer = this.after(root, dispatcher, stopAt);\n    return dispatcher.next ? appendAtChainEnd(dispatcher.next, outer) : outer;\n  }\n}\n\n/**\n * `start`'s chain with `after` attached where it ends — the chain's nodes\n * copied on the way (never registered anywhere: ids still resolve to the real\n * nodes). A chain that ends in a loop stub (or loops back on itself) is\n * returned as is: control leaves it through the loop, never \"after\" it.\n */\nfunction appendAtChainEnd<TOut, TScope>(\n  start: StageNode<TOut, TScope>,\n  after: StageNode<TOut, TScope> | undefined,\n): StageNode<TOut, TScope> {\n  if (after === undefined) return start;\n  const chain: StageNode<TOut, TScope>[] = [];\n  const seen = new Set<StageNode<TOut, TScope>>();\n  for (let node: StageNode<TOut, TScope> | undefined = start; node !== undefined; node = node.next) {\n    if (node.isLoopRef || seen.has(node)) return start;\n    seen.add(node);\n    chain.push(node);\n  }\n  let next = after;\n  for (let i = chain.length - 1; i >= 0; i--) next = { ...chain[i], next };\n  return next;\n}\n\n// ── Waiting siblings ─────────────────────────────────────────────────────────\n\n/** The sibling pauses waiting at one level, and the fan-out they wait in. */\ninterface LevelQueue<TOut, TScope> {\n  readonly fanOut: StageNode<TOut, TScope>;\n  readonly pauses: QueuedPause[];\n}\n\n/**\n * Validate `checkpoint.pendingPauses` (untrusted input) and queue each at the\n * level of its fan-out: the depth where its path parts from the paused\n * stage's. There, the paused stage's child (a mount on the path, or the stage\n * itself) and the sibling's must both hang off ONE parallel dispatcher — a\n * fork or a selector — or the record is not a sibling and the resume is\n * refused rather than asked a question the chart could not have raised.\n */\nfunction queueSiblingPauses<TOut, TScope>(\n  pending: readonly PendingPause[] | undefined,\n  at: {\n    chart: ChartIndex<TOut, TScope>;\n    subflows: Record<string, { root: StageNode<TOut, TScope> }> | undefined;\n    root: StageNode<TOut, TScope>;\n    path: readonly string[];\n    graphs: readonly StageNode<TOut, TScope>[];\n    mounts: readonly StageNode<TOut, TScope>[];\n    paused: StageNode<TOut, TScope> | undefined;\n  },\n): Array<LevelQueue<TOut, TScope> | undefined> {\n  const queues: Array<LevelQueue<TOut, TScope> | undefined> = [];\n  if (pending === undefined) return queues;\n  if (!Array.isArray(pending)) throw new Error('Invalid checkpoint: pendingPauses must be an array.');\n  const { chart, subflows, root, path, graphs, mounts, paused } = at;\n  const seen = new Set<string>();\n\n  pending.forEach((raw: unknown, n) => {\n    const pause = validPendingPause(raw, n);\n    // One record per paused sibling: a repeat would ask the same question twice.\n    const key = JSON.stringify([pause.subflowPath, pause.pausedStageId]);\n    if (seen.has(key)) {\n      throw new Error(\n        `Cannot resume: checkpoint.pendingPauses[${n}] ('${pause.pausedStageId}') repeats an earlier entry.`,\n      );\n    }\n    seen.add(key);\n    let level = 0;\n    while (level < path.length && level < pause.subflowPath.length && path[level] === pause.subflowPath[level]) level++;\n    const graph = graphs[level];\n    const ours = level < path.length ? mounts[level] : paused;\n    const theirMounts = level < pause.subflowPath.length ? chart.mountsOf(graph, pause.subflowPath[level]) : [];\n    const theirs =\n      level < pause.subflowPath.length\n        ? theirMounts.length === 1\n          ? theirMounts[0]\n          : undefined\n        : chart.stage(graph, pause.pausedStageId);\n    const fanOut = ours ? chart.dispatcherOf(graph, ours) : undefined;\n    const isSibling =\n      ours !== undefined &&\n      theirs !== undefined &&\n      ours !== theirs &&\n      fanOut !== undefined &&\n      chart.dispatcherOf(graph, theirs) === fanOut &&\n      !fanOut.deciderFn &&\n      (queues[level] === undefined || queues[level]!.fanOut === fanOut);\n    if (!isSibling || !walksToItsStage(chart, subflows, graph, pause, level)) {\n      throw new Error(\n        `Cannot resume: checkpoint.pendingPauses[${n}] ('${pause.pausedStageId}') is not a parallel sibling of ` +\n          `the paused stage '${paused?.id ?? '?'}' in this chart — no fork or selector runs them both, or its ` +\n          'path does not lead to that stage. The chart may have changed since the checkpoint was created.',\n      );\n    }\n    const leafRoot =\n      pause.subflowPath.length === 0 ? root : ownEntry(subflows, pause.subflowPath[pause.subflowPath.length - 1])?.root;\n    const stageName = (leafRoot && chart.stage(leafRoot, pause.pausedStageId)?.name) ?? pause.pausedStageId;\n    const queue = (queues[level] ??= { fanOut: fanOut!, pauses: [] });\n    queue.pauses.push({ pause, level, stageName });\n  });\n  return queues;\n}\n\n/**\n * Whether a waiting sibling's WHOLE path below its fan-out walks this chart:\n * every segment the only mount of its subflow in the enclosing graph, every\n * subflow registered, and the paused stage in the last graph — checked at\n * the FIRST resume, so a tampered record is refused up front, not when its\n * turn comes.\n */\nfunction walksToItsStage<TOut, TScope>(\n  chart: ChartIndex<TOut, TScope>,\n  subflows: Record<string, { root: StageNode<TOut, TScope> }> | undefined,\n  fanOutGraph: StageNode<TOut, TScope>,\n  pause: PendingPause,\n  level: number,\n): boolean {\n  let graph = fanOutGraph;\n  for (let i = level; i < pause.subflowPath.length; i++) {\n    if (chart.mountsOf(graph, pause.subflowPath[i]).length !== 1) return false;\n    const definition = ownEntry(subflows, pause.subflowPath[i]);\n    if (!definition) return false;\n    graph = definition.root;\n  }\n  return chart.stage(graph, pause.pausedStageId) !== undefined;\n}\n\n/** One `pendingPauses` entry, checked field by field — it comes from stored, untrusted data. */\nfunction validPendingPause(raw: unknown, n: number): PendingPause {\n  const refuse = (what: string): never => {\n    throw new Error(`Invalid checkpoint: pendingPauses[${n}] ${what}.`);\n  };\n  if (raw === null || typeof raw !== 'object' || Array.isArray(raw)) refuse('must be an object');\n  const record = raw as Record<string, unknown>;\n  if (typeof record.pausedStageId !== 'string' || record.pausedStageId === '') {\n    refuse('must name its paused stage (pausedStageId, a non-empty string)');\n  }\n  const subflowPath = record.subflowPath;\n  if (!Array.isArray(subflowPath) || !subflowPath.every((s) => typeof s === 'string')) {\n    refuse('must carry its subflowPath (an array of strings)');\n  }\n  const states = record.subflowStates;\n  if (states !== undefined && (states === null || typeof states !== 'object' || Array.isArray(states))) {\n    refuse('must carry its subflowStates as an object');\n  }\n  if (record.pausedBy !== undefined && record.pausedBy !== 'interrupt')\n    refuse(\"has an unknown pausedBy (only 'interrupt')\");\n  return {\n    pausedStageId: record.pausedStageId as string,\n    subflowPath: subflowPath as string[],\n    subflowStates: (states as Record<string, Record<string, unknown>> | undefined) ?? {},\n    ...(record.pauseData !== undefined && { pauseData: record.pauseData }),\n    ...(record.pausedBy === 'interrupt' && { pausedBy: 'interrupt' as const }),\n  };\n}\n\n/** `record[key]` only when it is the record's OWN property — never through the prototype chain. */\nfunction ownEntry<T>(record: Record<string, T> | undefined, key: string): T | undefined {\n  return record && Object.prototype.hasOwnProperty.call(record, key) ? record[key] : undefined;\n}\n"]}

package/dist/esm/lib/engine/handlers/SubflowExecutor.d.ts

@@ -20,6 +20,12 @@ import type { BreakFlag } from './types.js';
 export declare class SubflowExecutor<TOut = any, TScope = any> {
     private deps;
     private traverserFactory;
+    /**
+     * The resume's one-shot re-entry (`deps.resume`), or a seed-only one built
+     * from the deprecated `deps.subflowStatesForResume`. Undefined on a normal
+     * run. Asked once per subflow entry — see {@link ResumeEntry}.
+     */
+    private readonly resume;
     constructor(deps: HandlerDeps<TOut, TScope>, traverserFactory: SubflowTraverserFactory<TOut, TScope>);
     /**
      * Execute a subflow with isolated context.