@kensio/yulin 1.20.1 → 1.20.3

package/dist/service/stepfunctions/execution/sim-states-fan-out-outcome.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-fan-out-outcome.js","sourceRoot":"","sources":["../../../../src/service/stepfunctions/execution/sim-states-fan-out-outcome.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,wBAAwB,GACzB,MAAM,iCAAiC,CAAC;AAUzC;;;;;;GAMG;AACH,MAAM,UAAU,sBAAsB,CACpC,KAA2B,EAC3B,KAAgB,EAChB,OAA6B,EAC7B,OAAkB;IAElB,MAAM,MAAM,GAAG,wBAAwB,CAAC,KAAK,EAAE,CAAC,GAAG,OAAO,CAAC,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC;IAE7E,OAAO,KAAK,CAAC,IAAI,KAAK,SAAS;QAC7B,CAAC,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,EAAE;QAC7B,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC;AACjD,CAAC"}

package/dist/service/stepfunctions/execution/sim-states-fan-out.d.ts

@@ -0,0 +1,46 @@
+import type { JSONValue } from "../../../util/type-guard/json.js";
+import type { SimStatesChildKind } from "./sim-states-child.js";
+import { type SimStatesChildStart } from "./sim-states-child-runs.js";
+import type { SimStatesSettledOutcome, SimStatesStateContext, SimStatesStateOutcome } from "./sim-states-state-outcome.js";
+interface SimStatesFanOutProperties {
+    readonly kind: SimStatesChildKind;
+    readonly context: SimStatesStateContext;
+    readonly children: readonly SimStatesChildStart[];
+    /**
+     * How many children may be running at once.
+     */
+    readonly limit: number;
+    /**
+     * What one child is called, for the failure the state ends with.
+     */
+    readonly names: (index: number) => string;
+    /**
+     * What the state answers, given what every child produced in child order.
+     */
+    readonly answers: (outputs: readonly JSONValue[]) => SimStatesSettledOutcome;
+}
+/**
+ * Runs the children of one state, and says what the state made of them.
+ *
+ * A child that reaches a `Wait` state is left on the clock rather than waited
+ * for, so its siblings run while it waits. The state itself suspends when any
+ * of them does, and answers through the walk's `resume` once the last one has
+ * finished.
+ *
+ * A child that fails takes the state with it. The siblings still going are
+ * abandoned, which leaves whatever they had scheduled on the clock to find a
+ * child that has stopped.
+ */
+export declare class SimStatesFanOut {
+    #private;
+    constructor(properties: SimStatesFanOutProperties);
+    /**
+     * Start the children, and say what the state did as far as they have got.
+     *
+     * Everything that answers without waiting on the clock has answered by the
+     * time this does, so a fan-out with nothing to wait for never suspends.
+     */
+    run(): Promise<SimStatesStateOutcome>;
+}
+export {};
+//# sourceMappingURL=sim-states-fan-out.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-fan-out.d.ts","sourceRoot":"","sources":["../../../../src/service/stepfunctions/execution/sim-states-fan-out.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AAClE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAGhE,OAAO,EACL,KAAK,mBAAmB,EAEzB,MAAM,4BAA4B,CAAC;AAEpC,OAAO,KAAK,EAEV,uBAAuB,EACvB,qBAAqB,EACrB,qBAAqB,EACtB,MAAM,+BAA+B,CAAC;AAEvC,UAAU,yBAAyB;IACjC,QAAQ,CAAC,IAAI,EAAE,kBAAkB,CAAC;IAClC,QAAQ,CAAC,OAAO,EAAE,qBAAqB,CAAC;IACxC,QAAQ,CAAC,QAAQ,EAAE,SAAS,mBAAmB,EAAE,CAAC;IAElD;;OAEG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IAEvB;;OAEG;IACH,QAAQ,CAAC,KAAK,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC;IAE1C;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,CAAC,OAAO,EAAE,SAAS,SAAS,EAAE,KAAK,uBAAuB,CAAC;CAC9E;AAED;;;;;;;;;;;GAWG;AACH,qBAAa,eAAe;;IAa1B,YAAY,UAAU,EAAE,yBAAyB,EAahD;IAED;;;;;OAKG;IACG,GAAG,IAAI,OAAO,CAAC,qBAAqB,CAAC,CAY1C;CA8DF"}

package/dist/service/stepfunctions/execution/sim-states-fan-out.js

