footprintjs 9.26.0 → 9.28.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (54) hide show
  1. package/AGENTS.md +3 -0
  2. package/CLAUDE.md +5 -4
  3. package/README.md +4 -0
  4. package/dist/advanced.js +3 -2
  5. package/dist/esm/advanced.d.ts +2 -2
  6. package/dist/esm/advanced.js +2 -2
  7. package/dist/esm/index.d.ts +1 -1
  8. package/dist/esm/index.js +1 -1
  9. package/dist/esm/lib/builder/FlowChartBuilder.d.ts +10 -0
  10. package/dist/esm/lib/builder/FlowChartBuilder.js +27 -13
  11. package/dist/esm/lib/engine/handlers/ChildrenExecutor.js +45 -12
  12. package/dist/esm/lib/engine/handlers/ResumeEntry.d.ts +195 -0
  13. package/dist/esm/lib/engine/handlers/ResumeEntry.js +471 -0
  14. package/dist/esm/lib/engine/handlers/SubflowExecutor.d.ts +6 -0
  15. package/dist/esm/lib/engine/handlers/SubflowExecutor.js +43 -10
  16. package/dist/esm/lib/engine/handlers/index.d.ts +2 -0
  17. package/dist/esm/lib/engine/handlers/index.js +2 -1
  18. package/dist/esm/lib/engine/narrative/CombinedNarrativeRecorder.d.ts +1 -1
  19. package/dist/esm/lib/engine/traversal/FlowchartTraverser.d.ts +49 -4
  20. package/dist/esm/lib/engine/traversal/FlowchartTraverser.js +64 -13
  21. package/dist/esm/lib/engine/types.d.ts +30 -11
  22. package/dist/esm/lib/engine/types.js +1 -1
  23. package/dist/esm/lib/pause/index.d.ts +1 -1
  24. package/dist/esm/lib/pause/index.js +1 -1
  25. package/dist/esm/lib/pause/types.d.ts +93 -5
  26. package/dist/esm/lib/pause/types.js +57 -3
  27. package/dist/esm/lib/runner/FlowChartExecutor.d.ts +8 -10
  28. package/dist/esm/lib/runner/FlowChartExecutor.js +153 -181
  29. package/dist/esm/lib/time-travel/bundles.js +11 -1
  30. package/dist/index.js +1 -1
  31. package/dist/lib/builder/FlowChartBuilder.js +27 -13
  32. package/dist/lib/engine/handlers/ChildrenExecutor.js +45 -12
  33. package/dist/lib/engine/handlers/ResumeEntry.js +478 -0
  34. package/dist/lib/engine/handlers/SubflowExecutor.js +43 -10
  35. package/dist/lib/engine/handlers/index.js +4 -2
  36. package/dist/lib/engine/traversal/FlowchartTraverser.js +64 -13
  37. package/dist/lib/engine/types.js +1 -1
  38. package/dist/lib/pause/index.js +1 -1
  39. package/dist/lib/pause/types.js +57 -3
  40. package/dist/lib/runner/FlowChartExecutor.js +153 -181
  41. package/dist/lib/time-travel/bundles.js +11 -1
  42. package/dist/types/advanced.d.ts +2 -2
  43. package/dist/types/index.d.ts +1 -1
  44. package/dist/types/lib/builder/FlowChartBuilder.d.ts +10 -0
  45. package/dist/types/lib/engine/handlers/ResumeEntry.d.ts +195 -0
  46. package/dist/types/lib/engine/handlers/SubflowExecutor.d.ts +6 -0
  47. package/dist/types/lib/engine/handlers/index.d.ts +2 -0
  48. package/dist/types/lib/engine/narrative/CombinedNarrativeRecorder.d.ts +1 -1
  49. package/dist/types/lib/engine/traversal/FlowchartTraverser.d.ts +49 -4
  50. package/dist/types/lib/engine/types.d.ts +30 -11
  51. package/dist/types/lib/pause/index.d.ts +1 -1
  52. package/dist/types/lib/pause/types.d.ts +93 -5
  53. package/dist/types/lib/runner/FlowChartExecutor.d.ts +8 -10
  54. package/package.json +1 -1
@@ -89,6 +89,16 @@ function bundleRefusal(row) {
89
89
  return 'updates is not a plain object';
90
90
  if (row.overwrite !== undefined && !isPlainish(row.overwrite))
91
91
  return 'overwrite is not a plain object';
92
+ // The four verbs are the contract (9.27.0). The replay's switch used to
93
+ // treat anything else as `merge` — a silent coercion of a row a foreign
94
+ // producer got wrong. A bundle with such a row is a gap, and says which.
95
+ for (let i = 0; i < row.trace.length; i++) {
96
+ const entry = row.trace[i];
97
+ const verb = isPlainish(entry) ? entry.verb : undefined;
98
+ if (verb !== 'set' && verb !== 'merge' && verb !== 'append' && verb !== 'delete') {
99
+ return `trace[${i}].verb is ${verb === undefined ? 'missing' : JSON.stringify(verb)}, not set | merge | append | delete`;
100
+ }
101
+ }
92
102
  return undefined;
93
103
  }
94
104
  exports.bundleRefusal = bundleRefusal;
@@ -129,4 +139,4 @@ function readLog(raw) {
129
139
  return { log, gaps: Object.freeze(gaps) };
130
140
  }
131
141
  exports.readLog = readLog;
