@kensio/yulin 1.20.2 → 1.20.3

package/dist/service/stepfunctions/execution/sim-states-interpreter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sim-states-interpreter.d.ts","sourceRoot":"","sources":["../../../../src/service/stepfunctions/execution/sim-states-interpreter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,wCAAwC,CAAC;AAElF,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,wCAAwC,CAAC;AAElF,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,uCAAuC,CAAC;AAClF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAcpE,UAAU,8BAA8B;IACtC,QAAQ,CAAC,UAAU,EAAE,mBAAmB,CAAC;IACzC,QAAQ,CAAC,SAAS,EAAE,kBAAkB,CAAC;IACvC,QAAQ,CAAC,UAAU,EAAE,mBAAmB,CAAC;IAEzC;;OAEG;IACH,QAAQ,CAAC,KAAK,EAAE,oBAAoB,CAAC;IAErC;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED;;;;;;;;;;GAUG;AACH,qBAAa,oBAAoB;;IAY/B,YAAY,UAAU,EAAE,8BAA8B,EAarD;IAED;;;;;;OAMG;IACG,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC,CAEzB;CAgGF"}
+{"version":3,"file":"sim-states-interpreter.d.ts","sourceRoot":"","sources":["../../../../src/service/stepfunctions/execution/sim-states-interpreter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,wCAAwC,CAAC;AAElF,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,wCAAwC,CAAC;AAClF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAErE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,+BAA+B,CAAC;AAM1E,UAAU,8BAA8B;IACtC,QAAQ,CAAC,UAAU,EAAE,mBAAmB,CAAC;IACzC,QAAQ,CAAC,UAAU,EAAE,mBAAmB,CAAC;IAEzC;;;OAGG;IACH,QAAQ,CAAC,IAAI,EAAE,oBAAoB,CAAC;IAEpC;;;OAGG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1C;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,oBAAqB,YAAW,kBAAkB;;IAa7D,YAAY,UAAU,EAAE,8BAA8B,EA2BrD;IAED;;;;;;OAMG;IACG,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC,CAGzB;CAuDF"}

package/dist/service/stepfunctions/execution/sim-states-interpreter.js

@@ -1,8 +1,9 @@
-import { simStatesCycleFailure, simStatesMaximumTransitions, simStatesUnknownStateFailure, } from "./sim-states-failure.js";
 import { SimStatesSettlement } from "./sim-states-settlement.js";
+import { SimStatesStateAttempts } from "./sim-states-state-attempts.js";
 import { SimStatesStateRunner } from "./sim-states-state-runner.js";
+import { SimStatesWalkSteps } from "./sim-states-walk-steps.js";
 /**
- * Walks one execution through its state machine.
+ * Walks one execution, or one branch of one, through its states.
  *
  * The walk is a loop over a map of states, which is all Amazon States Language
  * asks for. Everything interesting happens either side of a state, in the
@@ -10,63 +11,85 @@ import { SimStatesStateRunner } from "./sim-states-state-runner.js";
  *
  * A `Wait` state pauses the walk rather than blocking it. The rest of it is
  * scheduled on the simulation's clock, so the execution stays `RUNNING` until
- * something moves simulated time to the instant it is waiting for.
+ * something moves simulated time to the instant it is waiting for. A `Retry`
+ * pauses it the same way, with the next attempt at the state standing in for
+ * the state after it.
+ *
+ * A `Parallel` state runs a walk of its own per branch, on the same clock and
+ * through the same states, so a branch waits the way anything else does and
+ * its siblings carry on while it does.
  */
 export class SimStatesInterpreter {
     #definition;
-    #execution;
+    #record;
     #background;
-    #runner;
-    #settlement;
+    #steps;
+    #attempts;
+    #onSettled;
     /**
-     * Transitions made so far, counted across the pauses a `Wait` state makes.
+     * Whether whatever is holding this walk has been told it ended.
      */
-    #taken = 0;
+    #told = false;
     constructor(properties) {
         this.#definition = properties.definition;
-        this.#execution = properties.execution;
+        this.#record = properties.walk.record;
         this.#background = properties.background;
-        this.#runner = new SimStatesStateRunner({
+        this.#onSettled = properties.onSettled;
+        const settlement = new SimStatesSettlement({
+            record: properties.walk.record,
             background: properties.background,
-            tasks: properties.tasks,
-            roleArn: properties.roleArn,
         });
-        this.#settlement = new SimStatesSettlement({
-            execution: properties.execution,
+        this.#steps = new SimStatesWalkSteps(properties.definition, settlement);
+        this.#attempts = new SimStatesStateAttempts({
+            runner: new SimStatesStateRunner({
+                background: properties.background,
+                walk: properties.walk,
+            }),
+            settlement,
             background: properties.background,
+            walkOn: async (outcome) => {
+                if (outcome !== undefined) {
+                    await this.#walk(outcome.next, outcome.output);
+                }
+                await this.#ended();
+            },
         });
     }
     /**
-     * Run the execution as far as it goes without waiting on the clock.
+     * Run the walk as far as it goes without waiting on the clock.
      *
      * A failure ends the execution and is recorded on it. Nothing raises out of
      * here, since this runs where a caller advancing the clock would otherwise
      * see the raise.
      */
     async run() {
-        await this.#walk(this.#definition.StartAt, this.#execution.input);
+        await this.#walk(this.#definition.StartAt, this.#record.input);
+        await this.#ended();
     }
     /**
-     * Walk from one state until the execution ends or a `Wait` pauses it.
+     * Walk from one state until the walk ends or the clock pauses it.
      */
     async #walk(from, value) {
         let current = from;
         let carried = value;