@@ -0,0 +1,106 @@
+import { simStatesChildFailure } from "./sim-states-child-failure.js";
+import { SimStatesChildRuns, } from "./sim-states-child-runs.js";
+import { simStatesFailureFrom } from "./sim-states-failure.js";
+/**
+ * Runs the children of one state, and says what the state made of them.
+ *
+ * A child that reaches a `Wait` state is left on the clock rather than waited
+ * for, so its siblings run while it waits. The state itself suspends when any
+ * of them does, and answers through the walk's `resume` once the last one has
+ * finished.
+ *
+ * A child that fails takes the state with it. The siblings still going are
+ * abandoned, which leaves whatever they had scheduled on the clock to find a
+ * child that has stopped.
+ */
+export class SimStatesFanOut {
+    #context;
+    #names;
+    #answers;
+    #children;
+    #failure;
+    /**
+     * Whether the state has told the walk that it suspended, and so owes it an
+     * answer through `resume`.
+     */
+    #suspended = false;
+    constructor(properties) {
+        this.#context = properties.context;
+        this.#names = properties.names;
+        this.#answers = properties.answers;
+        this.#children = new SimStatesChildRuns({
+            kind: properties.kind,
+            context: properties.context,
+            children: properties.children,
+            limit: properties.limit,
+            onSettled: async (run) => {
+                await this.#settled(run);
+            },
+        });
+    }
+    /**
+     * Start the children, and say what the state did as far as they have got.
+     *
+     * Everything that answers without waiting on the clock has answered by the
+     * time this does, so a fan-out with nothing to wait for never suspends.
+     */
+    async run() {
+        await this.#children.start();
+        const outcome = this.#outcome();
+        if (outcome !== undefined) {
+            return outcome;
+        }
+        this.#suspended = true;
+        return { kind: "pending" };
+    }
+    /**
+     * Take in that one child has ended, and carry on from there.
+     */
+    async #settled(run) {
+        if (this.#failure !== undefined) {
+            return;
+        }
+        this.#children.ended();
+        const failure = run.failure;
+        if (failure !== undefined) {
+            this.#failure = simStatesChildFailure(this.#names(run.index), failure);
+            this.#children.abandon();
+        }
+        await this.#children.start();
+        await this.#resumed();
+    }
+    /**
+     * Answer the walk, where the state suspended and is now done.
+     */
+    async #resumed() {
+        if (!this.#suspended) {
+            return;
+        }
+        const outcome = this.#outcome();
+        if (outcome === undefined) {
+            return;
+        }
+        this.#suspended = false;
+        await this.#context.resume(outcome);
+    }
+    /**
+     * What the state did, where its children are done enough to say.
+     */
+    #outcome() {
+        if (this.#failure !== undefined) {
+            return this.#failure;
+        }
+        if (!this.#children.finished) {
+            return undefined;
+        }
+        try {
+            return this.#answers(this.#children.outputs);
+        }
+        catch (error) {
+            // A ResultPath with nowhere to write fails the state rather than the
+            // clock advance that released the last child.
+            return simStatesFailureFrom(error);
+        }
+    }
+}
+//# sourceMappingURL=sim-states-fan-out.js.map

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

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

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

@@ -1,22 +1,23 @@
 import type { BackgroundScheduler } from "../../../util/background/background.js";
 import type { SimStatesDefinition } from "../definition/sim-states-definition.js";
-import type { SimStatesTaskTargets } from "../task/sim-states-task-invocation.js";
-import type { SimStatesExecution } from "./sim-states-execution.js";
+import type { SimStatesChildWalk } from "./sim-states-child-walk.js";
+import type { SimStatesWalkContext } from "./sim-states-state-outcome.js";
 interface SimStatesInterpreterProperties {
     readonly definition: SimStatesDefinition;
-    readonly execution: SimStatesExecution;
     readonly background: BackgroundScheduler;
     /**
-     * Where a `Task` state does its work.
+     * What every state of this walk is given, the record it writes itself on
+     * included.
      */
-    readonly tasks: SimStatesTaskTargets;
+    readonly walk: SimStatesWalkContext;
     /**
-     * The state machine's execution role, which a task assumes.
+     * What to do once this walk has ended, which is how a branch tells the
+     * `Parallel` state holding it.
      */
-    readonly roleArn: string;
+    readonly onSettled?: () => Promise<void>;
 }
 /**
- * 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
@@ -24,13 +25,19 @@ interface SimStatesInterpreterProperties {
  *
  * 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 declare class SimStatesInterpreter {
+export declare class SimStatesInterpreter implements SimStatesChildWalk {
     #private;
     constructor(properties: SimStatesInterpreterProperties);
     /**
-     * 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

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"}