132
- //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bundles.js","sourceRoot":"","sources":["../../../src/lib/time-travel/bundles.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * bundles.ts — reading a log whose rows are not typed yet.\n *\n * WHY THIS FILE EXISTS. A LIVE snapshot hands time travel real\n * {@link CommitBundle}s. A STORED recording hands it parsed JSON, and a\n * careful consumer will not claim that what came back off disk is a\n * `CommitBundle` — so it either casts (a lie with a comment on it) or cannot\n * call the library at all. Since 9.18.0 the source takes `readonly unknown[]`\n * and the narrowing happens here, per row, at the one place that actually\n * reads one.\n *\n * A row that is not a bundle becomes a GAP rather than an exception: it KEEPS\n * ITS INDEX — so every `commitIdx` in the axis still addresses the same\n * position — contributes no state, gets no stop, and is reported with its\n * index and a reason. One corrupt row in a stored recording loses that row,\n * not the recording.\n */\n\nimport type { CommitBundle, StageSnapshot } from '../memory/types.js';\nimport type { LogGap } from './types.js';\n\n/**\n * The stand-in a gap leaves at its index: a commit that belongs to no stage\n * and carries nothing.\n *\n * It is NOT invented evidence — every field is the empty value, and an id-less\n * bundle is a shape the log already has (a root-context commit made before any\n * stage ran). `commitStops` gives it no stop for exactly that reason, the fold\n * folds nothing from it, and `changedSince` reads no keys off it. What it does\n * is hold the index, so the arithmetic downstream never has to know.\n */\nconst GAP_BUNDLE: CommitBundle = Object.freeze({\n  stage: '',\n  stageId: '',\n  runtimeStageId: '',\n  trace: Object.freeze([]) as unknown as CommitBundle['trace'],\n  redactedPaths: Object.freeze([]) as unknown as string[],\n  overwrite: Object.freeze({}),\n  updates: Object.freeze({}),\n});\n\n/** A plain object — not null, not an array, not a primitive. */\nexport function isPlainish(value: unknown): value is Record<string, unknown> {\n  return typeof value === 'object' && value !== null && !Array.isArray(value);\n}\n\n/**\n * Read a source's `executionTree` as a {@link StageSnapshot}, or as absent.\n *\n * The tree is only ever WALKED for mount ids (`subflowId` + `runtimeStageId`\n * on each node), so the honest narrowing a reader can do is \"a plain object\";\n * anything else — a stored field that came back as a string, a number, an\n * array — is read as no tree at all, which sends `commitStops` down the same\n * shape-heuristic path a log handed over without its tree already takes.\n */\nexport function readTree(value: unknown): StageSnapshot | undefined {\n  return isPlainish(value) ? (value as unknown as StageSnapshot) : undefined;\n}\n\n/**\n * Why `row` cannot be read as a commit bundle, or `undefined` when it can.\n *\n * DELIBERATELY LENIENT — but exactly as lenient as the readers are. It checks\n * what the fold, the axis and `changedSince` actually touch:\n *\n * - `runtimeStageId` must be a string — the axis keys on it.\n * - `trace` must be an ARRAY, and it must be PRESENT. It is the one field\n *   every reader WALKS (`applySmartMerge` iterates it verb by verb;\n *   `changedSince` reads its paths), so a row without one is not a bundle the\n *   fold can survive — it is the crash a gap exists to prevent. `CommitBundle`\n *   declares it required, so no live log is affected.\n * - `updates` / `overwrite`, when present, must be plain objects. They are\n *   read only AT THE PATHS THE TRACE NAMES, so an absent one is harmless and\n *   is tolerated, exactly as the fold tolerates an absent `redactedPaths`.\n *\n * Being stricter than that — demanding `stage`, `stageId`, `idx` — would\n * reject hand-built logs that have folded correctly since 9.17.0, which is a\n * compatibility break dressed up as validation.\n */\nexport function bundleRefusal(row: unknown): string | undefined {\n  if (!isPlainish(row)) {\n    return `not an object (${row === null ? 'null' : Array.isArray(row) ? 'array' : typeof row})`;\n  }\n  if (typeof row.runtimeStageId !== 'string') {\n    return `runtimeStageId is ${\n      row.runtimeStageId === undefined ? 'missing' : `a ${typeof row.runtimeStageId}`\n    }, not a string`;\n  }\n  if (!Array.isArray(row.trace)) {\n    return `trace is ${row.trace === undefined ? 'missing' : `a ${typeof row.trace}`}, not an array`;\n  }\n  if (row.updates !== undefined && !isPlainish(row.updates)) return 'updates is not a plain object';\n  if (row.overwrite !== undefined && !isPlainish(row.overwrite)) return 'overwrite is not a plain object';\n  return undefined;\n}\n\n/** `true` when `row` can be read as a {@link CommitBundle}. */\nexport function isCommitBundle(row: unknown): row is CommitBundle {\n  return bundleRefusal(row) === undefined;\n}\n\n/** A log read row by row: the bundles, index-aligned, plus what was refused. */\nexport interface ReadLog {\n  /** Same length and order as the input; a refused row holds a GAP stand-in. */\n  readonly log: readonly CommitBundle[];\n  /** The refused rows, in index order. Empty when the log was clean. */\n  readonly gaps: readonly LogGap[];\n}\n\n/** Nothing to read — shared, so the clean path allocates nothing extra. */\nconst NO_GAPS: readonly LogGap[] = Object.freeze([]);\n\n/**\n * Read an unvalidated array as a commit log.\n *\n * The clean case (a live snapshot, or a stored recording that round-tripped\n * intact) returns the SAME array reference and no gaps: nothing is copied,\n * nothing is allocated, and the fold behaves byte for byte as it did in\n * 9.17.0. Only a log with a refused row is rebuilt, and only to keep the\n * indices aligned.\n *\n * @example\n * ```typescript\n * const { log, gaps } = readLog(JSON.parse(stored).commitLog);\n * gaps; // [{ index: 3, reason: 'not an object (null)' }]\n * ```\n */\nexport function readLog(raw: readonly unknown[] | undefined): ReadLog {\n  if (!raw || raw.length === 0) return { log: [], gaps: NO_GAPS };\n\n  let gaps: LogGap[] | undefined;\n  for (let i = 0; i < raw.length; i++) {\n    const reason = bundleRefusal(raw[i]);\n    if (reason !== undefined) (gaps ??= []).push({ index: i, reason });\n  }\n  if (!gaps) return { log: raw as readonly CommitBundle[], gaps: NO_GAPS };\n\n  const log = raw.map((row) => (isCommitBundle(row) ? row : GAP_BUNDLE));\n  return { log, gaps: Object.freeze(gaps) };\n}\n"]}
142
+ //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bundles.js","sourceRoot":"","sources":["../../../src/lib/time-travel/bundles.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * bundles.ts — reading a log whose rows are not typed yet.\n *\n * WHY THIS FILE EXISTS. A LIVE snapshot hands time travel real\n * {@link CommitBundle}s. A STORED recording hands it parsed JSON, and a\n * careful consumer will not claim that what came back off disk is a\n * `CommitBundle` — so it either casts (a lie with a comment on it) or cannot\n * call the library at all. Since 9.18.0 the source takes `readonly unknown[]`\n * and the narrowing happens here, per row, at the one place that actually\n * reads one.\n *\n * A row that is not a bundle becomes a GAP rather than an exception: it KEEPS\n * ITS INDEX — so every `commitIdx` in the axis still addresses the same\n * position — contributes no state, gets no stop, and is reported with its\n * index and a reason. One corrupt row in a stored recording loses that row,\n * not the recording.\n */\n\nimport type { CommitBundle, StageSnapshot } from '../memory/types.js';\nimport type { LogGap } from './types.js';\n\n/**\n * The stand-in a gap leaves at its index: a commit that belongs to no stage\n * and carries nothing.\n *\n * It is NOT invented evidence — every field is the empty value, and an id-less\n * bundle is a shape the log already has (a root-context commit made before any\n * stage ran). `commitStops` gives it no stop for exactly that reason, the fold\n * folds nothing from it, and `changedSince` reads no keys off it. What it does\n * is hold the index, so the arithmetic downstream never has to know.\n */\nconst GAP_BUNDLE: CommitBundle = Object.freeze({\n  stage: '',\n  stageId: '',\n  runtimeStageId: '',\n  trace: Object.freeze([]) as unknown as CommitBundle['trace'],\n  redactedPaths: Object.freeze([]) as unknown as string[],\n  overwrite: Object.freeze({}),\n  updates: Object.freeze({}),\n});\n\n/** A plain object — not null, not an array, not a primitive. */\nexport function isPlainish(value: unknown): value is Record<string, unknown> {\n  return typeof value === 'object' && value !== null && !Array.isArray(value);\n}\n\n/**\n * Read a source's `executionTree` as a {@link StageSnapshot}, or as absent.\n *\n * The tree is only ever WALKED for mount ids (`subflowId` + `runtimeStageId`\n * on each node), so the honest narrowing a reader can do is \"a plain object\";\n * anything else — a stored field that came back as a string, a number, an\n * array — is read as no tree at all, which sends `commitStops` down the same\n * shape-heuristic path a log handed over without its tree already takes.\n */\nexport function readTree(value: unknown): StageSnapshot | undefined {\n  return isPlainish(value) ? (value as unknown as StageSnapshot) : undefined;\n}\n\n/**\n * Why `row` cannot be read as a commit bundle, or `undefined` when it can.\n *\n * DELIBERATELY LENIENT — but exactly as lenient as the readers are. It checks\n * what the fold, the axis and `changedSince` actually touch:\n *\n * - `runtimeStageId` must be a string — the axis keys on it.\n * - `trace` must be an ARRAY, and it must be PRESENT. It is the one field\n *   every reader WALKS (`applySmartMerge` iterates it verb by verb;\n *   `changedSince` reads its paths), so a row without one is not a bundle the\n *   fold can survive — it is the crash a gap exists to prevent. `CommitBundle`\n *   declares it required, so no live log is affected.\n * - `updates` / `overwrite`, when present, must be plain objects. They are\n *   read only AT THE PATHS THE TRACE NAMES, so an absent one is harmless and\n *   is tolerated, exactly as the fold tolerates an absent `redactedPaths`.\n *\n * Being stricter than that — demanding `stage`, `stageId`, `idx` — would\n * reject hand-built logs that have folded correctly since 9.17.0, which is a\n * compatibility break dressed up as validation.\n */\nexport function bundleRefusal(row: unknown): string | undefined {\n  if (!isPlainish(row)) {\n    return `not an object (${row === null ? 'null' : Array.isArray(row) ? 'array' : typeof row})`;\n  }\n  if (typeof row.runtimeStageId !== 'string') {\n    return `runtimeStageId is ${\n      row.runtimeStageId === undefined ? 'missing' : `a ${typeof row.runtimeStageId}`\n    }, not a string`;\n  }\n  if (!Array.isArray(row.trace)) {\n    return `trace is ${row.trace === undefined ? 'missing' : `a ${typeof row.trace}`}, not an array`;\n  }\n  if (row.updates !== undefined && !isPlainish(row.updates)) return 'updates is not a plain object';\n  if (row.overwrite !== undefined && !isPlainish(row.overwrite)) return 'overwrite is not a plain object';\n  // The four verbs are the contract (9.27.0). The replay's switch used to\n  // treat anything else as `merge` — a silent coercion of a row a foreign\n  // producer got wrong. A bundle with such a row is a gap, and says which.\n  for (let i = 0; i < row.trace.length; i++) {\n    const entry: unknown = row.trace[i];\n    const verb = isPlainish(entry) ? entry.verb : undefined;\n    if (verb !== 'set' && verb !== 'merge' && verb !== 'append' && verb !== 'delete') {\n      return `trace[${i}].verb is ${\n        verb === undefined ? 'missing' : JSON.stringify(verb)\n      }, not set | merge | append | delete`;\n    }\n  }\n  return undefined;\n}\n\n/** `true` when `row` can be read as a {@link CommitBundle}. */\nexport function isCommitBundle(row: unknown): row is CommitBundle {\n  return bundleRefusal(row) === undefined;\n}\n\n/** A log read row by row: the bundles, index-aligned, plus what was refused. */\nexport interface ReadLog {\n  /** Same length and order as the input; a refused row holds a GAP stand-in. */\n  readonly log: readonly CommitBundle[];\n  /** The refused rows, in index order. Empty when the log was clean. */\n  readonly gaps: readonly LogGap[];\n}\n\n/** Nothing to read — shared, so the clean path allocates nothing extra. */\nconst NO_GAPS: readonly LogGap[] = Object.freeze([]);\n\n/**\n * Read an unvalidated array as a commit log.\n *\n * The clean case (a live snapshot, or a stored recording that round-tripped\n * intact) returns the SAME array reference and no gaps: nothing is copied,\n * nothing is allocated, and the fold behaves byte for byte as it did in\n * 9.17.0. Only a log with a refused row is rebuilt, and only to keep the\n * indices aligned.\n *\n * @example\n * ```typescript\n * const { log, gaps } = readLog(JSON.parse(stored).commitLog);\n * gaps; // [{ index: 3, reason: 'not an object (null)' }]\n * ```\n */\nexport function readLog(raw: readonly unknown[] | undefined): ReadLog {\n  if (!raw || raw.length === 0) return { log: [], gaps: NO_GAPS };\n\n  let gaps: LogGap[] | undefined;\n  for (let i = 0; i < raw.length; i++) {\n    const reason = bundleRefusal(raw[i]);\n    if (reason !== undefined) (gaps ??= []).push({ index: i, reason });\n  }\n  if (!gaps) return { log: raw as readonly CommitBundle[], gaps: NO_GAPS };\n\n  const log = raw.map((row) => (isCommitBundle(row) ? row : GAP_BUNDLE));\n  return { log, gaps: Object.freeze(gaps) };\n}\n"]}
@@ -47,8 +47,8 @@ export type { IControlFlowNarrative } from './lib/engine/index.js';
47
47
  export type { CombinedNarrativeEntry, CombinedNarrativeOptions } from './lib/engine/index.js';
