footprintjs 9.26.0 → 9.28.0

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

@@ -8,6 +8,28 @@
  * - Aggregate results into { childId: { result, isError } }
  */
 import { isPauseSignal } from '../../pause/types.js';
+/**
+ * The ONE pause a fan-out raises when several of its children paused (9.28.0).
+ *
+ * Only one question is asked at a time, so the FIRST child's pause (child
+ * order) is the one raised; every other child's pause — and any pause already
+ * waiting behind it — is queued on it (`PauseSignal.pendingPauses`) and rides
+ * the checkpoint as `pendingPauses`. Before 9.28.0 the others were dropped
+ * silently: the checkpoint asked one child, and the resume never asked the
+ * rest (or, on 9.27.0, re-ran the whole fan-out forever).
+ *
+ * Every queued entry is relative to the fan-out's level — the same level the
+ * first signal is at — so the bubble-up grows them together.
+ */
+function raisePauses(pauses) {
+    const [first, ...others] = pauses;
+    for (const other of others) {
+        first.addPendingPause(other.toPendingPause());
+        for (const waiting of other.pendingPauses)
+            first.addPendingPause(waiting);
+    }
+    return first;
+}
 export class ChildrenExecutor {
     deps;
     executeNode;
@@ -62,39 +84,50 @@ export class ChildrenExecutor {
             });
         });
         const childrenResults = {};
