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.
- package/AGENTS.md +3 -0
- package/CLAUDE.md +5 -4
- package/README.md +4 -0
- package/dist/advanced.js +3 -2
- package/dist/esm/advanced.d.ts +2 -2
- package/dist/esm/advanced.js +2 -2
- package/dist/esm/index.d.ts +1 -1
- package/dist/esm/index.js +1 -1
- package/dist/esm/lib/builder/FlowChartBuilder.d.ts +10 -0
- package/dist/esm/lib/builder/FlowChartBuilder.js +27 -13
- package/dist/esm/lib/engine/handlers/ChildrenExecutor.js +45 -12
- package/dist/esm/lib/engine/handlers/ResumeEntry.d.ts +195 -0
- package/dist/esm/lib/engine/handlers/ResumeEntry.js +471 -0
- package/dist/esm/lib/engine/handlers/SubflowExecutor.d.ts +6 -0
- package/dist/esm/lib/engine/handlers/SubflowExecutor.js +43 -10
- package/dist/esm/lib/engine/handlers/index.d.ts +2 -0
- package/dist/esm/lib/engine/handlers/index.js +2 -1
- package/dist/esm/lib/engine/narrative/CombinedNarrativeRecorder.d.ts +1 -1
- package/dist/esm/lib/engine/traversal/FlowchartTraverser.d.ts +49 -4
- package/dist/esm/lib/engine/traversal/FlowchartTraverser.js +64 -13
- package/dist/esm/lib/engine/types.d.ts +30 -11
- package/dist/esm/lib/engine/types.js +1 -1
- package/dist/esm/lib/pause/index.d.ts +1 -1
- package/dist/esm/lib/pause/index.js +1 -1
- package/dist/esm/lib/pause/types.d.ts +93 -5
- package/dist/esm/lib/pause/types.js +57 -3
- package/dist/esm/lib/runner/FlowChartExecutor.d.ts +8 -10
- package/dist/esm/lib/runner/FlowChartExecutor.js +153 -181
- package/dist/esm/lib/time-travel/bundles.js +11 -1
- package/dist/index.js +1 -1
- package/dist/lib/builder/FlowChartBuilder.js +27 -13
- package/dist/lib/engine/handlers/ChildrenExecutor.js +45 -12
- package/dist/lib/engine/handlers/ResumeEntry.js +478 -0
- package/dist/lib/engine/handlers/SubflowExecutor.js +43 -10
- package/dist/lib/engine/handlers/index.js +4 -2
- package/dist/lib/engine/traversal/FlowchartTraverser.js +64 -13
- package/dist/lib/engine/types.js +1 -1
- package/dist/lib/pause/index.js +1 -1
- package/dist/lib/pause/types.js +57 -3
- package/dist/lib/runner/FlowChartExecutor.js +153 -181
- package/dist/lib/time-travel/bundles.js +11 -1
- package/dist/types/advanced.d.ts +2 -2
- package/dist/types/index.d.ts +1 -1
- package/dist/types/lib/builder/FlowChartBuilder.d.ts +10 -0
- package/dist/types/lib/engine/handlers/ResumeEntry.d.ts +195 -0
- package/dist/types/lib/engine/handlers/SubflowExecutor.d.ts +6 -0
- package/dist/types/lib/engine/handlers/index.d.ts +2 -0
- package/dist/types/lib/engine/narrative/CombinedNarrativeRecorder.d.ts +1 -1
- package/dist/types/lib/engine/traversal/FlowchartTraverser.d.ts +49 -4
- package/dist/types/lib/engine/types.d.ts +30 -11
- package/dist/types/lib/pause/index.d.ts +1 -1
- package/dist/types/lib/pause/types.d.ts +93 -5
- package/dist/types/lib/runner/FlowChartExecutor.d.ts +8 -10
- 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"]}
|
package/dist/types/advanced.d.ts
CHANGED
|
@@ -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';
|
package/dist/types/index.d.ts
CHANGED
|
@@ -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" | "
|
|
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
|
-
*
|
|
94
|
-
*
|
|
95
|
-
*
|
|
96
|
-
*
|
|
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
|
-
*
|
|
471
|
-
*
|
|
472
|
-
*
|
|
473
|
-
*
|
|
474
|
-
*
|
|
475
|
-
* and
|
|
476
|
-
*
|
|
477
|
-
*
|
|
478
|
-
|
|
479
|
-
|
|
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';
|