48
48
  export type { BranchResult, BranchResults, SerializedPipelineStructure as EngineSerializedPipelineStructure, HandlerDeps, IExecutionRuntime, NodeResultType, RuntimeStructureMetadata, ScopeFactory, SerializedPipelineNode, StageFunction, SubflowResult, TraversalResult, } from './lib/engine/index.js';
49
49
  export { NullControlFlowNarrativeGenerator } from './lib/engine/index.js';
50
- export type { ExecuteNodeFn, RunStageFn } from './lib/engine/index.js';
51
- export { applyOutputMapping, ChildrenExecutor, computeNodeType, ContinuationResolver, createSubflowHandlerDeps, DeciderHandler, DEFAULT_MAX_ITERATIONS, extractParentScopeValues, getInitialScopeValues, NodeResolver, RuntimeStructureManager, seedSubflowGlobalStore, SelectorHandler, StageRunner, SubflowExecutor, } from './lib/engine/index.js';
50
+ export type { ExecuteNodeFn, QueuedPause, ResumeHop, RunStageFn } from './lib/engine/index.js';
51
+ export { applyOutputMapping, ChildrenExecutor, computeNodeType, ContinuationResolver, createSubflowHandlerDeps, DeciderHandler, DEFAULT_MAX_ITERATIONS, extractParentScopeValues, getInitialScopeValues, NodeResolver, ResumeEntry, RuntimeStructureManager, seedSubflowGlobalStore, SelectorHandler, StageRunner, SubflowExecutor, } from './lib/engine/index.js';
52
52
  export type { ExecutionCounter } from './lib/engine/runtimeStageId.js';
