@blokjs/runner 0.4.0 → 0.6.0

package/dist/ForEachNode.js

@@ -0,0 +1,522 @@
+/**
+ * ForEachNode — v0.5 primitive. Iterates over a collection, running a
+ * sub-pipeline of steps for each item. Supports sequential and parallel
+ * (with bounded concurrency) modes.
+ *
+ * The runtime config is read from `ctx.config[this.name]`:
+ *   {
+ *     in: unknown[],          // resolved by the blueprint mapper before run()
+ *     as: string,             // per-iteration variable name; lands at ctx.state[as]
+ *     mode: "sequential" | "parallel",
+ *     concurrency: number,    // parallel mode only
+ *     steps: NodeBase[],      // pre-resolved by Configuration's isFlowWithProperties path
+ *   }
+ *
+ * Per-iteration scoping: a child ctx is built per item with
+ * `ctx.state[as] = item` and `ctx.state[as + "Index"] = i`. Mutations
+ * to state inside an iteration do NOT bleed to other iterations
+ * (parallel safety, plus matches the documented forEach contract).
+ *
+ * Errors in any iteration propagate to the caller. The runner's outer
+ * step-level catch wraps them into the standard error envelope.
+ *
+ * v0.6 wait-inside-primitives:
+ *   - Phase 2 — sequential + wait shipped via the cursor stamps below.
+ *   - Phase 3 — parallel + wait shipped via the pool AbortController +
+ *     Promise.allSettled classification + cursor write. See
+ *     `docs/c/devtools/parallel-foreach-wait-spec.mdx` for the full
+ *     design.
+ */
+import _ from "lodash";
+import { RunCancelledError } from "./RunCancelledError";
+import RunnerNode from "./RunnerNode";
+import { WaitDispatchRequest } from "./WaitDispatchRequest";
+import { ForEachWaitMetrics } from "./monitoring/ForEachWaitMetrics";
+import { consumeRehydratedCursor, popPrimitiveFrame, pushPrimitiveFrame, readRehydratedCursor, } from "./runtime/PrimitiveStack";
+import { RunTracker } from "./tracing/RunTracker";
+import { applyStepOutput } from "./workflow/PersistenceHelper";
+export class ForEachNode extends RunnerNode {
+    /**
+     * v0.6 marker — RunnerSteps stamps `_blokActivePrimitiveNodeRunId`
+     * on ctx around `step.process()` calls when this flag is true so a
+     * nested wait fired inside an iteration body knows which NodeRun to
+     * write its `iteration_context` cursor to. Static `true` (vs an
+     * instance method) avoids importing ForEachNode inside RunnerSteps,
+     * which would create a circular dependency.
+     */
+    isPrimitiveIterator = true;
+    async run(ctx) {
+        this.contentType = "application/json";
+        const response = { success: true, data: [], error: null };
+        const opts = (ctx.config?.[this.name] ?? {});
+        const items = Array.isArray(opts.in) ? opts.in : [];
+        const as = typeof opts.as === "string" && opts.as.length > 0 ? opts.as : "item";
+        const mode = opts.mode === "parallel" ? "parallel" : "sequential";
+        const concurrency = typeof opts.concurrency === "number" && opts.concurrency > 0 ? opts.concurrency : 10;
+        const steps = (opts.steps ?? []);
+        if (items.length === 0 || steps.length === 0) {
+            response.data = [];
+            applyStepOutput(ctx, this, { data: [] });
+            return response;
+        }
+        // v0.6 — read the resume hint that TriggerBase rehydrated.
+        //
+        // Phase 4 — cursors are now keyed by NodeRun id in a map on ctx
+        // (`_blokIterationCursors`). Each primitive looks itself up by
+        // `ctx._traceNodeId` so nested primitives (forEach > forEach,
+        // switch > forEach, etc.) each find their OWN cursor — not the
+        // previous Phase 2/3 single-slot model that lost outer cursors
+        // to inner overwrites. Falls back to the legacy single-slot
+        // `_blokIterationResume` field for first-pass compatibility with
+        // callers that haven't migrated yet.
+        const ctxAny = ctx;
+        const myNodeRunId = ctxAny._traceNodeId;
+        // Phase 4 — lookup by step NAME (not NodeRun id). Names are
+        // stable across dispatchDeferred re-entries; NodeRun ids change.
+        let resume = readRehydratedCursor(ctx, this.name);
+        if (resume) {
+            consumeRehydratedCursor(ctx, this.name);
+        }
+        if (resume === undefined) {
+            const legacyResume = ctxAny._blokIterationResume;
+            if (legacyResume !== undefined) {
+                resume = legacyResume;
+                ctxAny._blokIterationResume = undefined;
+            }
+        }
+        // Lazy import to avoid circular dep (Runner pulls in Configuration).
+        const { default: Runner } = await import("./Runner");
+        // Discriminate on cursor mode at the read side. Sequential cursors
+        // written before this PR omit the `mode` field — treated as
+        // "sequential" by default. Parallel cursors are written ONLY by
+        // the parallel branch below.
+        const sequentialResume = resume && (resume.mode ?? "sequential") === "sequential" ? resume : undefined;
+        const parallelResume = resume?.mode === "parallel" ? resume : undefined;
+        // Pre-populate results[] from cursor — both sequential and parallel
+        // resume paths use this. Sequential: contiguous slice [0..N-1].
+        // Parallel: sparse — only slots present in `completedResults` get
+        // filled; the rest stay `undefined` and get re-launched.
+        const results = new Array(items.length);
+        if (sequentialResume?.completedResults) {
+            const cap = Math.min(sequentialResume.completedResults.length, items.length);
+            for (let k = 0; k < cap; k++) {
+                results[k] = sequentialResume.completedResults[k];
+            }
+        }
+        if (parallelResume?.completedResults) {
+            const cap = Math.min(parallelResume.completedResults.length, items.length);
+            for (let k = 0; k < cap; k++) {
+                const slot = parallelResume.completedResults[k];
+                // `null` distinguishes "ran but returned undefined" (re-use
+                // this value, don't re-launch) from a JSON-undefined hole
+                // (not present — re-launch). Both deserialise to `null` in
+                // some JSON encoders; we normalise sparse holes via
+                // `Object.prototype.hasOwnProperty` against the parsed
+                // array.
+                if (Object.prototype.hasOwnProperty.call(parallelResume.completedResults, k) && slot !== undefined) {
+                    // null sentinel survives — readers see `results[k] === null`
+                    // meaning "ran, returned undefined" and skip re-launch.
+                    results[k] = slot;
+                }
+            }
+        }
+        const runIteration = async (item, index, innerResumeIndex) => {
+            const childCtx = this.cloneCtxForIteration(ctx, as, item, index);
+            // v0.6 Phase 2 — pass the inner-step resume cursor on the
+            // child ctx. Phase 4 — propagate even the index-0 case so
+            // the wait-re-entry detection can distinguish a resumed
+            // iteration (innerResumeIndex defined) from a fresh one.
+            if (innerResumeIndex !== undefined) {
+                childCtx._blokInnerResumeIndex = innerResumeIndex;
+            }
+            const runner = new Runner(steps);
+            // `deep: true` — inner pipelines must not inherit the outer
+            // run's `lastCompletedStepIndex` cursor (PR 4 wait/resume logic)
+            // or every iteration's nested steps get marked "skipped (resumed
+            // past wait...)" and the iteration produces no output.
+            await runner.run(childCtx, { deep: true, stepName: this.name });
+            // After Runner.runSteps, `childCtx.response` is set to the last
+            // step's resolved data (RunnerSteps line ~349: `ctx.response =
+            // model.data`). So `childCtx.response` IS the iteration's
+            // output value, not a wrapped envelope.
+            return childCtx.response;
+        };
+        // v0.6 Phase 4 — push a primitive frame onto the ctx stack so the
+        // wait-throw site (and parallel-branch cursor writer) persists
+        // THIS forEach's iteration cursor to THIS forEach's NodeRun.
+        // Nested primitives (forEach > forEach, switch > forEach, etc.)
+        // each push their own frame, which is what unblocks the
+        // `forEach > forEach > wait` shape that the Phase 2/3 single-slot
+        // machinery couldn't represent.
+        const initialCursor = mode === "parallel"
+            ? {
+                mode: "parallel",
+                waitFiringIteration: 0,
+                innerStepIndex: 0,
+                completedResults: [],
+                cancelledIterations: [],
+            }
+            : { mode: "sequential", iteration: 0, innerStepIndex: 0, completedResults: [] };
+        const frame = myNodeRunId
+            ? { nodeRunId: myNodeRunId, cursor: initialCursor }
+            : undefined;
+        if (frame)
+            pushPrimitiveFrame(ctx, frame);
+        try {
+            if (mode === "sequential") {
+                // v0.6 Phase 2 — start at the resume iteration if present,
+                // else 0. Iterations before the resume index are not re-run;
+                // their results were rehydrated above.
+                const startIndex = sequentialResume?.iteration ?? 0;
+                for (let i = startIndex; i < items.length; i++) {
+                    // v0.6 Phase 4 — update the frame cursor so a wait fired
+                    // from inside this iteration body lands the right snapshot
+                    // in `node_runs.iteration_context`. `completedResults`
+                    // reflects results-so-far so on resume we don't re-run
+                    // iterations that already finished before the wait.
+                    if (frame) {
+                        const seq = frame.cursor;
+                        seq.iteration = i;
+                        seq.completedResults = results.slice(0, i);
+                    }
+                    const innerResumeIndex = i === startIndex && sequentialResume !== undefined ? sequentialResume.innerStepIndex : undefined;
+                    results[i] = await runIteration(items[i], i, innerResumeIndex);
+                }
+            }
+            else {
+                // === v0.6 Phase 3 — parallel forEach + wait =====================
+                // See `docs/c/devtools/parallel-foreach-wait-spec.mdx`. Headline
+                // contract: when one iteration's inner step throws
+                // `WaitDispatchRequest`, peer in-flight iterations are
+                // cancelled via a pool AbortController. Completed iterations'
+                // results are persisted in the cursor's `completedResults`
+                // sparse array; cancelled + queued iterations go in
+                // `cancelledIterations` for re-launch on resume.
+                //
+                // The pool AbortController is distinct from `ctx.signal` —
+                // tripping it MUST NOT cascade to the parent run (the parent
+                // is waiting, not cancelled). Each iteration's child ctx gets
+                // a per-iteration signal chained off BOTH the parent's signal
+                // (so user-cancel still cascades) AND the pool signal (so
+                // peer-wait cascades).
+                const poolController = new AbortController();
+                const poolSignal = poolController.signal;
+                // On resume in parallel mode, the work queue is the set of
+                // iterations that need to run: the wait-firing iter (with
+                // inner resume hint) + all cancelled/queued iters (from
+                // scratch). On a fresh pass, every iteration runs.
+                const queue = [];
+                if (parallelResume) {
+                    const toRun = new Set();
+                    toRun.add(parallelResume.waitFiringIteration);
+                    for (const idx of parallelResume.cancelledIterations) {
+                        if (idx < items.length)
+                            toRun.add(idx);
+                    }
+                    // Any iterations beyond `completedResults.length` are
+                    // trailing-not-started — also need to run.
+                    for (let i = parallelResume.completedResults.length; i < items.length; i++) {
+                        if (results[i] === undefined)
+                            toRun.add(i);
+                    }
+                    queue.push(...Array.from(toRun).sort((a, b) => a - b));
+                }
+                else {
+                    for (let i = 0; i < items.length; i++)
+                        queue.push(i);
+                }
+                let queuePos = 0;
+                const workerCount = Math.min(concurrency, queue.length);
+                const launchWorker = async () => {
+                    const outcomes = [];
+                    while (true) {
+                        const myQueuePos = queuePos++;
+                        if (myQueuePos >= queue.length)
+                            return outcomes;
+                        const index = queue[myQueuePos];
+                        // Skip if pool tripped before this iteration started —
+                        // classify as cancelled without doing any work.
+                        if (poolSignal.aborted) {
+                            outcomes.push({ kind: "cancelled", index });
+                            continue;
+                        }
+                        const innerResumeIndex = parallelResume !== undefined && index === parallelResume.waitFiringIteration
+                            ? parallelResume.innerStepIndex
+                            : undefined;
+                        try {
+                            const result = await runIterationWithPool(item(items, index), index, innerResumeIndex, poolSignal);
+                            outcomes.push({ kind: "completed", index, result });
+                        }
+                        catch (err) {
+                            if (err instanceof WaitDispatchRequest) {
+                                // This iteration fired a wait. Trip the pool so
+                                // peers stop accepting new iterations and exit
+                                // their current ones at the next step boundary.
+                                if (!poolSignal.aborted)
+                                    poolController.abort();
+                                outcomes.push({ kind: "wait", index, throwObj: err });
+                            }
+                            else if (err instanceof RunCancelledError) {
+                                // Distinguish pool-cancel from user-cancel. If
+                                // poolSignal is aborted AND ctx.signal is NOT,
+                                // this is a pool-induced cancellation due to a
+                                // peer's wait — re-runnable. Otherwise it's a
+                                // user-cancel — re-throw upstream.
+                                const userCancel = ctx.signal?.aborted === true && !poolSignal.aborted;
+                                if (userCancel) {
+                                    outcomes.push({ kind: "error", index, err });
+                                }
+                                else {
+                                    outcomes.push({ kind: "cancelled", index });
+                                }
+                            }
+                            else {
+                                // Real error. Trip the pool so peers stop
+                                // (don't waste CPU on a doomed forEach), then
+                                // record. Classification later: real errors
+                                // beat waits.
+                                if (!poolSignal.aborted)
+                                    poolController.abort();
+                                outcomes.push({ kind: "error", index, err });
+                            }
+                        }
+                    }
+                };
+                // Helper — same as `runIteration` but threads the pool signal
+                // through to the per-iteration child ctx (so RunnerSteps'
+                // between-step abort check sees pool aborts).
+                const runIterationWithPool = async (item_, index, innerResumeIndex, poolSig) => {
+                    const childCtx = this.cloneCtxForIteration(ctx, as, item_, index);
+                    const iterCtl = new AbortController();
+                    const listenerCleanup = new AbortController();
+                    // Chain from parent ctx.signal (user cancel cascade)
+                    if (ctx.signal) {
+                        if (ctx.signal.aborted)
+                            iterCtl.abort();
+                        else
+                            ctx.signal.addEventListener("abort", () => {
+                                if (!iterCtl.signal.aborted)
+                                    iterCtl.abort();
+                            }, { once: true, signal: listenerCleanup.signal });
+                    }
+                    // Chain from pool signal (peer wait cascade)
+                    if (poolSig.aborted)
+                        iterCtl.abort();
+                    else
+                        poolSig.addEventListener("abort", () => {
+                            if (!iterCtl.signal.aborted)
+                                iterCtl.abort();
+                        }, { once: true, signal: listenerCleanup.signal });
+                    // Replace the inherited signal (which would be parent's)
+                    // with the per-iteration signal that cascades both ways.
+                    childCtx.signal = iterCtl.signal;
+                    // Phase 4 — propagate the index-0 case too.
+                    if (innerResumeIndex !== undefined) {
+                        childCtx._blokInnerResumeIndex = innerResumeIndex;
+                    }
+                    try {
+                        const runner = new Runner(steps);
+                        await runner.run(childCtx, { deep: true, stepName: this.name });
+                        return childCtx.response;
+                    }
+                    finally {
+                        // Detach the per-iteration listeners from parent +
+                        // pool signals (PR 1 A3 pattern — prevents listener
+                        // accumulation on long-lived parents over many
+                        // parallel forEach invocations).
+                        listenerCleanup.abort();
+                    }
+                };
+                // Spawn workers. Each returns its set of outcomes (one
+                // outcome per iteration the worker handled). `allSettled`
+                // gives us each worker's final state; we then flatten.
+                const workers = [];
+                for (let w = 0; w < workerCount; w++) {
+                    workers.push(launchWorker());
+                }
+                const settled = await Promise.allSettled(workers);
+                // Flatten. A worker can't reject (its try/catch handles all
+                // errors and classifies into the outcome list). But guard
+                // defensively — rejection means a bug in launchWorker.
+                const allOutcomes = [];
+                for (const s of settled) {
+                    if (s.status === "fulfilled") {
+                        allOutcomes.push(...s.value);
+                    }
+                    else {
+                        // Defensive — re-throw so the failure isn't lost.
+                        throw s.reason;
+                    }
+                }
+                // Classification step. Walk outcomes:
+                //   1. If ANY non-wait error, re-throw the first one (errors
+                //      beat waits per the spec).
+                //   2. If ANY wait, identify the lowest-index wait as the
+                //      wait-firing iteration; reclassify others as cancelled.
+                //   3. Else, all iterations completed — fall through to
+                //      normal completion below.
+                const errors = allOutcomes.filter((o) => o.kind === "error");
+                if (errors.length > 0) {
+                    // First error wins (sorted by iteration index for
+                    // determinism, even though only one re-throws).
+                    errors.sort((a, b) => a.index - b.index);
+                    throw errors[0].err;
+                }
+                const waits = allOutcomes.filter((o) => o.kind === "wait");
+                if (waits.length > 0) {
+                    // First-wait-wins by iteration index.
+                    waits.sort((a, b) => a.index - b.index);
+                    const waitFiring = waits[0];
+                    // Demote other waits to cancelled (they were racing — only
+                    // one resumes; the others re-run from scratch).
+                    const cancelledFromOtherWaits = waits.slice(1).map((w) => w.index);
+                    const completed = allOutcomes.filter((o) => o.kind === "completed");
+                    const cancelled = allOutcomes
+                        .filter((o) => o.kind === "cancelled")
+                        .map((o) => o.index);
+                    // Build the sparse completedResults array. Slot k =
+                    // completed iteration k's return value; null = "ran but
+                    // returned undefined"; JSON-undefined hole = "not
+                    // present" (cancelled / queued / wait-firing). On resume,
+                    // only present-non-undefined slots short-circuit
+                    // re-launch.
+                    const completedResults = new Array(items.length);
+                    for (const c of completed) {
+                        completedResults[c.index] = c.result === undefined ? null : c.result;
+                    }
+                    // Also stash the rehydrated completed iterations from the
+                    // resume cursor — if we're already on a re-entry pass,
+                    // those iterations don't appear in `completed` (they
+                    // were never launched this pass) but their results are
+                    // in `results[]` from the pre-populate above.
+                    if (parallelResume) {
+                        for (let k = 0; k < parallelResume.completedResults.length; k++) {
+                            if (Object.prototype.hasOwnProperty.call(parallelResume.completedResults, k) &&
+                                parallelResume.completedResults[k] !== undefined &&
+                                completedResults[k] === undefined) {
+                                completedResults[k] = parallelResume.completedResults[k];
+                            }
+                        }
+                    }
+                    const allCancelled = [...new Set([...cancelled, ...cancelledFromOtherWaits])].sort((a, b) => a - b);
+                    const cursor = {
+                        mode: "parallel",
+                        waitFiringIteration: waitFiring.index,
+                        // `throwObj.info.stepIndex` carries the inner step index
+                        // the wait fired at — exactly what we need.
+                        innerStepIndex: waitFiring.throwObj.info.stepIndex,
+                        completedResults,
+                        cancelledIterations: allCancelled,
+                    };
+                    // Write the cursor BEFORE re-throwing so TriggerBase's
+                    // rehydrate (on the next resume) sees the parallel-mode
+                    // shape. RunnerSteps may have written a sequential-shape
+                    // cursor at the wait-throw moment (Phase 2 path); this
+                    // write overwrites it on the same NodeRun id.
+                    this.writeCursor(ctx, frame, cursor);
+                    // OTel — record the cancelled count so dashboards can
+                    // spot workflows that frequently waste work on cancel +
+                    // re-launch.
+                    try {
+                        ForEachWaitMetrics.getInstance().recordCancellation({
+                            workflowName: ctx.workflow_name ?? "unknown",
+                            cancelledCount: allCancelled.length,
+                        });
+                    }
+                    catch {
+                        // Metrics never block.
+                    }
+                    // Re-throw the original wait — TriggerBase catches it,
+                    // schedules the deferred dispatch, returns 202 to HTTP.
+                    throw waitFiring.throwObj;
+                }
+                // No waits, no errors — every iteration completed. Populate
+                // `results[]` from the completed outcomes.
+                for (const o of allOutcomes) {
+                    if (o.kind === "completed") {
+                        results[o.index] = o.result;
+                    }
+                }
+            }
+            response.data = results;
+            // Persist to ctx.state[this.name] so downstream steps can read via
+            // $.state[id]. Class-based RunnerNode subclasses must call
+            // applyStepOutput explicitly (BlokService does it implicitly via
+            // its `run()` method, but we own our own run() here).
+            applyStepOutput(ctx, this, { data: results });
+            return response;
+        }
+        finally {
+            // v0.6 Phase 4 — always pop the frame so sibling primitives
+            // later in the workflow don't see a stale cursor pointer, AND
+            // so a thrown WaitDispatchRequest unwind doesn't leave the
+            // stack in an inconsistent state for the outer runSteps.
+            if (frame)
+                popPrimitiveFrame(ctx);
+        }
+    }
+    /**
+     * Write the parallel cursor to the active forEach NodeRun's frame.
+     * Stamped from inside the parallel branch (vs. via RunnerSteps' wait-
+     * throw site) because the parallel cursor is built post-
+     * `Promise.allSettled` — the wait-throw site doesn't know which peer
+     * iterations got cancelled OR which completed.
+     *
+     * v0.6 Phase 4 — additionally mutates the frame's cursor in place so
+     * the wait-throw site (which runs AFTER this, when the throw unwinds
+     * back through RunnerSteps) re-persists the same parallel-shape
+     * cursor on outer-frame writes. Without the in-place mutation, the
+     * outer write would clobber this back to the initial parallel
+     * placeholder.
+     */
+    writeCursor(ctx, frame, cursor) {
+        if (!frame)
+            return;
+        // Replace the in-stack cursor so any subsequent stack walk uses
+        // the parallel-shape one we built (not the placeholder pushed at
+        // run() entry).
+        frame.cursor = cursor;
+        const primitiveNodeRunId = frame.nodeRunId;
+        try {
+            RunTracker.getInstance().getStore().updateNodeRun(primitiveNodeRunId, {
+                iterationContext: cursor,
+            });
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            ctx.logger.logLevel("warn", `[blok][wait] forEach parallel cursor write failed: ${msg}. Resume will re-run every iteration from scratch.`);
+        }
+    }
+    cloneCtxForIteration(ctx, as, item, index) {
+        const baseState = (ctx.state ?? {});
+        const state = { ...baseState };
+        state[as] = item;
+        state[`${as}Index`] = index;
+        // Deep-clone config so per-iteration blueprint mapper resolutions
+        // don't bleed across iterations (same hazard the v0.4 Configuration
+        // deep-clone fix addressed at the workflow level).
+        const config = _.cloneDeep(ctx.config);
+        const childCtx = {
+            ...ctx,
+            state,
+            vars: state,
+            config,
+            response: { data: null, success: true, error: null, contentType: "application/json" },
+        };
+        // v0.5.3 — stash the iteration index on the child ctx so RunnerSteps
+        // can propagate it to NodeRun.iterationIndex when starting each
+        // inner step. Studio reads this to group sibling rows by iteration
+        // (5 iterations × 3 inner steps render as 5 collapsible sections,
+        // not 15 flat rows with duplicate names). Overrides any sentinel
+        // inherited from a parent iteration scope — the inner-most forEach
+        // owns the index its inner steps see.
+        childCtx._blokIterationIndex = index;
+        return childCtx;
+    }
+}
+// Local helper to keep the parallel branch readable when reading
+// `items[index]` from inside an async lambda.
+function item(items, index) {
+    return items[index];
+}
+//# sourceMappingURL=ForEachNode.js.map