+        // Every child that paused, by CHILD index (not settle order) — see raisePauses.
+        const pausedAt = [];
         if (node.failFast) {
-            // Fail-fast: first child error rejects immediately (unwrapped)
+            // Fail-fast: first child ERROR rejects immediately (unwrapped). A pause
+            // is not an error: it settles like a result, so the fork waits for its
+            // siblings before it pauses — their writes land before the checkpoint
+            // is taken, and a second pausing sibling is seen, not raced past.
             const results = await Promise.all(allChildren.map((child, i) => childPromises[i].then((r) => {
                 if (r.isError)
                     throw r.result;
                 return r;
+            }, (error) => {
+                if (!isPauseSignal(error))
+                    throw error;
+                pausedAt[i] = error;
+                return undefined;
             })));
-            for (const { id, result, isError } of results) {
-                childrenResults[id] = { id, result, isError: isError ?? false };
+            for (const r of results) {
+                if (r === undefined)
+                    continue; // a paused child
+                childrenResults[r.id] = { id: r.id, result: r.result, isError: r.isError ?? false };
             }
         }
         else {
             // Default: run all children to completion even if some fail
             const settled = await Promise.allSettled(childPromises);
-            let pauseSignal;
-            settled.forEach((s) => {
+            settled.forEach((s, i) => {
                 if (s.status === 'fulfilled') {
                     const { id, result, isError } = s.value;
                     childrenResults[id] = { id, result, isError: isError ?? false };
                 }
                 else if (isPauseSignal(s.reason)) {
-                    // PauseSignal from a child — re-throw after all children settle.
-                    // Keep the first signal if multiple children pause.
-                    pauseSignal ??= s.reason;
+                    // PauseSignal from a child — re-thrown after all children settle.
+                    pausedAt[i] = s.reason;
                 }
                 else {
                     this.deps.logger.error(`Execution failed: ${s.reason}`);
                 }
             });
-            // Re-throw PauseSignal after all children have settled
-            if (pauseSignal)
-                throw pauseSignal;
         }
+        // Re-throw after every child has settled.
+        const pauses = pausedAt.filter((p) => p !== undefined);
+        if (pauses.length > 0)
+            throw raisePauses(pauses);
         return childrenResults;
     }
     /**
@@ -142,4 +175,4 @@ export class ChildrenExecutor {
         return await this.executeNodeChildren(tempNode, context, undefined, branchPath, traversalContext);
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ChildrenExecutor.js","sourceRoot":"","sources":["../../../../../src/lib/engine/handlers/ChildrenExecutor.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAQrD,MAAM,OAAO,gBAAgB;IACP;IAAyC;IAA7D,YAAoB,IAA+B,EAAU,WAAwC;QAAjF,SAAI,GAAJ,IAAI,CAA2B;QAAU,gBAAW,GAAX,WAAW,CAA6B;IAAG,CAAC;IAEzG;;;OAGG;IACH,KAAK,CAAC,mBAAmB,CACvB,IAA6B,EAC7B,OAAqB,EACrB,eAA0C,EAC1C,UAAmB,EACnB,gBAAmC;QAEnC,IAAI,UAAU,GAAG,CAAC,CAAC;QACnB,MAAM,aAAa,GAAG,IAAI,CAAC,QAAQ,EAAE,MAAM,IAAI,CAAC,CAAC;QACjD,MAAM,WAAW,GAAG,IAAI,CAAC,QAAQ,IAAI,EAAE,CAAC;QAExC,iCAAiC;QACjC,MAAM,iBAAiB,GAAG,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;QACzD,IAAI,CAAC,IAAI,CAAC,kBAAkB,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,EAAE,iBAAiB,EAAE,gBAAgB,CAAC,CAAC;QACpF,gEAAgE;QAChE,mEAAmE;QACnE,+DAA+D;QAC/D,iEAAiE;QACjE,uEAAuE;QACvE,IAAI,CAAC,IAAI,CAAC,kBAAkB,CAAC,eAAe,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,WAAW,EAAE,gBAAgB,EAAE,MAAM,CAAC,CAAC;QAEpG,MAAM,aAAa,GAA8B,WAAW,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE;YACzE,MAAM,eAAe,GAAG,UAAU,IAAI,KAAK,CAAC,EAAE,CAAC;YAC/C,MAAM,YAAY,GAAG,OAAO,CAAC,WAAW,CAAC,eAAyB,EAAE,KAAK,CAAC,EAAY,EAAE,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC,EAAE,CAAC,CAAC;YAC9G,MAAM,cAAc,GAAG,EAAE,WAAW,EAAE,KAAK,EAAE,CAAC;YAE9C,MAAM,qBAAqB,GAAG,GAAG,EAAE;gBACjC,IAAI,cAAc,CAAC,WAAW;oBAAE,UAAU,IAAI,CAAC,CAAC;gBAChD,IAAI,eAAe,IAAI,UAAU,KAAK,aAAa;oBAAE,eAAe,CAAC,WAAW,GAAG,IAAI,CAAC;YAC1F,CAAC,CAAC;YAEF,OAAO,IAAI,CAAC,WAAW,CAAC,KAAK,EAAE,YAAY,EAAE,cAAc,EAAE,eAAe,CAAC;iBAC1E,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE;gBACf,YAAY,CAAC,MAAM,EAAE,CAAC;gBACtB,qBAAqB,EAAE,CAAC;gBACxB,OAAO,EAAE,EAAE,EAAE,KAAK,CAAC,EAAG,EAAE,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,CAAC;YACnD,CAAC,CAAC;iBACD,KAAK,CAAC,CAAC,KAAK,EAAE,EAAE;gBACf,+DAA+D;gBAC/D,IAAI,aAAa,CAAC,KAAK,CAAC;oBAAE,MAAM,KAAK,CAAC;gBACtC,YAAY,CAAC,MAAM,EAAE,CAAC;gBACtB,qBAAqB,EAAE,CAAC;gBACxB,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,sDAAsD,KAAK,EAAE,EAAE,EAAE,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC;gBACpG,IAAI,IAAI,CAAC,IAAI,CAAC,sBAAsB,IAAI,IAAI,CAAC,IAAI,CAAC,sBAAsB,CAAC,KAAK,CAAC,EAAE,CAAC;oBAChF,YAAY,CAAC,YAAY,CAAC,CAAC,SAAS,CAAC,EAAE,aAAa,EAAE,IAAI,CAAC,CAAC;gBAC9D,CAAC;gBACD,OAAO,EAAE,EAAE,EAAE,KAAK,CAAC,EAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC;YACzD,CAAC,CAAC,CAAC;QACP,CAAC,CAAC,CAAC;QAEH,MAAM,eAAe,GAAmC,EAAE,CAAC;QAE3D,IAAI,IAAI,CAAC,QAAQ,EAAE,CAAC;YAClB,+DAA+D;YAC/D,MAAM,OAAO,GAAG,MAAM,OAAO,CAAC,GAAG,CAC/B,WAAW,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,CAAC,EAAE,EAAE,CAC3B,aAAa,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE;gBAC1B,IAAI,CAAC,CAAC,OAAO;oBAAE,MAAM,CAAC,CAAC,MAAM,CAAC;gBAC9B,OAAO,CAAC,CAAC;YACX,CAAC,CAAC,CACH,CACF,CAAC;YACF,KAAK,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,IAAI,OAAO,EAAE,CAAC;gBAC9C,eAAe,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,IAAI,KAAK,EAAE,CAAC;YAClE,CAAC;QACH,CAAC;aAAM,CAAC;YACN,4DAA4D;YAC5D,MAAM,OAAO,GAAG,MAAM,OAAO,CAAC,UAAU,CAAC,aAAa,CAAC,CAAC;YACxD,IAAI,WAAoB,CAAC;YACzB,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE;gBACpB,IAAI,CAAC,CAAC,MAAM,KAAK,WAAW,EAAE,CAAC;oBAC7B,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,CAAC,CAAC,KAAK,CAAC;oBACxC,eAAe,CAAC,EAAE,CAAC,GAAG,EAAE,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,IAAI,KAAK,EAAE,CAAC;gBAClE,CAAC;qBAAM,IAAI,aAAa,CAAC,CAAC,CAAC,MAAM,CAAC,EAAE,CAAC;oBACnC,iEAAiE;oBACjE,oDAAoD;oBACpD,WAAW,KAAK,CAAC,CAAC,MAAM,CAAC;gBAC3B,CAAC;qBAAM,CAAC;oBACN,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,qBAAqB,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC;gBAC1D,CAAC;YACH,CAAC,CAAC,CAAC;YACH,uDAAuD;YACvD,IAAI,WAAW;gBAAE,MAAM,WAAW,CAAC;QACrC,CAAC;QAED,OAAO,eAAe,CAAC;IACzB,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,uBAAuB,CAC3B,QAAkB,EAClB,QAAmC,EACnC,KAAU,EACV,OAAqB,EACrB,UAAkB,EAClB,gBAAmC,EACnC,QAAkB;QAElB,MAAM,cAAc,GAAG,MAAM,QAAQ,CAAC,KAAK,CAAC,CAAC;QAC7C,MAAM,WAAW,GAAG,KAAK,CAAC,OAAO,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC,CAAC,CAAC,cAAc,CAAC,CAAC;QAEtF,OAAO,CAAC,MAAM,CAAC,kBAAkB,EAAE,WAAW,CAAC,CAAC;QAChD,OAAO,CAAC,MAAM,CAAC,iBAAiB,EAAE,cAAc,CAAC,CAAC;QAElD,IAAI,WAAW,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC7B,OAAO,CAAC,MAAM,CAAC,oBAAoB,EAAE,IAAI,CAAC,CAAC;YAC3C,OAAO,EAAE,CAAC;QACZ,CAAC;QAED,MAAM,gBAAgB,GAAG,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAG,CAAC,CAAC,CAAC;QAE7E,qCAAqC;QACrC,IAAI,gBAAgB,CAAC,MAAM,KAAK,WAAW,CAAC,MAAM,EAAE,CAAC;YACnD,MAAM,QAAQ,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;YAC3C,MAAM,OAAO,GAAG,WAAW,CAAC,MAAM,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,CAAC;YACnE,MAAM,YAAY,GAAG,wCAAwC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,gBAAgB,QAAQ,CAAC,IAAI,CAC1G,IAAI,CACL,EAAE,CAAC;YACJ,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,sBAAsB,UAAU,IAAI,EAAE,EAAE,KAAK,EAAE,YAAY,EAAE,CAAC,CAAC;YACtF,OAAO,CAAC,QAAQ,CAAC,eAAe,EAAE,YAAY,CAAC,CAAC;YAChD,MAAM,IAAI,KAAK,CAAC,YAAY,CAAC,CAAC;QAChC,CAAC;QAED,MAAM,UAAU,GAAG,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;QACzF,IAAI,UAAU,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC1B,OAAO,CAAC,MAAM,CAAC,iBAAiB,EAAE,UAAU,CAAC,CAAC;QAChD,CAAC;QAED,MAAM,aAAa,GAAG,gBAAgB,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACrE,OAAO,CAAC,mBAAmB,CACzB,UAAU,EACV,WAAW,aAAa,KAAK,gBAAgB,CAAC,MAAM,OAAO,QAAQ,CAAC,MAAM,WAAW,EACrF,EAAE,KAAK,EAAE,gBAAgB,CAAC,MAAM,EAAE,WAAW,EAAE,gBAAgB,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,EAAE,CACrF,CAAC;QAEF,mCAAmC;QACnC,MAAM,oBAAoB,GAAG,gBAAgB,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;QACjE,MAAM,YAAY,GAAG,OAAO,CAAC,SAAS,IAAI,UAAU,CAAC;QACrD,IAAI,CAAC,IAAI,CAAC,kBAAkB,CAAC,UAAU,CAAC,YAAY,EAAE,oBAAoB,EAAE,QAAQ,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;QAC/G,mEAAmE;QACnE,IAAI,CAAC,IAAI,CAAC,kBAAkB,CAAC,eAAe,CAAC,YAAY,EAAE,SAAS,EAAE,gBAAgB,EAAE,UAAU,CAAC,CAAC;QAEpG,MAAM,QAAQ,GAA4B;YACxC,IAAI,EAAE,eAAe;YACrB,EAAE,EAAE,eAAe;YACnB,QAAQ,EAAE,gBAAgB;YAC1B,4EAA4E;YAC5E,QAAQ;SACT,CAAC;QACF,OAAO,MAAM,IAAI,CAAC,mBAAmB,CAAC,QAAQ,EAAE,OAAO,EAAE,SAAS,EAAE,UAAU,EAAE,gBAAgB,CAAC,CAAC;IACpG,CAAC;CACF","sourcesContent":["/**\n * ChildrenExecutor — Parallel fan-out via Promise.allSettled.\n *\n * Responsibilities:\n * - Execute all children in parallel (fork pattern)\n * - Execute selected children based on selector output (multi-choice)\n * - Handle throttling error flagging for rate-limited operations\n * - Aggregate results into { childId: { result, isError } }\n */\n\nimport type { StageContext } from '../../memory/StageContext.js';\nimport { isPauseSignal } from '../../pause/types.js';\nimport type { Selector, StageNode } from '../graph/StageNode.js';\nimport type { TraversalContext } from '../narrative/types.js';\nimport type { HandlerDeps, NodeResultType } from '../types.js';\nimport type { ExecuteNodeFn } from './types.js';\n\nexport type { ExecuteNodeFn };\n\nexport class ChildrenExecutor<TOut = any, TScope = any> {\n  constructor(private deps: HandlerDeps<TOut, TScope>, private executeNode: ExecuteNodeFn<TOut, TScope>) {}\n\n  /**\n   * Execute all children in parallel. Each child commits on settle.\n   * Uses Promise.allSettled to ensure all children complete even if some fail.\n   */\n  async executeNodeChildren(\n    node: StageNode<TOut, TScope>,\n    context: StageContext,\n    parentBreakFlag?: { shouldBreak: boolean },\n    branchPath?: string,\n    traversalContext?: TraversalContext,\n  ): Promise<Record<string, NodeResultType>> {\n    let breakCount = 0;\n    const totalChildren = node.children?.length ?? 0;\n    const allChildren = node.children ?? [];\n\n    // Narrative: capture the fan-out\n    const childDisplayNames = allChildren.map((c) => c.name);\n    this.deps.narrativeGenerator.onFork(node.name, childDisplayNames, traversalContext);\n    // Proposal #003: fire onStageExecuted for the fork parent AFTER\n    // the specialized event so consumers tracking \"did this stage run\"\n    // work uniformly. Fires BEFORE children execute — matching the\n    // \"decision made\" semantic (the fork's main work is the decision\n    // to fan out; children are separate stages with their own lifecycles).\n    this.deps.narrativeGenerator.onStageExecuted(node.name, node.description, traversalContext, 'fork');\n\n    const childPromises: Promise<NodeResultType>[] = allChildren.map((child) => {\n      const childBranchPath = branchPath || child.id;\n      const childContext = context.createChild(childBranchPath as string, child.id as string, child.name, child.id);\n      const childBreakFlag = { shouldBreak: false };\n\n      const updateParentBreakFlag = () => {\n        if (childBreakFlag.shouldBreak) breakCount += 1;\n        if (parentBreakFlag && breakCount === totalChildren) parentBreakFlag.shouldBreak = true;\n      };\n\n      return this.executeNode(child, childContext, childBreakFlag, childBranchPath)\n        .then((result) => {\n          childContext.commit();\n          updateParentBreakFlag();\n          return { id: child.id!, result, isError: false };\n        })\n        .catch((error) => {\n          // PauseSignal is expected control flow — re-throw immediately.\n          if (isPauseSignal(error)) throw error;\n          childContext.commit();\n          updateParentBreakFlag();\n          this.deps.logger.info(`TREE PIPELINE: executeNodeChildren - Error for id: ${child?.id}`, { error });\n          if (this.deps.throttlingErrorChecker && this.deps.throttlingErrorChecker(error)) {\n            childContext.updateObject(['monitor'], 'isThrottled', true);\n          }\n          return { id: child.id!, result: error, isError: true };\n        });\n    });\n\n    const childrenResults: Record<string, NodeResultType> = {};\n\n    if (node.failFast) {\n      // Fail-fast: first child error rejects immediately (unwrapped)\n      const results = await Promise.all(\n        allChildren.map((child, i) =>\n          childPromises[i].then((r) => {\n            if (r.isError) throw r.result;\n            return r;\n          }),\n        ),\n      );\n      for (const { id, result, isError } of results) {\n        childrenResults[id] = { id, result, isError: isError ?? false };\n      }\n    } else {\n      // Default: run all children to completion even if some fail\n      const settled = await Promise.allSettled(childPromises);\n      let pauseSignal: unknown;\n      settled.forEach((s) => {\n        if (s.status === 'fulfilled') {\n          const { id, result, isError } = s.value;\n          childrenResults[id] = { id, result, isError: isError ?? false };\n        } else if (isPauseSignal(s.reason)) {\n          // PauseSignal from a child — re-throw after all children settle.\n          // Keep the first signal if multiple children pause.\n          pauseSignal ??= s.reason;\n        } else {\n          this.deps.logger.error(`Execution failed: ${s.reason}`);\n        }\n      });\n      // Re-throw PauseSignal after all children have settled\n      if (pauseSignal) throw pauseSignal;\n    }\n\n    return childrenResults;\n  }\n\n  /**\n   * Execute selected children based on selector result.\n   * Validates IDs, records selection info, then delegates to executeNodeChildren.\n   */\n  async executeSelectedChildren(\n    selector: Selector,\n    children: StageNode<TOut, TScope>[],\n    input: any,\n    context: StageContext,\n    branchPath: string,\n    traversalContext?: TraversalContext,\n    failFast?: boolean,\n  ): Promise<Record<string, NodeResultType>> {\n    const selectorResult = await selector(input);\n    const selectedIds = Array.isArray(selectorResult) ? selectorResult : [selectorResult];\n\n    context.addLog('selectedChildIds', selectedIds);\n    context.addLog('selectorPattern', 'multi-choice');\n\n    if (selectedIds.length === 0) {\n      context.addLog('skippedAllChildren', true);\n      return {};\n    }\n\n    const selectedChildren = children.filter((c) => selectedIds.includes(c.id!));\n\n    // Validate all IDs exist (fail fast)\n    if (selectedChildren.length !== selectedIds.length) {\n      const childIds = children.map((c) => c.id);\n      const missing = selectedIds.filter((id) => !childIds.includes(id));\n      const errorMessage = `Selector returned unknown child IDs: ${missing.join(', ')}. Available: ${childIds.join(\n        ', ',\n      )}`;\n      this.deps.logger.error(`Error in pipeline (${branchPath}):`, { error: errorMessage });\n      context.addError('selectorError', errorMessage);\n      throw new Error(errorMessage);\n    }\n\n    const skippedIds = children.filter((c) => !selectedIds.includes(c.id!)).map((c) => c.id);\n    if (skippedIds.length > 0) {\n      context.addLog('skippedChildIds', skippedIds);\n    }\n\n    const selectedNames = selectedChildren.map((c) => c.name).join(', ');\n    context.addFlowDebugMessage(\n      'selected',\n      `Running ${selectedNames} (${selectedChildren.length} of ${children.length} matched)`,\n      { count: selectedChildren.length, targetStage: selectedChildren.map((c) => c.name) },\n    );\n\n    // Narrative: capture the selection\n    const selectedDisplayNames = selectedChildren.map((c) => c.name);\n    const selectorName = context.stageName || 'selector';\n    this.deps.narrativeGenerator.onSelected(selectorName, selectedDisplayNames, children.length, traversalContext);\n    // Proposal #003: fire onStageExecuted AFTER the specialized event.\n    this.deps.narrativeGenerator.onStageExecuted(selectorName, undefined, traversalContext, 'selector');\n\n    const tempNode: StageNode<TOut, TScope> = {\n      name: 'selector-temp',\n      id: 'selector-temp',\n      children: selectedChildren,\n      // Honor the selector node's fan-out error mode (Promise.all vs allSettled).\n      failFast,\n    };\n    return await this.executeNodeChildren(tempNode, context, undefined, branchPath, traversalContext);\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ChildrenExecutor.js","sourceRoot":"","sources":["../../../../../src/lib/engine/handlers/ChildrenExecutor.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * ChildrenExecutor — Parallel fan-out via Promise.allSettled.\n *\n * Responsibilities:\n * - Execute all children in parallel (fork pattern)\n * - Execute selected children based on selector output (multi-choice)\n * - Handle throttling error flagging for rate-limited operations\n * - Aggregate results into { childId: { result, isError } }\n */\n\nimport type { StageContext } from '../../memory/StageContext.js';\nimport type { PauseSignal } from '../../pause/types.js';\nimport { isPauseSignal } from '../../pause/types.js';\nimport type { Selector, StageNode } from '../graph/StageNode.js';\nimport type { TraversalContext } from '../narrative/types.js';\nimport type { HandlerDeps, NodeResultType } from '../types.js';\nimport type { ExecuteNodeFn } from './types.js';\n\nexport type { ExecuteNodeFn };\n\n/**\n * The ONE pause a fan-out raises when several of its children paused (9.28.0).\n *\n * Only one question is asked at a time, so the FIRST child's pause (child\n * order) is the one raised; every other child's pause — and any pause already\n * waiting behind it — is queued on it (`PauseSignal.pendingPauses`) and rides\n * the checkpoint as `pendingPauses`. Before 9.28.0 the others were dropped\n * silently: the checkpoint asked one child, and the resume never asked the\n * rest (or, on 9.27.0, re-ran the whole fan-out forever).\n *\n * Every queued entry is relative to the fan-out's level — the same level the\n * first signal is at — so the bubble-up grows them together.\n */\nfunction raisePauses(pauses: readonly PauseSignal[]): PauseSignal {\n  const [first, ...others] = pauses;\n  for (const other of others) {\n    first.addPendingPause(other.toPendingPause());\n    for (const waiting of other.pendingPauses) first.addPendingPause(waiting);\n  }\n  return first;\n}\n\nexport class ChildrenExecutor<TOut = any, TScope = any> {\n  constructor(private deps: HandlerDeps<TOut, TScope>, private executeNode: ExecuteNodeFn<TOut, TScope>) {}\n\n  /**\n   * Execute all children in parallel. Each child commits on settle.\n   * Uses Promise.allSettled to ensure all children complete even if some fail.\n   */\n  async executeNodeChildren(\n    node: StageNode<TOut, TScope>,\n    context: StageContext,\n    parentBreakFlag?: { shouldBreak: boolean },\n    branchPath?: string,\n    traversalContext?: TraversalContext,\n  ): Promise<Record<string, NodeResultType>> {\n    let breakCount = 0;\n    const totalChildren = node.children?.length ?? 0;\n    const allChildren = node.children ?? [];\n\n    // Narrative: capture the fan-out\n    const childDisplayNames = allChildren.map((c) => c.name);\n    this.deps.narrativeGenerator.onFork(node.name, childDisplayNames, traversalContext);\n    // Proposal #003: fire onStageExecuted for the fork parent AFTER\n    // the specialized event so consumers tracking \"did this stage run\"\n    // work uniformly. Fires BEFORE children execute — matching the\n    // \"decision made\" semantic (the fork's main work is the decision\n    // to fan out; children are separate stages with their own lifecycles).\n    this.deps.narrativeGenerator.onStageExecuted(node.name, node.description, traversalContext, 'fork');\n\n    const childPromises: Promise<NodeResultType>[] = allChildren.map((child) => {\n      const childBranchPath = branchPath || child.id;\n      const childContext = context.createChild(childBranchPath as string, child.id as string, child.name, child.id);\n      const childBreakFlag = { shouldBreak: false };\n\n      const updateParentBreakFlag = () => {\n        if (childBreakFlag.shouldBreak) breakCount += 1;\n        if (parentBreakFlag && breakCount === totalChildren) parentBreakFlag.shouldBreak = true;\n      };\n\n      return this.executeNode(child, childContext, childBreakFlag, childBranchPath)\n        .then((result) => {\n          childContext.commit();\n          updateParentBreakFlag();\n          return { id: child.id!, result, isError: false };\n        })\n        .catch((error) => {\n          // PauseSignal is expected control flow — re-throw immediately.\n          if (isPauseSignal(error)) throw error;\n          childContext.commit();\n          updateParentBreakFlag();\n          this.deps.logger.info(`TREE PIPELINE: executeNodeChildren - Error for id: ${child?.id}`, { error });\n          if (this.deps.throttlingErrorChecker && this.deps.throttlingErrorChecker(error)) {\n            childContext.updateObject(['monitor'], 'isThrottled', true);\n          }\n          return { id: child.id!, result: error, isError: true };\n        });\n    });\n\n    const childrenResults: Record<string, NodeResultType> = {};\n    // Every child that paused, by CHILD index (not settle order) — see raisePauses.\n    const pausedAt: (PauseSignal | undefined)[] = [];\n\n    if (node.failFast) {\n      // Fail-fast: first child ERROR rejects immediately (unwrapped). A pause\n      // is not an error: it settles like a result, so the fork waits for its\n      // siblings before it pauses — their writes land before the checkpoint\n      // is taken, and a second pausing sibling is seen, not raced past.\n      const results = await Promise.all(\n        allChildren.map((child, i) =>\n          childPromises[i].then(\n            (r) => {\n              if (r.isError) throw r.result;\n              return r;\n            },\n            (error: unknown) => {\n              if (!isPauseSignal(error)) throw error;\n              pausedAt[i] = error;\n              return undefined;\n            },\n          ),\n        ),\n      );\n      for (const r of results) {\n        if (r === undefined) continue; // a paused child\n        childrenResults[r.id] = { id: r.id, result: r.result, isError: r.isError ?? false };\n      }\n    } else {\n      // Default: run all children to completion even if some fail\n      const settled = await Promise.allSettled(childPromises);\n      settled.forEach((s, i) => {\n        if (s.status === 'fulfilled') {\n          const { id, result, isError } = s.value;\n          childrenResults[id] = { id, result, isError: isError ?? false };\n        } else if (isPauseSignal(s.reason)) {\n          // PauseSignal from a child — re-thrown after all children settle.\n          pausedAt[i] = s.reason;\n        } else {\n          this.deps.logger.error(`Execution failed: ${s.reason}`);\n        }\n      });\n    }\n\n    // Re-throw after every child has settled.\n    const pauses = pausedAt.filter((p): p is PauseSignal => p !== undefined);\n    if (pauses.length > 0) throw raisePauses(pauses);\n\n    return childrenResults;\n  }\n\n  /**\n   * Execute selected children based on selector result.\n   * Validates IDs, records selection info, then delegates to executeNodeChildren.\n   */\n  async executeSelectedChildren(\n    selector: Selector,\n    children: StageNode<TOut, TScope>[],\n    input: any,\n    context: StageContext,\n    branchPath: string,\n    traversalContext?: TraversalContext,\n    failFast?: boolean,\n  ): Promise<Record<string, NodeResultType>> {\n    const selectorResult = await selector(input);\n    const selectedIds = Array.isArray(selectorResult) ? selectorResult : [selectorResult];\n\n    context.addLog('selectedChildIds', selectedIds);\n    context.addLog('selectorPattern', 'multi-choice');\n\n    if (selectedIds.length === 0) {\n      context.addLog('skippedAllChildren', true);\n      return {};\n    }\n\n    const selectedChildren = children.filter((c) => selectedIds.includes(c.id!));\n\n    // Validate all IDs exist (fail fast)\n    if (selectedChildren.length !== selectedIds.length) {\n      const childIds = children.map((c) => c.id);\n      const missing = selectedIds.filter((id) => !childIds.includes(id));\n      const errorMessage = `Selector returned unknown child IDs: ${missing.join(', ')}. Available: ${childIds.join(\n        ', ',\n      )}`;\n      this.deps.logger.error(`Error in pipeline (${branchPath}):`, { error: errorMessage });\n      context.addError('selectorError', errorMessage);\n      throw new Error(errorMessage);\n    }\n\n    const skippedIds = children.filter((c) => !selectedIds.includes(c.id!)).map((c) => c.id);\n    if (skippedIds.length > 0) {\n      context.addLog('skippedChildIds', skippedIds);\n    }\n\n    const selectedNames = selectedChildren.map((c) => c.name).join(', ');\n    context.addFlowDebugMessage(\n      'selected',\n      `Running ${selectedNames} (${selectedChildren.length} of ${children.length} matched)`,\n      { count: selectedChildren.length, targetStage: selectedChildren.map((c) => c.name) },\n    );\n\n    // Narrative: capture the selection\n    const selectedDisplayNames = selectedChildren.map((c) => c.name);\n    const selectorName = context.stageName || 'selector';\n    this.deps.narrativeGenerator.onSelected(selectorName, selectedDisplayNames, children.length, traversalContext);\n    // Proposal #003: fire onStageExecuted AFTER the specialized event.\n    this.deps.narrativeGenerator.onStageExecuted(selectorName, undefined, traversalContext, 'selector');\n\n    const tempNode: StageNode<TOut, TScope> = {\n      name: 'selector-temp',\n      id: 'selector-temp',\n      children: selectedChildren,\n      // Honor the selector node's fan-out error mode (Promise.all vs allSettled).\n      failFast,\n    };\n    return await this.executeNodeChildren(tempNode, context, undefined, branchPath, traversalContext);\n  }\n}\n"]}

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

@@ -0,0 +1,195 @@
+/**
+ * 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 type { PendingPause } from '../../pause/types.js';
+import { PauseSignal } from '../../pause/types.js';
+import type { StageNode } from '../graph/StageNode.js';
+/**
+ * A parallel sibling's pause, queued at the level of its fan-out: raised
+ * again there once the resumed child's chain ends (see {@link raiseQueuedPause}).
+ */
+export interface QueuedPause {
+    /** The sibling's pause as the checkpoint carries it — its path from the top. */
+    readonly pause: PendingPause;
+    /** How many subflows deep the fan-out sits (0 = the top level). */
+    readonly level: number;
+    /** The sibling's paused stage's name, for the `onPause` event. */
+    readonly stageName: string;
+}
+/** One subflow boundary on the way back to a paused stage. */
+export interface ResumeHop<TOut = any, TScope = any> {
+    /** The path-prefixed subflow id (a `FlowchartCheckpoint.subflowPath` entry). */
+    readonly subflowId: string;
+    /**
+     * The subflow's state at the pause (`checkpoint.subflowStates[subflowId]`).
+     * Seeds the nested runtime INSTEAD of the inputMapper's values — the capture
+     * already holds the post-input, pre-pause memory (the inputMapper still
+     * runs, for the stages' read-only args only). Absent when the checkpoint
+     * holds no capture for this subflow; the inputMapper then seeds it, as on
+     * any entry.
+     */
+    readonly seed?: Record<string, unknown>;
+    /**
+     * Where this subflow's traversal starts on the re-entry: the mount of the
+     * next subflow on the path, or — on the last hop — the paused stage's
+     * stand-in, each with its dispatcher's continuation attached (see the
+     * module doc). Absent: the subflow's own root — a seed-only hop (see
+     * {@link ResumeEntry.fromCaptures}), or an outer subflow whose capture the
+     * checkpoint lacks.
+     */
+    readonly entry?: StageNode<TOut, TScope>;
+    /**
+     * Pauses of parallel siblings whose fan-out sits in THIS subflow, raised in
+     * order once `entry`'s chain ends (the first is raised, the rest wait
+     * behind it). Absent when no sibling is waiting here.
+     */
+    readonly pendingPauses?: readonly QueuedPause[];
+}
+export declare class ResumeEntry<TOut = any, TScope = any> {
+    /**
+     * 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.
+     */
+    readonly start: StageNode<TOut, TScope> | undefined;
+    /** Sibling pauses whose fan-out sits at the TOP level — raised once `start`'s chain ends. */
+    readonly startPendingPauses: readonly QueuedPause[] | undefined;
+    /**
+     * 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.
+     */
+    readonly stepsBeforeStandIn: number | undefined;
+    /** Hops not taken yet, by subflow id. A hop leaves this map when it is taken. */
+    private readonly pending;
+    private constructor();
+    /**
+     * 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<TOut, TScope>(args: {
+        root: StageNode<TOut, TScope>;
+        subflows: Record<string, {
+            root: StageNode<TOut, TScope>;
+        }> | undefined;
+        path: readonly string[];
+        captures: Record<string, Record<string, unknown>> | undefined;
+        standIn: StageNode<TOut, TScope>;
+        pendingPauses?: readonly PendingPause[];
+    }): ResumeEntry<TOut, TScope>;
+    /**
+     * 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<TOut, TScope>(captures: Record<string, Record<string, unknown>>): ResumeEntry<TOut, TScope>;
+    /**
+     * 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: string): ResumeHop<TOut, TScope> | undefined;
+    /** `true` once every hop has been taken — the rest of the run is ordinary. */
+    get spent(): boolean;
+}
+/**
+ * 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 declare function queueBehind(signal: PauseSignal, queue: readonly QueuedPause[]): void;
+/**
+ * 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 declare function raiseQueuedPause(queue: readonly QueuedPause[]): PauseSignal;
+/**
+ * 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 declare function findMount<TOut, TScope>(start: StageNode<TOut, TScope>, subflowId: string): StageNode<TOut, TScope> | undefined;