53
53
  export { buildRuntimeStageId, createExecutionCounter, parseRuntimeStageId } from './lib/engine/runtimeStageId.js';
54
54
  export { findCommit, findCommits, findLastWriter } from './lib/memory/commitLogUtils.js';
@@ -138,7 +138,7 @@ export { getSubtreeSnapshot, listSubflowPaths } from './lib/runner/index.js';
138
138
  export { CompositeRecorder } from './lib/recorder/index.js';
139
139
  /** @category Pause/Resume */
140
140
  /** @category Pause/Resume */
141
- export type { FlowchartCheckpoint, PausableHandler } from './lib/pause/index.js';
141
+ export type { FlowchartCheckpoint, PausableHandler, PendingPause } from './lib/pause/index.js';
142
142
  /**
143
143
  * @category Pause/Resume
144
144
  *
@@ -621,6 +621,16 @@ export declare class FlowChartBuilder<TOut = any, TScope = any> {
621
621
  private _cursorTail?;
622
622
  private _advanceCursorSpec;
623
623
  _stageMapHas(key: string): boolean;
624
+ /**
625
+ * @internal Register a mounted subflow's definition — first mount wins,
626
+ * at every eager mount site (linear, fork child, decider and selector
627
+ * branch). A SECOND mount under the same id is allowed (existing charts do
628
+ * it) and shares the first one's definition — but a pause inside either
629
+ * cannot be resumed: a checkpoint's `subflowPath` names the subflow id, not
630
+ * the mount, so `resume()` refuses the ambiguous path. Dev mode says so
631
+ * here, at build time, where the id can still be changed.
632
+ */
633
+ _registerSubflowDef(id: string, root: StageNode<TOut, TScope>): void;
624
634
  _addToMap(id: string, fn: StageFunction<TOut, TScope>): void;
625
635
  _mergeStageMap(other: Map<string, StageFunction<TOut, TScope>>, prefix?: string): void;