package/dist/ForEachNode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ForEachNode.js","sourceRoot":"","sources":["../src/ForEachNode.ts"],"names":[],"mappings":"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"}

package/dist/LoopMaxIterationsError.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Thrown when a `loop` step exceeds its `maxIterations` cap. Distinct
+ * from generic Error so callers can `instanceof` discriminate (e.g. to
+ * route to a tryCatch.catch arm or surface a 500 vs a 408).
+ */
+export declare class LoopMaxIterationsError extends Error {
+    readonly stepId: string;
+    readonly maxIterations: number;
+    readonly actualIterations: number;
+    constructor(stepId: string, maxIterations: number, actualIterations: number);
+}

package/dist/LoopMaxIterationsError.js

@@ -0,0 +1,18 @@
+/**
+ * Thrown when a `loop` step exceeds its `maxIterations` cap. Distinct
+ * from generic Error so callers can `instanceof` discriminate (e.g. to
+ * route to a tryCatch.catch arm or surface a 500 vs a 408).
+ */
+export class LoopMaxIterationsError extends Error {
+    stepId;
+    maxIterations;
+    actualIterations;
+    constructor(stepId, maxIterations, actualIterations) {
+        super(`Loop "${stepId}" exceeded maxIterations=${maxIterations} (ran ${actualIterations} times). This is a hard safety cap to prevent infinite loops. Increase the cap if your loop legitimately runs longer, or check the \`while\` condition.`);
+        this.name = "LoopMaxIterationsError";
+        this.stepId = stepId;
+        this.maxIterations = maxIterations;
+        this.actualIterations = actualIterations;
+    }
+}
+//# sourceMappingURL=LoopMaxIterationsError.js.map

