@kensio/yulin 1.19.4 → 1.20.1

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

@@ -0,0 +1,50 @@
+import { SimStepFunctionsError } from "../error/sim-step-functions.error.js";
+/**
+ * Read the Amazon States Language error name off whatever was raised.
+ */
+export function simStatesFailureFrom(error) {
+    if (error instanceof SimStepFunctionsError) {
+        return {
+            kind: "fail",
+            error: error.statesErrorName,
+            cause: error.message,
+        };
+    }
+    return {
+        kind: "fail",
+        error: "States.Runtime",
+        cause: error instanceof Error ? error.message : String(error),
+    };
+}
+/**
+ * How many state transitions one execution may make.
+ *
+ * Amazon States Language allows a cycle, so a definition can be valid and
+ * still never reach a terminal state. Real Step Functions stops such an
+ * execution when it runs out of execution history events, and this stands in
+ * for that limit. Without it the walk never returns and `StartExecution` never
+ * answers, which is the one failure a test tool must not have.
+ */
+export const simStatesMaximumTransitions = 25_000;
+/**
+ * The failure an execution whose states form a cycle ends with.
+ */
+export function simStatesCycleFailure() {
+    return {
+        kind: "fail",
+        error: "States.Runtime",
+        cause: `The execution made ${String(simStatesMaximumTransitions)} ` +
+            "transitions without reaching a terminal state. Its states form a cycle.",
+    };
+}
+/**
+ * The failure a transition naming no state ends the execution with.
+ */
+export function simStatesUnknownStateFailure(name) {
+    return {
+        kind: "fail",
+        error: "States.Runtime",
+        cause: `The state ${name} is not one of this state machine's states.`,
+    };
+}
+//# sourceMappingURL=sim-states-failure.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-failure.js","sourceRoot":"","sources":["../../../../src/service/stepfunctions/execution/sim-states-failure.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,sCAAsC,CAAC;AAG7E;;GAEG;AACH,MAAM,UAAU,oBAAoB,CAAC,KAAc;IACjD,IAAI,KAAK,YAAY,qBAAqB,EAAE,CAAC;QAC3C,OAAO;YACL,IAAI,EAAE,MAAM;YACZ,KAAK,EAAE,KAAK,CAAC,eAAe;YAC5B,KAAK,EAAE,KAAK,CAAC,OAAO;SACrB,CAAC;IACJ,CAAC;IAED,OAAO;QACL,IAAI,EAAE,MAAM;QACZ,KAAK,EAAE,gBAAgB;QACvB,KAAK,EAAE,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC;KAC9D,CAAC;AACJ,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,2BAA2B,GAAG,MAAM,CAAC;AAElD;;GAEG;AACH,MAAM,UAAU,qBAAqB;IACnC,OAAO;QACL,IAAI,EAAE,MAAM;QACZ,KAAK,EAAE,gBAAgB;QACvB,KAAK,EACH,sBAAsB,MAAM,CAAC,2BAA2B,CAAC,GAAG;YAC5D,yEAAyE;KAC5E,CAAC;AACJ,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,4BAA4B,CAC1C,IAAY;IAEZ,OAAO;QACL,IAAI,EAAE,MAAM;QACZ,KAAK,EAAE,gBAAgB;QACvB,KAAK,EAAE,aAAa,IAAI,6CAA6C;KACtE,CAAC;AACJ,CAAC"}

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