-        for (;;) {
-            const state = this.#nextState(current);
+        while (!this.#record.stopped) {
+            const state = this.#steps.next(current);
             if (state === undefined) {
                 return;
             }
-            this.#execution.enter(current);
+            this.#record.enter(current);
             // One sequencing point per state. The states are a chain, so there is
             // nothing here to run in parallel.
             // oxlint-disable-next-line eslint/no-await-in-loop
             await this.#background.sequence();
-            const carrying = this.#resolve(
-            // One state at a time, since each one's input is what the state
-            // before it produced.
+            // One state at a time, since each one's input is what the state before
+            // it produced.
             // oxlint-disable-next-line eslint/no-await-in-loop
-            await this.#runner.run(state, carried, current));
+            const carrying = await this.#attempts.run({
+                name: current,
+                state,
+                input: carried,
+            });
             if (carrying === undefined) {
                 return;
             }
@@ -75,50 +98,17 @@ export class SimStatesInterpreter {
         }
     }
     /**
-     * The state a name stands for, failing the execution where there is none.
-     */
-    #nextState(current) {
-        if (this.#taken++ >= simStatesMaximumTransitions) {
-            this.#settlement.settle(simStatesCycleFailure());
-            return undefined;
-        }
-        const state = this.#definition.States.get(current);
-        if (state === undefined) {
-            this.#settlement.settle(simStatesUnknownStateFailure(current));
-        }
-        return state;
-    }
-    /**
-     * Settle what a state left to do, or schedule the rest of the walk.
+     * Tell whatever is holding this walk that it is over, once it is.
      *
-     * Answers with the outcome the walk carries on from, and with nothing where
-     * the execution has ended or is waiting on the clock.
+     * A walk that answered with states still on the clock is not over, and this
+     * runs again when they release it.
      */
-    #resolve(outcome) {
-        if (outcome.kind === "wait") {
-            return this.#wait(outcome.until, outcome.resume);
+    async #ended() {
+        if (this.#told || !this.#record.stopped) {
+            return;
         }
-        return this.#settlement.settle(outcome);
-    }
-    /**
-     * Hold the execution until the clock reaches an instant.
-     *
-     * An instant already reached holds nothing up, and the walk carries straight
-     * on. Anything later is scheduled, and the execution is left `RUNNING` until
-     * simulated time gets there. Under a frozen clock that is for as long as the
-     * test leaves it.
-     */
-    #wait(until, resume) {
-        if (until.getTime() <= this.#background.now().getTime()) {
-            return this.#settlement.settle(resume);
-        }
-        this.#background.scheduleAt(until, async () => {
-            const carrying = this.#settlement.settle(resume);
-            if (carrying !== undefined) {
-                await this.#walk(carrying.next, carrying.output);
-            }
-        });
-        return undefined;
+        this.#told = true;
+        await this.#onSettled?.();
     }
 }
 //# sourceMappingURL=sim-states-interpreter.js.map

package/dist/service/stepfunctions/execution/sim-states-interpreter.js.map