626
636
  /**
@@ -0,0 +1,195 @@
1
+ /**
2
+ * ResumeEntry — the resume's ONE-SHOT re-entry (M2, pause/resume).
3
+ *
4
+ * A resume has to get back to a stage in the middle of a chart. It does that
5
+ * with a small synthetic structure: a stand-in for the paused stage (the
6
+ * stage's own node with its function swapped for the resume half — or, for an
7
+ * `interrupt()` pause, for its own function with the answer deposited), and,
8
+ * for a pause inside subflows, the checkpoint's capture of each subflow's
9
+ * state on the way down.
10
+ *
11
+ * THE LAW: that structure is used EXACTLY ONCE, for the re-entry. The stand-in
12
+ * is where the resumed traversal STARTS (or where the leaf subflow's traversal
13
+ * starts) — it is never a node any id can resolve to. Each subflow on the pause
14
+ * path takes its seed and its entry point on its FIRST entry and never again.
15
+ * After that the run belongs to the real chart: every loop target, every later
16
+ * subflow entry (real root, inputMapper runs), every re-visit of the paused
17
+ * stage (which pauses again) resolves against the chart as built.
18
+ *
19
+ * ONE RULE AT EVERY LEVEL — what runs after the entry. On the original run,
20
+ * whatever DISPATCHED the paused stage (or the mount of the next subflow on
21
+ * the path) — a decider, a selector, a fork — ran its own continuation once
22
+ * that child's chain ended: the decider's `next`, the fork's join. A resume
23
+ * enters AT the child, so that continuation must be carried: the entry is
24
+ * the child with the enclosing dispatcher's continuation attached at the end
25
+ * of its own chain (`{ ...child, next: dispatcher.next }` for a chart the
26
+ * builder made). It is read from the CHART, level by level — never from the
27
+ * checkpoint, so an edited checkpoint cannot redirect a run — and it lands
28
+ * at the level it belongs to: a top-level decider's `next` runs at the top
29
+ * level, after the subflow's outputMapper, not inside the subflow.
30
+ *
31
+ * PARALLEL SIBLINGS THAT PAUSED TOO (9.28.0). When two children of one
32
+ * fan-out paused, the checkpoint asks the first and carries the others
33
+ * (`FlowchartCheckpoint.pendingPauses`). At that fan-out's level the entry is
34
+ * the child's own chain only — no join — and once it ends, the next sibling's
35
+ * pause is raised again as it was (its question, its captured state), without
36
+ * re-running anything. The join runs only when the last sibling is resumed.
37
+ *
38
+ * Before 9.28.0 the structure stayed in force for the whole resumed run — the
39
+ * traversal was ROOTED at the stand-in (so a loop back to the paused id re-ran
40
+ * the resume half, and a loop target upstream of the resume point was
41
+ * unreachable: one stage ran, then the run ended silently), and the leaf
42
+ * subflow's root was SWAPPED for the stand-in in the subflow dictionary (so a
43
+ * later entry into it would re-run the resume half on a stale seed).
44
+ *
45
+ * @example
46
+ * ```typescript
47
+ * // What FlowChartExecutor.resume() builds for a pause at 'sf-a/sf-b/ask'
48
+ * // (subflowPath ['sf-a', 'sf-a/sf-b']), 'sf-a/sf-b' mounted as a decider
49
+ * // branch inside sf-a whose decider continues to 'sf-a/after':
50
+ * const entry = ResumeEntry.plan({ root, subflows, path, captures, standIn });
51
+ * entry.start; // the top-level mount of 'sf-a'
52
+ * entry.enterSubflow('sf-a'); // { seed: sf-a's capture, entry: { ...mount of 'sf-a/sf-b', next: sf-a/after } }
53
+ * entry.enterSubflow('sf-a/sf-b'); // { seed: sf-b's capture, entry: the stand-in }
54
+ * entry.enterSubflow('sf-a/sf-b'); // undefined — a later entry is an ordinary one
55
+ * ```
56
+ *
57
+ * A pause two (or more) subflows deep therefore re-enters each outer subflow
58
+ * AT the mount of the next one — the outer subflow's stages before that mount
59
+ * do not run again (they did before 9.28.0). The one exception is a degraded
60
+ * checkpoint missing an outer subflow's capture: that subflow re-runs from its
61
+ * root with its inputMapper (its earlier stages recompute what the capture
62
+ * would have held), exactly as 9.27.0 did.
63
+ */
64
+ import type { PendingPause } from '../../pause/types.js';
65
+ import { PauseSignal } from '../../pause/types.js';
66
+ import type { StageNode } from '../graph/StageNode.js';
67
+ /**
68
+ * A parallel sibling's pause, queued at the level of its fan-out: raised
69
+ * again there once the resumed child's chain ends (see {@link raiseQueuedPause}).
70
+ */
71
+ export interface QueuedPause {
72
+ /** The sibling's pause as the checkpoint carries it — its path from the top. */
73
+ readonly pause: PendingPause;
74
+ /** How many subflows deep the fan-out sits (0 = the top level). */
75
+ readonly level: number;
76
+ /** The sibling's paused stage's name, for the `onPause` event. */
77
+ readonly stageName: string;
78
+ }
79
+ /** One subflow boundary on the way back to a paused stage. */
80
+ export interface ResumeHop<TOut = any, TScope = any> {
81
+ /** The path-prefixed subflow id (a `FlowchartCheckpoint.subflowPath` entry). */
82
+ readonly subflowId: string;
83
+ /**
84
+ * The subflow's state at the pause (`checkpoint.subflowStates[subflowId]`).
85
+ * Seeds the nested runtime INSTEAD of the inputMapper's values — the capture
86
+ * already holds the post-input, pre-pause memory (the inputMapper still
87
+ * runs, for the stages' read-only args only). Absent when the checkpoint
88
+ * holds no capture for this subflow; the inputMapper then seeds it, as on
89
+ * any entry.
90
+ */
91
+ readonly seed?: Record<string, unknown>;
92
+ /**
93
+ * Where this subflow's traversal starts on the re-entry: the mount of the
94
+ * next subflow on the path, or — on the last hop — the paused stage's
95
+ * stand-in, each with its dispatcher's continuation attached (see the
96
+ * module doc). Absent: the subflow's own root — a seed-only hop (see
97
+ * {@link ResumeEntry.fromCaptures}), or an outer subflow whose capture the
98
+ * checkpoint lacks.
99
+ */
100
+ readonly entry?: StageNode<TOut, TScope>;
101
+ /**
102
+ * Pauses of parallel siblings whose fan-out sits in THIS subflow, raised in
103
+ * order once `entry`'s chain ends (the first is raised, the rest wait
104
+ * behind it). Absent when no sibling is waiting here.
105
+ */
106
+ readonly pendingPauses?: readonly QueuedPause[];
107
+ }
108
+ export declare class ResumeEntry<TOut = any, TScope = any> {
109
+ /**
110
+ * Where the resumed TOP-LEVEL traversal starts: the stand-in (a top-level
111
+ * pause) or the mount of the first subflow on the path — each with its
112
+ * dispatcher's continuation attached. `undefined` for a seed-only entry —
113
+ * the traversal starts at its root.
114
+ */
115
+ readonly start: StageNode<TOut, TScope> | undefined;
116
+ /** Sibling pauses whose fan-out sits at the TOP level — raised once `start`'s chain ends. */
117
+ readonly startPendingPauses: readonly QueuedPause[] | undefined;
118
+ /**
119
+ * How many stage executions the resumed run makes before the stand-in runs
120
+ * — one per subflow on the path, each entered at its mount — so the
121
+ * executor's `onResume` names the stand-in's own `runtimeStageId`.
122
+ * `undefined` when it cannot be known before the run: an outer subflow
123
+ * missing its capture re-runs from its root.
124
+ */
125
+ readonly stepsBeforeStandIn: number | undefined;
126
+ /** Hops not taken yet, by subflow id. A hop leaves this map when it is taken. */
127
+ private readonly pending;
128
+ private constructor();
129
+ /**
130
+ * Plan the re-entry of a paused chart. Every mount on the path, every
131
+ * dispatcher continuation and every waiting sibling is resolved HERE,
132
+ * against the chart as built, before a single stage runs — so a checkpoint
133
+ * whose path the chart cannot walk is refused up front instead of resuming
134
+ * into the wrong shape.
135
+ *
136
+ * @param args - `root` and `subflows`: the chart as built
137
+ * (`FlowChart.root`, `FlowChart.subflows`); `path`:
138
+ * `checkpoint.subflowPath`, outermost first; `captures`:
139
+ * `checkpoint.subflowStates` (a detached copy); `standIn`: the node that
140
+ * runs the resume half — the paused stage's own node, function swapped
141
+ * (its continuation is attached here); `pendingPauses`:
142
+ * `checkpoint.pendingPauses` (a detached copy).
143
+ * @throws when a subflow on the path is missing, mounted more than once, or
144
+ * its mount cannot be reached from the enclosing graph; or when a pending
145
+ * pause is malformed or is not a parallel sibling of the paused stage
146
+ */
147
+ static plan<TOut, TScope>(args: {
148
+ root: StageNode<TOut, TScope>;
149
+ subflows: Record<string, {
150
+ root: StageNode<TOut, TScope>;
151
+ }> | undefined;
152
+ path: readonly string[];
153
+ captures: Record<string, Record<string, unknown>> | undefined;
154
+ standIn: StageNode<TOut, TScope>;
155
+ pendingPauses?: readonly PendingPause[];
156
+ }): ResumeEntry<TOut, TScope>;
157
+ /**
158
+ * A seed-only entry: each capture seeds the FIRST entry into its subflow,
159
+ * which then starts at its own root. What the deprecated
160
+ * `subflowStatesForResume` option (TraverserOptions / HandlerDeps) means
161
+ * since 9.28.0 — the same one-shot law, without a stand-in or a path.
162
+ */
163
+ static fromCaptures<TOut, TScope>(captures: Record<string, Record<string, unknown>>): ResumeEntry<TOut, TScope>;
164
+ /**
165
+ * The re-entry into `subflowId`, taken — or `undefined` when this entry is
166
+ * an ordinary one (the subflow is off the pause path, or its hop was already
167
+ * taken). ONE-SHOT: a hop is returned at most once, so a second entry into
168
+ * the same subflow (a loop passing its mount again) runs the real subflow
169
+ * from its real root with its inputMapper.
170
+ */
171
+ enterSubflow(subflowId: string): ResumeHop<TOut, TScope> | undefined;
172
+ /** `true` once every hop has been taken — the rest of the run is ordinary. */
173
+ get spent(): boolean;
174
+ }
175
+ /**
176
+ * Queue `queue` behind a pause passing through its level: a pause raised
177
+ * while siblings still wait must carry them to its checkpoint. Each path is
178
+ * cut to that level — the bubble-up prepends the levels above.
179
+ */
180
+ export declare function queueBehind(signal: PauseSignal, queue: readonly QueuedPause[]): void;
181
+ /**
182
+ * The first waiting sibling's pause, raised again at its fan-out's level —
183
+ * exactly as it bubbled up to that level the first time (its stage, its
184
+ * question, its own subflow captures), nothing re-run; the rest of the queue
185
+ * waits behind it. The subflows ABOVE the fan-out capture themselves afresh
186
+ * as it bubbles up, so they carry what the resumed child wrote.
187
+ */
188
+ export declare function raiseQueuedPause(queue: readonly QueuedPause[]): PauseSignal;
189
+ /**
190
+ * The node that mounts `subflowId`, found by DFS from `start` over `next` and
191
+ * `children` (loop-ref stubs skipped — they share their target's id and carry
192
+ * nothing). Cycle-safe (visited by identity, so an absent id terminates too);
193
+ * first match in DFS pre-order (children before `next`, like the builder).
194
+ */
195
+ export declare function findMount<TOut, TScope>(start: StageNode<TOut, TScope>, subflowId: string): StageNode<TOut, TScope> | undefined;
@@ -20,6 +20,12 @@ import type { BreakFlag } from './types.js';
20
20
  export declare class SubflowExecutor<TOut = any, TScope = any> {
21
21
  private deps;
22
22
  private traverserFactory;
23
+ /**
24
+ * The resume's one-shot re-entry (`deps.resume`), or a seed-only one built
25
+ * from the deprecated `deps.subflowStatesForResume`. Undefined on a normal
26
+ * run. Asked once per subflow entry — see {@link ResumeEntry}.
27
+ */
28
+ private readonly resume;
23
29
  constructor(deps: HandlerDeps<TOut, TScope>, traverserFactory: SubflowTraverserFactory<TOut, TScope>);
24
30
  /**
25
31
  * Execute a subflow with isolated context.
@@ -9,5 +9,7 @@ export { DeciderHandler } from './DeciderHandler.js';
9
9
  export { SelectorHandler } from './SelectorHandler.js';
10
10
  export { ContinuationResolver, DEFAULT_MAX_ITERATIONS } from './ContinuationResolver.js';
11
11
  export { SubflowExecutor } from './SubflowExecutor.js';
12
+ export type { QueuedPause, ResumeHop } from './ResumeEntry.js';
13
+ export { ResumeEntry } from './ResumeEntry.js';
12
14
  export { applyOutputMapping, createSubflowHandlerDeps, extractParentScopeValues, getInitialScopeValues, seedSubflowGlobalStore, } from './SubflowInputMapper.js';
13
15
  export { computeNodeType, RuntimeStructureManager } from './RuntimeStructureManager.js';
@@ -155,7 +155,7 @@ export declare class CombinedNarrativeRecorder implements CombinedRecorder {
155
155
  description: string;
156
156
  preferredOperation: "translate";
157
157
  data: {
158
- type: "subflow" | "loop" | "error" | "fork" | "selector" | "stage" | "step" | "condition" | "break" | "pause" | "resume" | "emit" | "retry";
158
+ type: "subflow" | "loop" | "error" | "pause" | "fork" | "selector" | "stage" | "step" | "condition" | "break" | "resume" | "emit" | "retry";
159
159
  text: string;
160
160
  depth: number;
161
161
  stageName?: string | undefined;
@@ -23,11 +23,34 @@
23
23
  * Patch model: Stage writes into local patch; commitPatch() after return or throw.
24
24
  */
25
25
  import type { ScopeProtectionMode } from '../../scope/protection/types.js';
26
+ import type { QueuedPause } from '../handlers/ResumeEntry.js';
27
+ import { ResumeEntry } from '../handlers/ResumeEntry.js';
26
28
  import { FlowRecorderDispatcher } from '../narrative/FlowRecorderDispatcher.js';
27
29
  import type { FlowRecorder, IControlFlowNarrative } from '../narrative/types.js';
28
30
  import type { IExecutionRuntime, ILogger, ScopeFactory, Selector, SerializedPipelineStructure, StageFunction, StageNode, StreamHandlers, SubflowMountOptions, SubflowResult, TraversalResult } from '../types.js';
29
31
  export interface TraverserOptions<TOut = any, TScope = any> {
32
+ /**
33
+ * The graph this traverser walks — and the graph every id resolves against
34
+ * (the node map behind every `loopTo`, the DFS fallback). `execute()`
35
+ * starts here unless `entry` says otherwise.
36
+ */
30
37
  root: StageNode<TOut, TScope>;
38
+ /**
39
+ * Where `execute()` starts when not at `root` — a resume's one-shot
40
+ * re-entry (M2): the paused stage's stand-in, or the mount of the first
41
+ * subflow on the pause path, each with its dispatcher's continuation
42
+ * attached. Visited once, first, and never registered anywhere an id can
43
+ * reach it, so a loop back to the paused stage finds the REAL stage.
44
+ * Consumed by the first `execute()`.
45
+ */
46
+ entry?: StageNode<TOut, TScope>;
47
+ /**
48
+ * Parallel siblings' pauses waiting at this level (a resume, 9.28.0): once
49
+ * `entry`'s chain ends, `execute()` raises the first again (the rest wait
50
+ * behind it); a pause raised from inside the chain carries them all. Only
51
+ * with `entry`; consumed by the first `execute()`. See `ResumeEntry`.
52
+ */
53
+ pendingPauses?: readonly QueuedPause[];
31
54
  stageMap: Map<string, StageFunction<TOut, TScope>>;
32
55
  scopeFactory: ScopeFactory<TScope>;
33
56
  executionRuntime: IExecutionRuntime;
@@ -90,10 +113,17 @@ export interface TraverserOptions<TOut = any, TScope = any> {
90
113
  */
91
114
  visitCounts?: Map<string, number>;
92
115
  /**
93
- * Per-subflow scope captures from a checkpoint, on the resume path.
94
- * Forwarded to `HandlerDeps.subflowStatesForResume` so SubflowExecutor
95
- * can re-seed nested runtimes from pre-pause state instead of running
96
- * the inputMapper. Undefined on normal `run()` paths.
116
+ * The resume's one-shot re-entry (M2), shared by reference with every
117
+ * nested traverser (the execution counter's precedent): each subflow on the
118
+ * pause path takes its captured state and its entry point exactly once, on
119
+ * its first entry. See `ResumeEntry`. Undefined on normal `run()` paths.
120
+ */
121
+ resume?: ResumeEntry<TOut, TScope>;
122
+ /**
123
+ * @deprecated since 9.28.0 — pass {@link resume}. Still honoured, under the
124
+ * same one-shot law: each capture seeds only the FIRST entry into its
125
+ * subflow (in place of the inputMapper's values); later entries are
126
+ * ordinary. Ignored when `resume` is set.
97
127
  */
98
128
  subflowStatesForResume?: Record<string, Record<string, unknown>>;
99
129
  /**
@@ -138,6 +168,12 @@ export interface DynamicNodePatch<TOut = any, TScope = any> {
138
168
  }
139
169
  export declare class FlowchartTraverser<TOut = any, TScope = any> {
140
170
  private readonly root;
171
+ /** Where the next `execute()` starts when not at `root` — one-shot (see TraverserOptions.entry). */
172
+ private entry;
173
+ /** Siblings' pauses raised once `entry`'s chain ends — one-shot (see TraverserOptions.pendingPauses). */
174
+ private entryPendingPauses;
175
+ /** The resume's one-shot re-entry, shared with nested traversers. Undefined on a normal run. */
176
+ private readonly resume;
141
177
  private stageMap;
142
178
  private readonly executionRuntime;
143
179
  private subflows;
@@ -269,6 +305,15 @@ export declare class FlowchartTraverser<TOut = any, TScope = any> {
269
305
  */
270
306
  private _topBreakFlag;
271
307
  execute(branchPath?: string): Promise<TraversalResult>;
308
+ /**
309
+ * A resume's entry chain at a level where parallel siblings' pauses wait
310
+ * (9.28.0): run the chain — the resumed child only, the fan-out's join is
311
+ * NOT attached — then raise the first waiting pause again, the rest behind
312
+ * it. Nothing of the sibling re-runs; its question comes back as it was
313
+ * asked. A pause raised from inside the chain (the resumed child asking
314
+ * again) carries every waiting sibling instead, so none is ever dropped.
315
+ */
316
+ private walkThenRaise;
272
317
  /**
273
318
  * Break state captured at the top-level of the most recent `execute()`.
274
319
  * `shouldBreak` is true when a stage called `scope.$break(reason)`; the
@@ -9,6 +9,7 @@ import type { StageContext } from '../memory/StageContext.js';
9
9
  import type { FlowControlType, FlowMessage } from '../memory/types.js';
10
10
  import type { ScopeProtectionMode } from '../scope/protection/types.js';
11
11
  import type { StageNode } from './graph/StageNode.js';
12
+ import type { QueuedPause, ResumeEntry } from './handlers/ResumeEntry.js';
12
13
  import type { IControlFlowNarrative } from './narrative/types.js';
13
14
  export type { Decider, Selector, StageNode } from './graph/StageNode.js';
14
15
  export type { FlowchartCheckpoint, PausableHandler, PauseResult } from '../pause/index.js';
@@ -336,8 +337,20 @@ export interface SubflowResult {
336
337
  * so deciders, selectors, loops, lazy subflows, and abort signals all work inside subflows.
337
338
  */
338
339
  export type SubflowTraverserFactory<TOut = any, TScope = any> = (options: {
339
- /** Root node of the subflow (with isSubflowRoot stripped). */
340
+ /** Root node of the subflow (with isSubflowRoot stripped) — the graph every id inside the subflow resolves against. */
340
341
  root: StageNode<TOut, TScope>;
342
+ /**
343
+ * Where the subflow's traversal starts when not at `root` — a resume's
344
+ * one-shot re-entry (`ResumeHop.entry`): the next mount on the pause path,
345
+ * or the paused stage's stand-in, each with its dispatcher's continuation
346
+ * attached. Visited once, first; never resolvable by id.
347
+ */
348
+ entry?: StageNode<TOut, TScope>;
349
+ /**
350
+ * Parallel siblings' pauses waiting in this subflow (`ResumeHop.pendingPauses`,
351
+ * 9.28.0) — raised in order once `entry`'s chain ends.
352
+ */
353
+ pendingPauses?: readonly QueuedPause[];
341
354
  /** Isolated execution runtime for the subflow. */
342
355
  executionRuntime: IExecutionRuntime;
343
356
  /** Mapped input from parent scope (becomes readOnlyContext for stages). */
@@ -467,16 +480,22 @@ export interface HandlerDeps<TOut = any, TScope = any> {
467
480
  logger: ILogger;
468
481
  signal?: AbortSignal;
469
482
  /**
470
- * On resume, the per-subflow scope captures from the checkpoint.
471
- * Keyed by path-prefixed `subflowId` (matches `PauseSignal.subflowPath`).
472
- *
473
- * `SubflowExecutor` consults this on entry: if a key matches the
474
- * current subflow id, the nested runtime is seeded from this state
475
- * and the inputMapper is SKIPPED (the captured state already
476
- * reflects post-input pre-pause memory). This is what makes
477
- * cross-executor resume work for pauses INSIDE a subflow.
478
- *
479
- * Undefined on normal `run()` paths — only the resume path sets it.
483
+ * The resume's one-shot re-entry (M2) — shared by reference with every
484
+ * nested traverser, like the execution counter. `SubflowExecutor` asks it
485
+ * at each subflow entry: the FIRST entry into a subflow on the pause path
486
+ * takes that subflow's captured state (seeding the nested runtime in place
487
+ * of the inputMapper's values — the mapper still runs for the read-only
488
+ * args), its entry point and any sibling pauses waiting there; every later
489
+ * entry is an ordinary one. See `ResumeEntry`. Undefined on normal `run()`
490
+ * paths.
491
+ */
492
+ resume?: ResumeEntry<TOut, TScope>;
493
+ /**
494
+ * @deprecated since 9.28.0 — the engine plans a resume with {@link resume}.
495
+ * Still honoured, under the same one-shot law: each capture (keyed by
496
+ * path-prefixed `subflowId`) seeds only the FIRST entry into its subflow,
497
+ * in place of the inputMapper's values; later entries are ordinary.
498
+ * Ignored when `resume` is set.
480
499
  */
481
500
  subflowStatesForResume?: Record<string, Record<string, unknown>>;
482
501
  }
@@ -1,4 +1,4 @@
1
1
  export type { InterruptPayload } from './interrupt.js';
2
2
  export { interrupt, InterruptSignal, isInterruptSignal, provideInterruptAnswer } from './interrupt.js';
3
- export type { FlowchartCheckpoint, PausableHandler, PauseResult } from './types.js';
3
+ export type { FlowchartCheckpoint, PausableHandler, PauseResult, PendingPause } from './types.js';
4
4
  export { isPauseResult, isPauseSignal, PauseSignal } from './types.js';