@@ -0,0 +1,42 @@
+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";
+interface SimStatesInterpreterProperties {
+    readonly definition: SimStatesDefinition;
+    readonly execution: SimStatesExecution;
+    readonly background: BackgroundScheduler;
+    /**
+     * Where a `Task` state does its work.
+     */
+    readonly tasks: SimStatesTaskTargets;
+    /**
+     * The state machine's execution role, which a task assumes.
+     */
+    readonly roleArn: string;
+}
+/**
+ * Walks one execution through its state machine.
+ *
+ * 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
+ * data-flow fields.
+ *
+ * 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.
+ */
+export declare class SimStatesInterpreter {
+    #private;
+    constructor(properties: SimStatesInterpreterProperties);
+    /**
+     * Run the execution 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.
+     */
+    run(): Promise<void>;
+}
+export {};
+//# sourceMappingURL=sim-states-interpreter.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,124 @@
+import { simStatesCycleFailure, simStatesMaximumTransitions, simStatesUnknownStateFailure, } from "./sim-states-failure.js";
+import { SimStatesSettlement } from "./sim-states-settlement.js";
+import { SimStatesStateRunner } from "./sim-states-state-runner.js";
+/**
+ * Walks one execution through its state machine.
+ *
+ * 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
+ * data-flow fields.
+ *
+ * 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.
+ */
+export class SimStatesInterpreter {
+    #definition;
+    #execution;
+    #background;
+    #runner;
+    #settlement;
+    /**
+     * Transitions made so far, counted across the pauses a `Wait` state makes.
+     */
+    #taken = 0;
+    constructor(properties) {
+        this.#definition = properties.definition;
+        this.#execution = properties.execution;
+        this.#background = properties.background;
+        this.#runner = new SimStatesStateRunner({
+            background: properties.background,
+            tasks: properties.tasks,
+            roleArn: properties.roleArn,
+        });
+        this.#settlement = new SimStatesSettlement({
+            execution: properties.execution,
+            background: properties.background,
+        });
+    }
+    /**
+     * Run the execution 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);
+    }
+    /**
+     * Walk from one state until the execution ends or a `Wait` pauses it.
+     */
+    async #walk(from, value) {
+        let current = from;
+        let carried = value;
+        for (;;) {
+            const state = this.#nextState(current);
+            if (state === undefined) {
+                return;
+            }
+            this.#execution.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.
+            // oxlint-disable-next-line eslint/no-await-in-loop
+            await this.#runner.run(state, carried, current));
+            if (carrying === undefined) {
+                return;
+            }
+            carried = carrying.output;
+            current = carrying.next;
+        }
+    }
+    /**
+     * 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.
+     *
+     * Answers with the outcome the walk carries on from, and with nothing where
+     * the execution has ended or is waiting on the clock.
+     */
+    #resolve(outcome) {
+        if (outcome.kind === "wait") {
+            return this.#wait(outcome.until, outcome.resume);
+        }
+        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;
+    }
+}
+//# sourceMappingURL=sim-states-interpreter.js.map

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