package/dist/LoopMaxIterationsError.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"LoopMaxIterationsError.js","sourceRoot":"","sources":["../src/LoopMaxIterationsError.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,OAAO,sBAAuB,SAAQ,KAAK;IAChC,MAAM,CAAS;IACf,aAAa,CAAS;IACtB,gBAAgB,CAAS;IAEzC,YAAY,MAAc,EAAE,aAAqB,EAAE,gBAAwB;QAC1E,KAAK,CACJ,SAAS,MAAM,4BAA4B,aAAa,SAAS,gBAAgB,yJAAyJ,CAC1O,CAAC;QACF,IAAI,CAAC,IAAI,GAAG,wBAAwB,CAAC;QACrC,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,CAAC,aAAa,GAAG,aAAa,CAAC;QACnC,IAAI,CAAC,gBAAgB,GAAG,gBAAgB,CAAC;IAC1C,CAAC;CACD"}

package/dist/LoopNode.d.ts

@@ -0,0 +1,36 @@
+/**
+ * LoopNode — v0.5 primitive. While-loop with hard maxIterations safety
+ * cap. Runs a sub-pipeline as long as the `while` condition evaluates
+ * truthy against the live ctx. Each iteration carries forward state
+ * mutations (sequential by definition) so condition variables can
+ * advance between iterations.
+ *
+ * The runtime config is read from `ctx.config[this.name]`:
+ *   {
+ *     while: string,          // JS expression evaluated against ctx
+ *     maxIterations: number,  // hard safety cap; throws LoopMaxIterationsError on hit
+ *     steps: NodeBase[],      // pre-resolved by Configuration's isFlowWithProperties path
+ *   }
+ *
+ * The loop counter is exposed as `ctx.state[<stepId>Index]` (0-based)
+ * so the `while` expression can reference it. Each iteration's final
+ * step output is the loop step's overall data (the last iteration's
+ * `ctx.response.data`).
+ */
+import type { Context, ResponseContext } from "@blokjs/shared";
+import RunnerNode from "./RunnerNode";
+export declare class LoopNode extends RunnerNode {
+    /**
+     * v0.6 marker — RunnerSteps stamps `_blokActivePrimitiveNodeRunId`
+     * on ctx around `step.process()` calls when this flag is true so a
+     * nested wait fired inside an iteration body knows which NodeRun to
+     * write its `iteration_context` cursor to. Mirrors ForEachNode's
+     * marker (Phase 2). Static `true` (vs an instance method) avoids
+     * importing LoopNode inside RunnerSteps, which would create a
+     * circular dependency.
+     */
+    readonly isPrimitiveIterator = true;
+    run(ctx: Context): Promise<ResponseContext>;
+    private evaluateCondition;
+    private cloneCtxForIteration;
+}