@@ -1 +1 @@
-{"version":3,"file":"sim-states-interpreter.js","sourceRoot":"","sources":["../../../../src/service/stepfunctions/execution/sim-states-interpreter.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"sim-states-interpreter.js","sourceRoot":"","sources":["../../../../src/service/stepfunctions/execution/sim-states-interpreter.ts"],"names":[],"mappings":"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"}

package/dist/service/stepfunctions/execution/sim-states-map-items.d.ts

@@ -0,0 +1,13 @@
+import type { JSONValue } from "../../../util/type-guard/json.js";
+import type { SimStatesMapState } from "../definition/sim-states-state.js";
+import type { SimStatesStateContext } from "./sim-states-state-outcome.js";
+/**
+ * The items one `Map` state runs its `ItemProcessor` over.
+ *
+ * `ItemsPath` selects them out of the state's effective input, and a state
+ * carrying none runs over that input itself. Real Step Functions fails the
+ * execution with `States.Runtime` where what it finds is not an array, and so
+ * does this.
+ */
+export declare function simStatesMapItems(state: SimStatesMapState, effective: JSONValue, context: SimStatesStateContext): readonly JSONValue[];
+//# sourceMappingURL=sim-states-map-items.d.ts.map

package/dist/service/stepfunctions/execution/sim-states-map-items.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-map-items.d.ts","sourceRoot":"","sources":["../../../../src/service/stepfunctions/execution/sim-states-map-items.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AAElE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AAE3E,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,+BAA+B,CAAC;AAE3E;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,iBAAiB,EACxB,SAAS,EAAE,SAAS,EACpB,OAAO,EAAE,qBAAqB,GAC7B,SAAS,SAAS,EAAE,CAYtB"}

package/dist/service/stepfunctions/execution/sim-states-map-items.js

@@ -0,0 +1,38 @@
+import { selectSimStatesReadPath } from "../data/sim-states-context-path.js";
+import { SimStatesRuntimeFailure } from "../error/sim-step-functions.error.js";
+/**
+ * The items one `Map` state runs its `ItemProcessor` over.
+ *
+ * `ItemsPath` selects them out of the state's effective input, and a state
+ * carrying none runs over that input itself. Real Step Functions fails the
+ * execution with `States.Runtime` where what it finds is not an array, and so
+ * does this.
+ */
+export function simStatesMapItems(state, effective, context) {
+    const items = selected(state, effective, context);
+    if (!Array.isArray(items)) {
+        throw new SimStatesRuntimeFailure(`The Map state ${context.stateName} reads its items from ` +
+            `${state.ItemsPath ?? "$"}, which holds ${found(items)} rather than ` +
+            "an array.");
+    }
+    return items;
+}
+/**
+ * What the state found there, for the failure it ends with.
+ */
+function found(items) {
+    if (items === undefined) {
+        return "nothing";
+    }
+    return JSON.stringify(items);
+}
+/**
+ * What the state's `ItemsPath` selects, which may be nothing at all.
+ */
+function selected(state, effective, context) {
+    if (state.ItemsPath === undefined) {
+        return effective;
+    }
+    return selectSimStatesReadPath(state.ItemsPath, effective, context.contextObject);
+}
+//# sourceMappingURL=sim-states-map-items.js.map

package/dist/service/stepfunctions/execution/sim-states-map-items.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-map-items.js","sourceRoot":"","sources":["../../../../src/service/stepfunctions/execution/sim-states-map-items.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,uBAAuB,EAAE,MAAM,oCAAoC,CAAC;AAE7E,OAAO,EAAE,uBAAuB,EAAE,MAAM,sCAAsC,CAAC;AAG/E;;;;;;;GAOG;AACH,MAAM,UAAU,iBAAiB,CAC/B,KAAwB,EACxB,SAAoB,EACpB,OAA8B;IAE9B,MAAM,KAAK,GAAG,QAAQ,CAAC,KAAK,EAAE,SAAS,EAAE,OAAO,CAAC,CAAC;IAElD,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;QAC1B,MAAM,IAAI,uBAAuB,CAC/B,iBAAiB,OAAO,CAAC,SAAS,wBAAwB;YACxD,GAAG,KAAK,CAAC,SAAS,IAAI,GAAG,iBAAiB,KAAK,CAAC,KAAK,CAAC,eAAe;YACrE,WAAW,CACd,CAAC;IACJ,CAAC;IAED,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;GAEG;AACH,SAAS,KAAK,CAAC,KAA4B;IACzC,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;QACxB,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,OAAO,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;AAC/B,CAAC;AAED;;GAEG;AACH,SAAS,QAAQ,CACf,KAAwB,EACxB,SAAoB,EACpB,OAA8B;IAE9B,IAAI,KAAK,CAAC,SAAS,KAAK,SAAS,EAAE,CAAC;QAClC,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,OAAO,uBAAuB,CAC5B,KAAK,CAAC,SAAS,EACf,SAAS,EACT,OAAO,CAAC,aAAa,CACtB,CAAC;AACJ,CAAC"}

package/dist/service/stepfunctions/execution/sim-states-map-iteration.d.ts

@@ -0,0 +1,32 @@
+import type { JSONValue } from "../../../util/type-guard/json.js";
+import type { SimStatesMapState } from "../definition/sim-states-state.js";
+import type { SimStatesChildStart } from "./sim-states-child-runs.js";
+import type { SimStatesStateContext } from "./sim-states-state-outcome.js";
+interface SimStatesMapIterationProperties {
+    readonly state: SimStatesMapState;
+    /**
+     * The `Map` state's effective input, which `ItemSelector` reads through `$`.
+     */
+    readonly effective: JSONValue;
+    readonly item: JSONValue;
+    readonly index: number;
+    readonly context: SimStatesStateContext;
+}
+/**
+ * How many iterations one `Map` state runs at once.
+ *
+ * A state carrying no `MaxConcurrency`, or one of 0, runs all of them. Both
+ * arrive here as an infinite bound, which is the bound the fan-out subtracts
+ * from.
+ */
+export declare function simStatesMapConcurrency(state: SimStatesMapState): number;
+/**
+ * One iteration, and what it is given to work on.
+ *
+ * `ItemSelector` reads the state's own effective input through `$`, and the
+ * item it is building for through `$$.Map.Item`. A state carrying none gives
+ * the iteration the item itself.
+ */
+export declare function simStatesMapIteration(properties: SimStatesMapIterationProperties): SimStatesChildStart;
+export {};
+//# sourceMappingURL=sim-states-map-iteration.d.ts.map

package/dist/service/stepfunctions/execution/sim-states-map-iteration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-map-iteration.d.ts","sourceRoot":"","sources":["../../../../src/service/stepfunctions/execution/sim-states-map-iteration.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AAGlE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AAC3E,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AACtE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,+BAA+B,CAAC;AAO3E,UAAU,+BAA+B;IACvC,QAAQ,CAAC,KAAK,EAAE,iBAAiB,CAAC;IAElC;;OAEG;IACH,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAC;IAE9B,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IACzB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,OAAO,EAAE,qBAAqB,CAAC;CACzC;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,iBAAiB,GAAG,MAAM,CAIxE;AAED;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CACnC,UAAU,EAAE,+BAA+B,GAC1C,mBAAmB,CAsBrB"}

package/dist/service/stepfunctions/execution/sim-states-map-iteration.js

@@ -0,0 +1,37 @@
+import { simStatesMapItemContext } from "../data/sim-states-context-object.js";
+import { evaluateSimStatesPayloadTemplate } from "../data/sim-states-payload-template.js";
+/**
+ * What a `MaxConcurrency` of 0 means, which is every iteration at once.
+ */
+const unbounded = Infinity;
+/**
+ * How many iterations one `Map` state runs at once.
+ *
+ * A state carrying no `MaxConcurrency`, or one of 0, runs all of them. Both
+ * arrive here as an infinite bound, which is the bound the fan-out subtracts
+ * from.
+ */
+export function simStatesMapConcurrency(state) {
+    const bound = state.MaxConcurrency ?? 0;
+    return bound === 0 ? unbounded : bound;
+}
+/**
+ * One iteration, and what it is given to work on.
+ *
+ * `ItemSelector` reads the state's own effective input through `$`, and the
+ * item it is building for through `$$.Map.Item`. A state carrying none gives
+ * the iteration the item itself.
+ */
+export function simStatesMapIteration(properties) {
+    const { context, effective, index, item, state } = properties;
+    const contextObject = simStatesMapItemContext(context.contextObject, index, item);
+    return {
+        index,
+        definition: state.ItemProcessor,
+        contextObject,
+        input: state.ItemSelector === undefined
+            ? item
+            : evaluateSimStatesPayloadTemplate(state.ItemSelector, effective, contextObject),
+    };
+}
+//# sourceMappingURL=sim-states-map-iteration.js.map

package/dist/service/stepfunctions/execution/sim-states-map-iteration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-map-iteration.js","sourceRoot":"","sources":["../../../../src/service/stepfunctions/execution/sim-states-map-iteration.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,uBAAuB,EAAE,MAAM,sCAAsC,CAAC;AAC/E,OAAO,EAAE,gCAAgC,EAAE,MAAM,wCAAwC,CAAC;AAK1F;;GAEG;AACH,MAAM,SAAS,GAAG,QAAQ,CAAC;AAe3B;;;;;;GAMG;AACH,MAAM,UAAU,uBAAuB,CAAC,KAAwB;IAC9D,MAAM,KAAK,GAAG,KAAK,CAAC,cAAc,IAAI,CAAC,CAAC;IAExC,OAAO,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC;AACzC,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,qBAAqB,CACnC,UAA2C;IAE3C,MAAM,EAAE,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,UAAU,CAAC;IAE9D,MAAM,aAAa,GAAG,uBAAuB,CAC3C,OAAO,CAAC,aAAa,EACrB,KAAK,EACL,IAAI,CACL,CAAC;IAEF,OAAO;QACL,KAAK;QACL,UAAU,EAAE,KAAK,CAAC,aAAa;QAC/B,aAAa;QACb,KAAK,EACH,KAAK,CAAC,YAAY,KAAK,SAAS;YAC9B,CAAC,CAAC,IAAI;YACN,CAAC,CAAC,gCAAgC,CAC9B,KAAK,CAAC,YAAY,EAClB,SAAS,EACT,aAAa,CACd;KACR,CAAC;AACJ,CAAC"}

package/dist/service/stepfunctions/execution/sim-states-run-choice.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sim-states-run-choice.d.ts","sourceRoot":"","sources":["../../../../src/service/stepfunctions/execution/sim-states-run-choice.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AAKlE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,mCAAmC,CAAC;AAE9E,OAAO,KAAK,EACV,qBAAqB,EACrB,qBAAqB,EACtB,MAAM,+BAA+B,CAAC;AAEvC;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,oBAAoB,EAC3B,KAAK,EAAE,SAAS,EAChB,OAAO,EAAE,qBAAqB,GAC7B,qBAAqB,CAiBvB"}
+{"version":3,"file":"sim-states-run-choice.d.ts","sourceRoot":"","sources":["../../../../src/service/stepfunctions/execution/sim-states-run-choice.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AAKlE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,mCAAmC,CAAC;AAE9E,OAAO,KAAK,EACV,qBAAqB,EACrB,qBAAqB,EACtB,MAAM,+BAA+B,CAAC;AAEvC;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,oBAAoB,EAC3B,KAAK,EAAE,SAAS,EAChB,OAAO,EAAE,qBAAqB,GAC7B,qBAAqB,CA0BvB"}

package/dist/service/stepfunctions/execution/sim-states-run-choice.js

@@ -8,7 +8,7 @@ import { SimStatesNoChoiceMatched } from "../error/sim-step-functions.error.js";
  * so what it passes on is its own input.
  */
 export function runSimStatesChoice(state, input, context) {
-    const effective = simStatesEffectiveInput(input, state);
+    const effective = simStatesEffectiveInput(input, state, context.contextObject);
     const matched = state.Choices.find((rule) => rule.matches(effective));
     const next = matched?.next ?? state.Default;
     if (next === undefined) {
@@ -17,7 +17,7 @@ export function runSimStatesChoice(state, input, context) {
     }
     return {
         kind: "next",
-        output: simStatesEffectiveOutput(effective, effective, state),
+        output: simStatesEffectiveOutput(effective, effective, state, context.contextObject),
         next,
     };
 }

package/dist/service/stepfunctions/execution/sim-states-run-choice.js.map

@@ -1 +1 @@
-{"version":3,"file":"sim-states-run-choice.js","sourceRoot":"","sources":["../../../../src/service/stepfunctions/execution/sim-states-run-choice.ts"],"names":[],"mappings":"AACA,OAAO,EACL,uBAAuB,EACvB,wBAAwB,GACzB,MAAM,iCAAiC,CAAC;AAEzC,OAAO,EAAE,wBAAwB,EAAE,MAAM,sCAAsC,CAAC;AAMhF;;;;;;GAMG;AACH,MAAM,UAAU,kBAAkB,CAChC,KAA2B,EAC3B,KAAgB,EAChB,OAA8B;IAE9B,MAAM,SAAS,GAAG,uBAAuB,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;IACxD,MAAM,OAAO,GAAG,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC;IACtE,MAAM,IAAI,GAAG,OAAO,EAAE,IAAI,IAAI,KAAK,CAAC,OAAO,CAAC;IAE5C,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;QACvB,MAAM,IAAI,wBAAwB,CAChC,oBAAoB,OAAO,CAAC,SAAS,iCAAiC;YACpE,qCAAqC,CACxC,CAAC;IACJ,CAAC;IAED,OAAO;QACL,IAAI,EAAE,MAAM;QACZ,MAAM,EAAE,wBAAwB,CAAC,SAAS,EAAE,SAAS,EAAE,KAAK,CAAC;QAC7D,IAAI;KACL,CAAC;AACJ,CAAC"}
+{"version":3,"file":"sim-states-run-choice.js","sourceRoot":"","sources":["../../../../src/service/stepfunctions/execution/sim-states-run-choice.ts"],"names":[],"mappings":"AACA,OAAO,EACL,uBAAuB,EACvB,wBAAwB,GACzB,MAAM,iCAAiC,CAAC;AAEzC,OAAO,EAAE,wBAAwB,EAAE,MAAM,sCAAsC,CAAC;AAMhF;;;;;;GAMG;AACH,MAAM,UAAU,kBAAkB,CAChC,KAA2B,EAC3B,KAAgB,EAChB,OAA8B;IAE9B,MAAM,SAAS,GAAG,uBAAuB,CACvC,KAAK,EACL,KAAK,EACL,OAAO,CAAC,aAAa,CACtB,CAAC;IACF,MAAM,OAAO,GAAG,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC;IACtE,MAAM,IAAI,GAAG,OAAO,EAAE,IAAI,IAAI,KAAK,CAAC,OAAO,CAAC;IAE5C,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;QACvB,MAAM,IAAI,wBAAwB,CAChC,oBAAoB,OAAO,CAAC,SAAS,iCAAiC;YACpE,qCAAqC,CACxC,CAAC;IACJ,CAAC;IAED,OAAO;QACL,IAAI,EAAE,MAAM;QACZ,MAAM,EAAE,wBAAwB,CAC9B,SAAS,EACT,SAAS,EACT,KAAK,EACL,OAAO,CAAC,aAAa,CACtB;QACD,IAAI;KACL,CAAC;AACJ,CAAC"}

package/dist/service/stepfunctions/execution/sim-states-run-map.d.ts

@@ -0,0 +1,12 @@
+import type { JSONValue } from "../../../util/type-guard/json.js";
+import type { SimStatesMapState } from "../definition/sim-states-state.js";
+import type { SimStatesStateContext, SimStatesStateOutcome } from "./sim-states-state-outcome.js";
+/**
+ * A `Map` state, which runs its `ItemProcessor` once per item.
+ *
+ * The result is an array of what each iteration produced, in the order the
+ * items were in rather than the order the iterations finished. An empty array
+ * of items runs the processor no times and answers with an empty array.
+ */
+export declare function runSimStatesMap(state: SimStatesMapState, input: JSONValue, context: SimStatesStateContext): Promise<SimStatesStateOutcome>;
+//# sourceMappingURL=sim-states-run-map.d.ts.map

package/dist/service/stepfunctions/execution/sim-states-run-map.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-run-map.d.ts","sourceRoot":"","sources":["../../../../src/service/stepfunctions/execution/sim-states-run-map.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AAElE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAC;AAQ3E,OAAO,KAAK,EACV,qBAAqB,EACrB,qBAAqB,EACtB,MAAM,+BAA+B,CAAC;AAEvC;;;;;;GAMG;AACH,wBAAsB,eAAe,CACnC,KAAK,EAAE,iBAAiB,EACxB,KAAK,EAAE,SAAS,EAChB,OAAO,EAAE,qBAAqB,GAC7B,OAAO,CAAC,qBAAqB,CAAC,CAoBhC"}

package/dist/service/stepfunctions/execution/sim-states-run-map.js

@@ -0,0 +1,25 @@
+import { simStatesEffectiveInput } from "../data/sim-states-data-flow.js";
+import { SimStatesFanOut } from "./sim-states-fan-out.js";
+import { simStatesFanOutOutcome } from "./sim-states-fan-out-outcome.js";
+import { simStatesMapConcurrency, simStatesMapIteration, } from "./sim-states-map-iteration.js";
+import { simStatesMapItems } from "./sim-states-map-items.js";
+/**
+ * A `Map` state, which runs its `ItemProcessor` once per item.
+ *
+ * The result is an array of what each iteration produced, in the order the
+ * items were in rather than the order the iterations finished. An empty array
+ * of items runs the processor no times and answers with an empty array.
+ */
+export async function runSimStatesMap(state, input, context) {
+    const effective = simStatesEffectiveInput(input, state, context.contextObject);
+    const items = simStatesMapItems(state, effective, context);
+    return await new SimStatesFanOut({
+        context,
+        kind: "iteration",
+        limit: simStatesMapConcurrency(state),
+        children: items.map((item, index) => simStatesMapIteration({ state, effective, item, index, context })),
+        names: (index) => `Iteration ${String(index)} of the Map state ${context.stateName}`,
+        answers: (outputs) => simStatesFanOutOutcome(state, input, outputs, context.contextObject),
+    }).run();
+}
+//# sourceMappingURL=sim-states-run-map.js.map

package/dist/service/stepfunctions/execution/sim-states-run-map.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-run-map.js","sourceRoot":"","sources":["../../../../src/service/stepfunctions/execution/sim-states-run-map.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,uBAAuB,EAAE,MAAM,iCAAiC,CAAC;AAE1E,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAC1D,OAAO,EAAE,sBAAsB,EAAE,MAAM,iCAAiC,CAAC;AACzE,OAAO,EACL,uBAAuB,EACvB,qBAAqB,GACtB,MAAM,+BAA+B,CAAC;AACvC,OAAO,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAM9D;;;;;;GAMG;AACH,MAAM,CAAC,KAAK,UAAU,eAAe,CACnC,KAAwB,EACxB,KAAgB,EAChB,OAA8B;IAE9B,MAAM,SAAS,GAAG,uBAAuB,CACvC,KAAK,EACL,KAAK,EACL,OAAO,CAAC,aAAa,CACtB,CAAC;IACF,MAAM,KAAK,GAAG,iBAAiB,CAAC,KAAK,EAAE,SAAS,EAAE,OAAO,CAAC,CAAC;IAE3D,OAAO,MAAM,IAAI,eAAe,CAAC;QAC/B,OAAO;QACP,IAAI,EAAE,WAAW;QACjB,KAAK,EAAE,uBAAuB,CAAC,KAAK,CAAC;QACrC,QAAQ,EAAE,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAClC,qBAAqB,CAAC,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC,CAClE;QACD,KAAK,EAAE,CAAC,KAAK,EAAE,EAAE,CACf,aAAa,MAAM,CAAC,KAAK,CAAC,qBAAqB,OAAO,CAAC,SAAS,EAAE;QACpE,OAAO,EAAE,CAAC,OAAO,EAAE,EAAE,CACnB,sBAAsB,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,aAAa,CAAC;KACvE,CAAC,CAAC,GAAG,EAAE,CAAC;AACX,CAAC"}

package/dist/service/stepfunctions/execution/sim-states-run-parallel.d.ts

@@ -0,0 +1,16 @@
+import type { JSONValue } from "../../../util/type-guard/json.js";
+import type { SimStatesParallelState } from "../definition/sim-states-state.js";
+import type { SimStatesStateContext, SimStatesStateOutcome } from "./sim-states-state-outcome.js";
+/**
+ * A `Parallel` state, which runs each of its branches on the same input.
+ *
+ * Every branch is given the state's effective input, so `InputPath` and
+ * `Parameters` are applied once rather than per branch. The result is an array
+ * of what each branch produced, in the order the branches were written, and
+ * `ResultSelector`, `ResultPath` and `OutputPath` then apply to that array.
+ *
+ * All the branches run at once. Nothing bounds how many of them are going,
+ * which is what Amazon States Language says of a `Parallel` state.
+ */
+export declare function runSimStatesParallel(state: SimStatesParallelState, input: JSONValue, context: SimStatesStateContext): Promise<SimStatesStateOutcome>;
+//# sourceMappingURL=sim-states-run-parallel.d.ts.map

package/dist/service/stepfunctions/execution/sim-states-run-parallel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-run-parallel.d.ts","sourceRoot":"","sources":["../../../../src/service/stepfunctions/execution/sim-states-run-parallel.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AAElE,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,mCAAmC,CAAC;AAGhF,OAAO,KAAK,EACV,qBAAqB,EACrB,qBAAqB,EACtB,MAAM,+BAA+B,CAAC;AAEvC;;;;;;;;;;GAUG;AACH,wBAAsB,oBAAoB,CACxC,KAAK,EAAE,sBAAsB,EAC7B,KAAK,EAAE,SAAS,EAChB,OAAO,EAAE,qBAAqB,GAC7B,OAAO,CAAC,qBAAqB,CAAC,CAsBhC"}

package/dist/service/stepfunctions/execution/sim-states-run-parallel.js

@@ -0,0 +1,31 @@
+import { simStatesEffectiveInput } from "../data/sim-states-data-flow.js";
+import { SimStatesFanOut } from "./sim-states-fan-out.js";
+import { simStatesFanOutOutcome } from "./sim-states-fan-out-outcome.js";
+/**
+ * A `Parallel` state, which runs each of its branches on the same input.
+ *
+ * Every branch is given the state's effective input, so `InputPath` and
+ * `Parameters` are applied once rather than per branch. The result is an array
+ * of what each branch produced, in the order the branches were written, and
+ * `ResultSelector`, `ResultPath` and `OutputPath` then apply to that array.
+ *
+ * All the branches run at once. Nothing bounds how many of them are going,
+ * which is what Amazon States Language says of a `Parallel` state.
+ */
+export async function runSimStatesParallel(state, input, context) {
+    const effective = simStatesEffectiveInput(input, state, context.contextObject);
+    return await new SimStatesFanOut({
+        context,
+        kind: "branch",
+        limit: Infinity,
+        children: state.Branches.map((definition, index) => ({
+            index,
+            definition,
+            input: effective,
+            contextObject: context.contextObject,
+        })),
+        names: (index) => `Branch ${String(index + 1)} of the Parallel state ${context.stateName}`,
+        answers: (outputs) => simStatesFanOutOutcome(state, input, outputs, context.contextObject),
+    }).run();
+}
+//# sourceMappingURL=sim-states-run-parallel.js.map

package/dist/service/stepfunctions/execution/sim-states-run-parallel.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-run-parallel.js","sourceRoot":"","sources":["../../../../src/service/stepfunctions/execution/sim-states-run-parallel.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,uBAAuB,EAAE,MAAM,iCAAiC,CAAC;AAE1E,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAC1D,OAAO,EAAE,sBAAsB,EAAE,MAAM,iCAAiC,CAAC;AAMzE;;;;;;;;;;GAUG;AACH,MAAM,CAAC,KAAK,UAAU,oBAAoB,CACxC,KAA6B,EAC7B,KAAgB,EAChB,OAA8B;IAE9B,MAAM,SAAS,GAAG,uBAAuB,CACvC,KAAK,EACL,KAAK,EACL,OAAO,CAAC,aAAa,CACtB,CAAC;IAEF,OAAO,MAAM,IAAI,eAAe,CAAC;QAC/B,OAAO;QACP,IAAI,EAAE,QAAQ;QACd,KAAK,EAAE,QAAQ;QACf,QAAQ,EAAE,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,UAAU,EAAE,KAAK,EAAE,EAAE,CAAC,CAAC;YACnD,KAAK;YACL,UAAU;YACV,KAAK,EAAE,SAAS;YAChB,aAAa,EAAE,OAAO,CAAC,aAAa;SACrC,CAAC,CAAC;QACH,KAAK,EAAE,CAAC,KAAK,EAAE,EAAE,CACf,UAAU,MAAM,CAAC,KAAK,GAAG,CAAC,CAAC,0BAA0B,OAAO,CAAC,SAAS,EAAE;QAC1E,OAAO,EAAE,CAAC,OAAO,EAAE,EAAE,CACnB,sBAAsB,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,OAAO,CAAC,aAAa,CAAC;KACvE,CAAC,CAAC,GAAG,EAAE,CAAC;AACX,CAAC"}

package/dist/service/stepfunctions/execution/sim-states-run-record.d.ts

@@ -0,0 +1,47 @@
+import type { JSONValue } from "../../../util/type-guard/json.js";
+import type { SimStatesChildRun } from "./sim-states-child-run.js";
+/**
+ * What a walk over a set of states records as it goes.
+ *
+ * An execution is one of these, and so is a `Parallel` state's branch. The
+ * interpreter walks either without knowing which it has, so a branch gets the
+ * same `Wait` states, the same retries and the same clock as the execution
+ * holding it.
+ */
+export interface SimStatesRunRecord {
+    /**
+     * What the walk starts at its first state with.
+     */
+    readonly input: JSONValue;
+    /**
+     * Whether the walk is over, so nothing more of it should run.
+     *
+     * A branch a sibling's failure abandoned reads as stopped while its states
+     * are still scheduled on the clock, which is what stops them.
+     */
+    readonly stopped: boolean;
+    /**
+     * Record that the walk has entered a state.
+     */
+    enter(stateName: string): void;
+    /**
+     * Record that the walk ran a state, and what that run failed with.
+     */
+    attempt(stateName: string, error: string | undefined): void;
+    /**
+     * End the walk with the value its last state produced.
+     */
+    succeed(output: JSONValue, at: Date): void;
+    /**
+     * End the walk with the error that stopped it.
+     */
+    fail(error: string, cause: string | undefined, at: Date): void;
+    /**
+     * Record a branch, which is reported on the execution however deeply
+     * nested the state running it is. A branch that is given up on gives up on
+     * the branches it was running, so the run is held rather than what it
+     * reports.
+     */
+    child(child: SimStatesChildRun): void;
+}
+//# sourceMappingURL=sim-states-run-record.d.ts.map

package/dist/service/stepfunctions/execution/sim-states-run-record.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-run-record.d.ts","sourceRoot":"","sources":["../../../../src/service/stepfunctions/execution/sim-states-run-record.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AAClE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAEnE;;;;;;;GAOG;AACH,MAAM,WAAW,kBAAkB;IACjC;;OAEG;IACH,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC;IAE1B;;;;;OAKG;IACH,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAE1B;;OAEG;IACH,KAAK,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IAE/B;;OAEG;IACH,OAAO,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAAC;IAE5D;;OAEG;IACH,OAAO,CAAC,MAAM,EAAE,SAAS,EAAE,EAAE,EAAE,IAAI,GAAG,IAAI,CAAC;IAE3C;;OAEG;IACH,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,SAAS,EAAE,EAAE,EAAE,IAAI,GAAG,IAAI,CAAC;IAE/D;;;;;OAKG;IACH,KAAK,CAAC,KAAK,EAAE,iBAAiB,GAAG,IAAI,CAAC;CACvC"}

package/dist/service/stepfunctions/execution/sim-states-run-record.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=sim-states-run-record.js.map

package/dist/service/stepfunctions/execution/sim-states-run-record.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-run-record.js","sourceRoot":"","sources":["../../../../src/service/stepfunctions/execution/sim-states-run-record.ts"],"names":[],"mappings":""}

package/dist/service/stepfunctions/execution/sim-states-run-state.d.ts

@@ -7,9 +7,10 @@ import type { SimStatesStateContext, SimStatesStateOutcome } from "./sim-states-
  * A data-flow field raising is left to the caller, which reads the Amazon
  * States Language error name off whatever came out.
  *
- * This waits on the work a `Task` state does. Every other state type answers
- * without waiting for anything. A `Wait` state pauses the walk rather than
- * blocking it, and answers by saying what it is waiting for.
+ * This waits on the work a `Task` state does, and on the branches or
+ * iterations a `Parallel` or a `Map` state runs as far as they get. Every other state type answers without
+ * waiting for anything. A `Wait` state pauses the walk rather than blocking
+ * it, and answers by saying what it is waiting for.
  */
 export declare function runSimStatesState(state: SimStatesState, input: JSONValue, context: SimStatesStateContext): Promise<SimStatesStateOutcome>;
 //# sourceMappingURL=sim-states-run-state.d.ts.map

package/dist/service/stepfunctions/execution/sim-states-run-state.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sim-states-run-state.d.ts","sourceRoot":"","sources":["../../../../src/service/stepfunctions/execution/sim-states-run-state.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AAKlE,OAAO,KAAK,EAGV,cAAc,EAEf,MAAM,mCAAmC,CAAC;AAI3C,OAAO,KAAK,EACV,qBAAqB,EACrB,qBAAqB,EACtB,MAAM,+BAA+B,CAAC;AAOvC;;;;;;;;;GASG;AACH,wBAAsB,iBAAiB,CACrC,KAAK,EAAE,cAAc,EACrB,KAAK,EAAE,SAAS,EAChB,OAAO,EAAE,qBAAqB,GAC7B,OAAO,CAAC,qBAAqB,CAAC,CAsBhC"}
+{"version":3,"file":"sim-states-run-state.d.ts","sourceRoot":"","sources":["../../../../src/service/stepfunctions/execution/sim-states-run-state.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AAKlE,OAAO,KAAK,EAGV,cAAc,EAEf,MAAM,mCAAmC,CAAC;AAM3C,OAAO,KAAK,EACV,qBAAqB,EACrB,qBAAqB,EACtB,MAAM,+BAA+B,CAAC;AAOvC;;;;;;;;;;GAUG;AACH,wBAAsB,iBAAiB,CACrC,KAAK,EAAE,cAAc,EACrB,KAAK,EAAE,SAAS,EAChB,OAAO,EAAE,qBAAqB,GAC7B,OAAO,CAAC,qBAAqB,CAAC,CA8BhC"}