@@ -0,0 +1 @@
+{"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-run-choice.d.ts

@@ -0,0 +1,12 @@
+import type { JSONValue } from "../../../util/type-guard/json.js";
+import type { SimStatesChoiceState } from "../definition/sim-states-state.js";
+import type { SimStatesStateContext, SimStatesStateOutcome } from "./sim-states-state-outcome.js";
+/**
+ * A `Choice` state, which takes the first rule its input matches.
+ *
+ * The rules are tested in the order they were written, which is what lets a
+ * definition put its narrower rule first. A `Choice` state produces no result,
+ * so what it passes on is its own input.
+ */
+export declare function runSimStatesChoice(state: SimStatesChoiceState, input: JSONValue, context: SimStatesStateContext): SimStatesStateOutcome;
+//# sourceMappingURL=sim-states-run-choice.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,24 @@
+import { simStatesEffectiveInput, simStatesEffectiveOutput, } from "../data/sim-states-data-flow.js";
+import { SimStatesNoChoiceMatched } from "../error/sim-step-functions.error.js";
+/**
+ * A `Choice` state, which takes the first rule its input matches.
+ *
+ * The rules are tested in the order they were written, which is what lets a
+ * definition put its narrower rule first. A `Choice` state produces no result,
+ * so what it passes on is its own input.
+ */
+export function runSimStatesChoice(state, input, context) {
+    const effective = simStatesEffectiveInput(input, state);
+    const matched = state.Choices.find((rule) => rule.matches(effective));
+    const next = matched?.next ?? state.Default;
+    if (next === undefined) {
+        throw new SimStatesNoChoiceMatched(`The Choice state ${context.stateName} matched none of its rules and ` +
+            "carries no Default to fall back on.");
+    }
+    return {
+        kind: "next",
+        output: simStatesEffectiveOutput(effective, effective, state),
+        next,
+    };
+}
+//# sourceMappingURL=sim-states-run-choice.js.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,15 @@
+import type { JSONValue } from "../../../util/type-guard/json.js";
+import type { SimStatesState } from "../definition/sim-states-state.js";
+import type { SimStatesStateContext, SimStatesStateOutcome } from "./sim-states-state-outcome.js";
+/**
+ * Run one state and say what happened.
+ *
+ * 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.
+ */
+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

@@ -0,0 +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"}

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

@@ -0,0 +1,68 @@
+import { simStatesEffectiveInput, simStatesEffectiveOutput, } from "../data/sim-states-data-flow.js";
+import { runSimStatesChoice } from "./sim-states-run-choice.js";
+import { runSimStatesTask } from "./sim-states-run-task.js";
+import { runSimStatesWait } from "./sim-states-run-wait.js";
+/**
+ * The default a `Fail` state reports when it names no error.
+ */
+const unnamedFailError = "States.Unknown";
+/**
+ * Run one state and say what happened.
+ *
+ * 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.
+ */
+export async function runSimStatesState(state, input, context) {
+    if (state.Type === "Task") {
+        return await runSimStatesTask(state, input, context);
+    }
+    if (state.Type === "Fail") {
+        return runFail(state);
+    }
+    if (state.Type === "Succeed") {
+        return runSucceed(state, input);
+    }
+    if (state.Type === "Choice") {
+        return runSimStatesChoice(state, input, context);
+    }
+    if (state.Type === "Wait") {
+        return runSimStatesWait(state, input, context);
+    }
+    return runPass(state, input);
+}
+/**
+ * A `Pass` state, whose result is its `Result` or its effective input.
+ */
+function runPass(state, input) {
+    const effective = simStatesEffectiveInput(input, state);
+    const result = state.Result === undefined ? effective : state.Result;
+    const output = simStatesEffectiveOutput(input, result, state);
+    return state.Next === undefined
+        ? { kind: "succeed", output }
+        : { kind: "next", output, next: state.Next };
+}
+/**
+ * A `Succeed` state, which ends the execution with what reaches it.
+ */
+function runSucceed(state, input) {
+    const effective = simStatesEffectiveInput(input, state);
+    return {
+        kind: "succeed",
+        output: simStatesEffectiveOutput(effective, effective, state),
+    };
+}
+/**
+ * A `Fail` state, which ends the execution with the error it names.
+ */
+function runFail(state) {
+    return {
+        kind: "fail",
+        error: state.Error ?? unnamedFailError,
+        cause: state.Cause,
+    };
+}
+//# sourceMappingURL=sim-states-run-state.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-run-state.js","sourceRoot":"","sources":["../../../../src/service/stepfunctions/execution/sim-states-run-state.ts"],"names":[],"mappings":"AACA,OAAO,EACL,uBAAuB,EACvB,wBAAwB,GACzB,MAAM,iCAAiC,CAAC;AAOzC,OAAO,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAChE,OAAO,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAC5D,OAAO,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAM5D;;GAEG;AACH,MAAM,gBAAgB,GAAG,gBAAgB,CAAC;AAE1C;;;;;;;;;GASG;AACH,MAAM,CAAC,KAAK,UAAU,iBAAiB,CACrC,KAAqB,EACrB,KAAgB,EAChB,OAA8B;IAE9B,IAAI,KAAK,CAAC,IAAI,KAAK,MAAM,EAAE,CAAC;QAC1B,OAAO,MAAM,gBAAgB,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC;IACvD,CAAC;IAED,IAAI,KAAK,CAAC,IAAI,KAAK,MAAM,EAAE,CAAC;QAC1B,OAAO,OAAO,CAAC,KAAK,CAAC,CAAC;IACxB,CAAC;IAED,IAAI,KAAK,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC;QAC7B,OAAO,UAAU,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;IAClC,CAAC;IAED,IAAI,KAAK,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;QAC5B,OAAO,kBAAkB,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC;IACnD,CAAC;IAED,IAAI,KAAK,CAAC,IAAI,KAAK,MAAM,EAAE,CAAC;QAC1B,OAAO,gBAAgB,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC;IACjD,CAAC;IAED,OAAO,OAAO,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;AAC/B,CAAC;AAED;;GAEG;AACH,SAAS,OAAO,CACd,KAAyB,EACzB,KAAgB;IAEhB,MAAM,SAAS,GAAG,uBAAuB,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;IACxD,MAAM,MAAM,GAAG,KAAK,CAAC,MAAM,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC;IACrE,MAAM,MAAM,GAAG,wBAAwB,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC;IAE9D,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;AAED;;GAEG;AACH,SAAS,UAAU,CACjB,KAA4B,EAC5B,KAAgB;IAEhB,MAAM,SAAS,GAAG,uBAAuB,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;IAExD,OAAO;QACL,IAAI,EAAE,SAAS;QACf,MAAM,EAAE,wBAAwB,CAAC,SAAS,EAAE,SAAS,EAAE,KAAK,CAAC;KAC9D,CAAC;AACJ,CAAC;AAED;;GAEG;AACH,SAAS,OAAO,CAAC,KAAyB;IACxC,OAAO;QACL,IAAI,EAAE,MAAM;QACZ,KAAK,EAAE,KAAK,CAAC,KAAK,IAAI,gBAAgB;QACtC,KAAK,EAAE,KAAK,CAAC,KAAK;KACnB,CAAC;AACJ,CAAC"}

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

@@ -0,0 +1,14 @@
+import type { JSONValue } from "../../../util/type-guard/json.js";
+import type { SimStatesTaskState } from "../definition/sim-states-state.js";
+import type { SimStatesStateContext, SimStatesStateOutcome } from "./sim-states-state-outcome.js";
+/**
+ * A `Task` state, which does its work outside the state machine.
+ *
+ * The data-flow fields apply around the work the way they do around any other
+ * state. `InputPath` and `Parameters` build what the task is sent, and
+ * `ResultSelector`, `ResultPath` and `OutputPath` shape what comes back.
+ * `ResultPath` reads the state's raw input, so a task can put its result
+ * beside the input it was given.
+ */
+export declare function runSimStatesTask(state: SimStatesTaskState, input: JSONValue, context: SimStatesStateContext): Promise<SimStatesStateOutcome>;
+//# sourceMappingURL=sim-states-run-task.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-run-task.d.ts","sourceRoot":"","sources":["../../../../src/service/stepfunctions/execution/sim-states-run-task.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AAKlE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAC;AAC5E,OAAO,KAAK,EACV,qBAAqB,EACrB,qBAAqB,EACtB,MAAM,+BAA+B,CAAC;AAEvC;;;;;;;;GAQG;AACH,wBAAsB,gBAAgB,CACpC,KAAK,EAAE,kBAAkB,EACzB,KAAK,EAAE,SAAS,EAChB,OAAO,EAAE,qBAAqB,GAC7B,OAAO,CAAC,qBAAqB,CAAC,CAahC"}

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

@@ -0,0 +1,23 @@
+import { simStatesEffectiveInput, simStatesEffectiveOutput, } from "../data/sim-states-data-flow.js";
+/**
+ * A `Task` state, which does its work outside the state machine.
+ *
+ * The data-flow fields apply around the work the way they do around any other
+ * state. `InputPath` and `Parameters` build what the task is sent, and
+ * `ResultSelector`, `ResultPath` and `OutputPath` shape what comes back.
+ * `ResultPath` reads the state's raw input, so a task can put its result
+ * beside the input it was given.
+ */
+export async function runSimStatesTask(state, input, context) {
+    const result = await context.tasks.invoke({
+        stateName: context.stateName,
+        target: state.target,
+        payload: simStatesEffectiveInput(input, state),
+        roleArn: context.roleArn,
+    });
+    const output = simStatesEffectiveOutput(input, result, state);
+    return state.Next === undefined
+        ? { kind: "succeed", output }
+        : { kind: "next", output, next: state.Next };
+}
+//# sourceMappingURL=sim-states-run-task.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-run-task.js","sourceRoot":"","sources":["../../../../src/service/stepfunctions/execution/sim-states-run-task.ts"],"names":[],"mappings":"AACA,OAAO,EACL,uBAAuB,EACvB,wBAAwB,GACzB,MAAM,iCAAiC,CAAC;AAOzC;;;;;;;;GAQG;AACH,MAAM,CAAC,KAAK,UAAU,gBAAgB,CACpC,KAAyB,EACzB,KAAgB,EAChB,OAA8B;IAE9B,MAAM,MAAM,GAAG,MAAM,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC;QACxC,SAAS,EAAE,OAAO,CAAC,SAAS;QAC5B,MAAM,EAAE,KAAK,CAAC,MAAM;QACpB,OAAO,EAAE,uBAAuB,CAAC,KAAK,EAAE,KAAK,CAAC;QAC9C,OAAO,EAAE,OAAO,CAAC,OAAO;KACzB,CAAC,CAAC;IAEH,MAAM,MAAM,GAAG,wBAAwB,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC;IAE9D,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-run-wait.d.ts

@@ -0,0 +1,11 @@
+import type { JSONValue } from "../../../util/type-guard/json.js";
+import type { SimStatesWaitState } from "../definition/sim-states-state.js";
+import type { SimStatesStateContext, SimStatesStateOutcome } from "./sim-states-state-outcome.js";
+/**
+ * A `Wait` state, which holds the execution until an instant on the clock.
+ *
+ * Like a `Choice` state it produces no result. What it passes on once the wait
+ * is over is its own input.
+ */
+export declare function runSimStatesWait(state: SimStatesWaitState, input: JSONValue, context: SimStatesStateContext): SimStatesStateOutcome;
+//# sourceMappingURL=sim-states-run-wait.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-run-wait.d.ts","sourceRoot":"","sources":["../../../../src/service/stepfunctions/execution/sim-states-run-wait.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AAKlE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAC;AAE5E,OAAO,KAAK,EAEV,qBAAqB,EACrB,qBAAqB,EACtB,MAAM,+BAA+B,CAAC;AAEvC;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,kBAAkB,EACzB,KAAK,EAAE,SAAS,EAChB,OAAO,EAAE,qBAAqB,GAC7B,qBAAqB,CAavB"}

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

@@ -0,0 +1,21 @@
+import { simStatesEffectiveInput, simStatesEffectiveOutput, } from "../data/sim-states-data-flow.js";
+import { simStatesWaitDue } from "../wait/sim-states-wait-due.js";
+/**
+ * A `Wait` state, which holds the execution until an instant on the clock.
+ *
+ * Like a `Choice` state it produces no result. What it passes on once the wait
+ * is over is its own input.
+ */
+export function runSimStatesWait(state, input, context) {
+    const effective = simStatesEffectiveInput(input, state);
+    const output = simStatesEffectiveOutput(effective, effective, state);
+    const resume = state.Next === undefined
+        ? { kind: "succeed", output }
+        : { kind: "next", output, next: state.Next };
+    return {
+        kind: "wait",
+        until: simStatesWaitDue(state, effective, context.now),
+        resume,
+    };
+}
+//# sourceMappingURL=sim-states-run-wait.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-run-wait.js","sourceRoot":"","sources":["../../../../src/service/stepfunctions/execution/sim-states-run-wait.ts"],"names":[],"mappings":"AACA,OAAO,EACL,uBAAuB,EACvB,wBAAwB,GACzB,MAAM,iCAAiC,CAAC;AAEzC,OAAO,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAC;AAOlE;;;;;GAKG;AACH,MAAM,UAAU,gBAAgB,CAC9B,KAAyB,EACzB,KAAgB,EAChB,OAA8B;IAE9B,MAAM,SAAS,GAAG,uBAAuB,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;IACxD,MAAM,MAAM,GAAG,wBAAwB,CAAC,SAAS,EAAE,SAAS,EAAE,KAAK,CAAC,CAAC;IACrE,MAAM,MAAM,GACV,KAAK,CAAC,IAAI,KAAK,SAAS;QACtB,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;IAEjD,OAAO;QACL,IAAI,EAAE,MAAM;QACZ,KAAK,EAAE,gBAAgB,CAAC,KAAK,EAAE,SAAS,EAAE,OAAO,CAAC,GAAG,CAAC;QACtD,MAAM;KACP,CAAC;AACJ,CAAC"}

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

@@ -0,0 +1,27 @@
+import type { BackgroundScheduler } from "../../../util/background/background.js";
+import type { SimStatesExecution } from "./sim-states-execution.js";
+import type { SimStatesNextOutcome, SimStatesSettledOutcome } from "./sim-states-state-outcome.js";
+interface SimStatesSettlementProperties {
+    readonly execution: SimStatesExecution;
+    readonly background: BackgroundScheduler;
+}
+/**
+ * Records on one execution whatever its states leave it as.
+ *
+ * The interpreter walks the states and this holds what the walk did, which
+ * keeps the recording in one place for the walk and for a `Wait` state
+ * carrying on later.
+ */
+export declare class SimStatesSettlement {
+    #private;
+    constructor(properties: SimStatesSettlementProperties);
+    /**
+     * Record what a state's outcome ended the execution with.
+     *
+     * Answers with the outcome the walk carries on from, and with nothing where
+     * the execution has ended.
+     */
+    settle(outcome: SimStatesSettledOutcome): SimStatesNextOutcome | undefined;
+}
+export {};
+//# sourceMappingURL=sim-states-settlement.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-settlement.d.ts","sourceRoot":"","sources":["../../../../src/service/stepfunctions/execution/sim-states-settlement.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,wCAAwC,CAAC;AAClF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AACpE,OAAO,KAAK,EACV,oBAAoB,EACpB,uBAAuB,EACxB,MAAM,+BAA+B,CAAC;AAEvC,UAAU,6BAA6B;IACrC,QAAQ,CAAC,SAAS,EAAE,kBAAkB,CAAC;IACvC,QAAQ,CAAC,UAAU,EAAE,mBAAmB,CAAC;CAC1C;AAED;;;;;;GAMG;AACH,qBAAa,mBAAmB;;IAI9B,YAAY,UAAU,EAAE,6BAA6B,EAGpD;IAED;;;;;OAKG;IACH,MAAM,CAAC,OAAO,EAAE,uBAAuB,GAAG,oBAAoB,GAAG,SAAS,CAazE;CACF"}

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

@@ -0,0 +1,33 @@
+/**
+ * Records on one execution whatever its states leave it as.
+ *
+ * The interpreter walks the states and this holds what the walk did, which
+ * keeps the recording in one place for the walk and for a `Wait` state
+ * carrying on later.
+ */
+export class SimStatesSettlement {
+    #execution;
+    #background;
+    constructor(properties) {
+        this.#execution = properties.execution;
+        this.#background = properties.background;
+    }
+    /**
+     * Record what a state's outcome ended the execution with.
+     *
+     * Answers with the outcome the walk carries on from, and with nothing where
+     * the execution has ended.
+     */
+    settle(outcome) {
+        if (outcome.kind === "next") {
+            return outcome;
+        }
+        if (outcome.kind === "succeed") {
+            this.#execution.succeed(outcome.output, this.#background.now());
+            return undefined;
+        }
+        this.#execution.fail(outcome.error, outcome.cause, this.#background.now());
+        return undefined;
+    }
+}
+//# sourceMappingURL=sim-states-settlement.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-settlement.js","sourceRoot":"","sources":["../../../../src/service/stepfunctions/execution/sim-states-settlement.ts"],"names":[],"mappings":"AAYA;;;;;;GAMG;AACH,MAAM,OAAO,mBAAmB;IACrB,UAAU,CAAqB;IAC/B,WAAW,CAAsB;IAE1C,YAAY,UAAyC;QACnD,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC,SAAS,CAAC;QACvC,IAAI,CAAC,WAAW,GAAG,UAAU,CAAC,UAAU,CAAC;IAC3C,CAAC;IAED;;;;;OAKG;IACH,MAAM,CAAC,OAAgC;QACrC,IAAI,OAAO,CAAC,IAAI,KAAK,MAAM,EAAE,CAAC;YAC5B,OAAO,OAAO,CAAC;QACjB,CAAC;QAED,IAAI,OAAO,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC;YAC/B,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,OAAO,CAAC,MAAM,EAAE,IAAI,CAAC,WAAW,CAAC,GAAG,EAAE,CAAC,CAAC;YAChE,OAAO,SAAS,CAAC;QACnB,CAAC;QAED,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,OAAO,CAAC,KAAK,EAAE,IAAI,CAAC,WAAW,CAAC,GAAG,EAAE,CAAC,CAAC;QAE3E,OAAO,SAAS,CAAC;IACnB,CAAC;CACF"}

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

@@ -0,0 +1,46 @@
+import type { JSONValue } from "../../../util/type-guard/json.js";
+import type { SimStatesTaskTargets } from "../task/sim-states-task-invocation.js";
+/**
+ * What a state leaves the execution to do once it has run.
+ */
+export interface SimStatesNextOutcome {
+    readonly kind: "next";
+    readonly output: JSONValue;
+    readonly next: string;
+}
+export type SimStatesMoveOnOutcome = SimStatesNextOutcome | {
+    readonly kind: "succeed";
+    readonly output: JSONValue;
+};
+/**
+ * What running one state did to the execution.
+ *
+ * A `wait` outcome carries what the execution does once the clock reaches the
+ * instant, which is either the next state or the end of the execution.
+ */
+export type SimStatesSettledOutcome = SimStatesMoveOnOutcome | {
+    readonly kind: "fail";
+    readonly error: string;
+    readonly cause: string | undefined;
+};
+export type SimStatesStateOutcome = SimStatesSettledOutcome | {
+    readonly kind: "wait";
+    readonly until: Date;
+    readonly resume: SimStatesMoveOnOutcome;
+};
+/**
+ * What a state knows about the execution it is running in.
+ */
+export interface SimStatesStateContext {
+    readonly stateName: string;
+    readonly now: Date;
+    /**
+     * Where a `Task` state does its work.
+     */
+    readonly tasks: SimStatesTaskTargets;
+    /**
+     * The state machine's execution role, which a task assumes.
+     */
+    readonly roleArn: string;
+}
+//# sourceMappingURL=sim-states-state-outcome.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-state-outcome.d.ts","sourceRoot":"","sources":["../../../../src/service/stepfunctions/execution/sim-states-state-outcome.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AAClE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,uCAAuC,CAAC;AAElF;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAC;IAC3B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,MAAM,sBAAsB,GAC9B,oBAAoB,GACpB;IAAE,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,SAAS,CAAA;CAAE,CAAC;AAE7D;;;;;GAKG;AACH,MAAM,MAAM,uBAAuB,GAC/B,sBAAsB,GACtB;IACE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;CACpC,CAAC;AAEN,MAAM,MAAM,qBAAqB,GAC7B,uBAAuB,GACvB;IACE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,IAAI,CAAC;IACrB,QAAQ,CAAC,MAAM,EAAE,sBAAsB,CAAC;CACzC,CAAC;AAEN;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,GAAG,EAAE,IAAI,CAAC;IAEnB;;OAEG;IACH,QAAQ,CAAC,KAAK,EAAE,oBAAoB,CAAC;IAErC;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B"}

package/dist/service/stepfunctions/execution/sim-states-state-outcome.js

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

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

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

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

@@ -0,0 +1,27 @@
+import type { BackgroundScheduler } from "../../../util/background/background.js";
+import type { JSONValue } from "../../../util/type-guard/json.js";
+import type { SimStatesState } from "../definition/sim-states-state.js";
+import type { SimStatesTaskTargets } from "../task/sim-states-task-invocation.js";
+import type { SimStatesStateOutcome } from "./sim-states-state-outcome.js";
+interface SimStatesStateRunnerProperties {
+    readonly background: BackgroundScheduler;
+    readonly tasks: SimStatesTaskTargets;
+    readonly roleArn: string;
+}
+/**
+ * Runs one state of an execution, and never raises.
+ *
+ * What a state knows about the execution it is running in is gathered here,
+ * and so is reading the Amazon States Language error name off whatever a state
+ * raised. Both leave the interpreter with the walk alone.
+ */
+export declare class SimStatesStateRunner {
+    #private;
+    constructor(properties: SimStatesStateRunnerProperties);
+    /**
+     * Run one state and say what happened, failure included.
+     */
+    run(state: SimStatesState, input: JSONValue, stateName: string): Promise<SimStatesStateOutcome>;
+}
+export {};
+//# sourceMappingURL=sim-states-state-runner.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-state-runner.d.ts","sourceRoot":"","sources":["../../../../src/service/stepfunctions/execution/sim-states-state-runner.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,wCAAwC,CAAC;AAClF,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AAClE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mCAAmC,CAAC;AACxE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,uCAAuC,CAAC;AAGlF,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,+BAA+B,CAAC;AAE3E,UAAU,8BAA8B;IACtC,QAAQ,CAAC,UAAU,EAAE,mBAAmB,CAAC;IACzC,QAAQ,CAAC,KAAK,EAAE,oBAAoB,CAAC;IACrC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED;;;;;;GAMG;AACH,qBAAa,oBAAoB;;IAK/B,YAAY,UAAU,EAAE,8BAA8B,EAIrD;IAED;;OAEG;IACG,GAAG,CACP,KAAK,EAAE,cAAc,EACrB,KAAK,EAAE,SAAS,EAChB,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,qBAAqB,CAAC,CAWhC;CACF"}