@kensio/yulin 1.20.0 → 1.20.1

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

@@ -0,0 +1,55 @@
+/**
+ * The executions one simulated Step Functions holds, by ARN.
+ *
+ * Executions are kept after they end. `DescribeExecution` answers for a
+ * finished one, and real Step Functions keeps a standard execution's history
+ * for 90 days.
+ */
+export class SimStatesExecutionStore {
+    #byArn = new Map();
+    add(execution) {
+        this.#byArn.set(execution.arn, execution);
+    }
+    find(arn) {
+        return this.#byArn.get(arn);
+    }
+    /**
+     * Every execution of one state machine, most recently started first.
+     */
+    forStateMachine(stateMachineArn) {
+        return this.#byArn
+            .values()
+            .filter((execution) => execution.stateMachineArn === stateMachineArn)
+            .toArray()
+            .toReversed();
+    }
+    /**
+     * One state machine's execution of a name, where it has one.
+     *
+     * Real Step Functions keeps a name taken for 90 days after the execution
+     * closes, which is what makes a name usable for idempotency.
+     */
+    findByName(stateMachineArn, name) {
+        return this.#byArn
+            .values()
+            .find((execution) => execution.stateMachineArn === stateMachineArn &&
+            execution.name === name);
+    }
+    /**
+     * Whether one state machine already has an execution of this name.
+     */
+    hasName(stateMachineArn, name) {
+        return this.findByName(stateMachineArn, name) !== undefined;
+    }
+    /**
+     * Forget every execution of one state machine.
+     */
+    removeForStateMachine(stateMachineArn) {
+        for (const [arn, execution] of this.#byArn) {
+            if (execution.stateMachineArn === stateMachineArn) {
+                this.#byArn.delete(arn);
+            }
+        }
+    }
+}
+//# sourceMappingURL=sim-states-execution-store.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-execution-store.js","sourceRoot":"","sources":["../../../../src/service/stepfunctions/execution/sim-states-execution-store.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,MAAM,OAAO,uBAAuB;IACzB,MAAM,GAAG,IAAI,GAAG,EAA8B,CAAC;IAExD,GAAG,CAAC,SAA6B;QAC/B,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,SAAS,CAAC,GAAG,EAAE,SAAS,CAAC,CAAC;IAC5C,CAAC;IAED,IAAI,CAAC,GAAW;QACd,OAAO,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IAC9B,CAAC;IAED;;OAEG;IACH,eAAe,CAAC,eAAuB;QACrC,OAAO,IAAI,CAAC,MAAM;aACf,MAAM,EAAE;aACR,MAAM,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,SAAS,CAAC,eAAe,KAAK,eAAe,CAAC;aACpE,OAAO,EAAE;aACT,UAAU,EAAE,CAAC;IAClB,CAAC;IAED;;;;;OAKG;IACH,UAAU,CACR,eAAuB,EACvB,IAAY;QAEZ,OAAO,IAAI,CAAC,MAAM;aACf,MAAM,EAAE;aACR,IAAI,CACH,CAAC,SAAS,EAAE,EAAE,CACZ,SAAS,CAAC,eAAe,KAAK,eAAe;YAC7C,SAAS,CAAC,IAAI,KAAK,IAAI,CAC1B,CAAC;IACN,CAAC;IAED;;OAEG;IACH,OAAO,CAAC,eAAuB,EAAE,IAAY;QAC3C,OAAO,IAAI,CAAC,UAAU,CAAC,eAAe,EAAE,IAAI,CAAC,KAAK,SAAS,CAAC;IAC9D,CAAC;IAED;;OAEG;IACH,qBAAqB,CAAC,eAAuB;QAC3C,KAAK,MAAM,CAAC,GAAG,EAAE,SAAS,CAAC,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC;YAC3C,IAAI,SAAS,CAAC,eAAe,KAAK,eAAe,EAAE,CAAC;gBAClD,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;YAC1B,CAAC;QACH,CAAC;IACH,CAAC;CACF"}

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

@@ -0,0 +1,53 @@
+import type { JSONValue } from "../../../util/type-guard/json.js";
+export type SimStatesExecutionStatus = "RUNNING" | "SUCCEEDED" | "FAILED" | "TIMED_OUT" | "ABORTED";
+interface SimStatesExecutionProperties {
+    readonly arn: string;
+    readonly name: string;
+    readonly stateMachineArn: string;
+    readonly input: JSONValue;
+    readonly startDate: Date;
+}
+/**
+ * One run of a state machine.
+ *
+ * An execution holds what it has done as well as where it got to, because the
+ * states it visited are what a test asserts on. Real Step Functions keeps the
+ * same record and answers it through `GetExecutionHistory`.
+ */
+export declare class SimStatesExecution {
+    #private;
+    readonly arn: string;
+    readonly name: string;
+    readonly stateMachineArn: string;
+    readonly input: JSONValue;
+    readonly startDate: Date;
+    constructor(properties: SimStatesExecutionProperties);
+    get status(): SimStatesExecutionStatus;
+    get output(): JSONValue | undefined;
+    get error(): string | undefined;
+    get cause(): string | undefined;
+    get stopDate(): Date | undefined;
+    /**
+     * The states this execution has entered, in the order it entered them.
+     */
+    get visitedStates(): readonly string[];
+    /**
+     * Record that the execution has entered a state.
+     */
+    enter(stateName: string): void;
+    /**
+     * End the execution with the value its last state produced.
+     */
+    succeed(output: JSONValue, at: Date): void;
+    /**
+     * End the execution with the error that stopped it.
+     *
+     * Nothing is thrown from here. An execution failing is as often the thing a
+     * test is asserting on as it is a fault, and advancing the clock past a
+     * failure elsewhere in the same test would otherwise raise from that
+     * caller's `advanceBy`.
+     */
+    fail(error: string, cause: string | undefined, at: Date): void;
+}
+export {};
+//# sourceMappingURL=sim-states-execution.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-execution.d.ts","sourceRoot":"","sources":["../../../../src/service/stepfunctions/execution/sim-states-execution.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AAElE,MAAM,MAAM,wBAAwB,GAChC,SAAS,GACT,WAAW,GACX,QAAQ,GACR,WAAW,GACX,SAAS,CAAC;AAEd,UAAU,4BAA4B;IACpC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC;IAC1B,QAAQ,CAAC,SAAS,EAAE,IAAI,CAAC;CAC1B;AAED;;;;;;GAMG;AACH,qBAAa,kBAAkB;;IAC7B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC;IAC1B,QAAQ,CAAC,SAAS,EAAE,IAAI,CAAC;IASzB,YAAY,UAAU,EAAE,4BAA4B,EAMnD;IAED,IAAI,MAAM,IAAI,wBAAwB,CAErC;IAED,IAAI,MAAM,IAAI,SAAS,GAAG,SAAS,CAElC;IAED,IAAI,KAAK,IAAI,MAAM,GAAG,SAAS,CAE9B;IAED,IAAI,KAAK,IAAI,MAAM,GAAG,SAAS,CAE9B;IAED,IAAI,QAAQ,IAAI,IAAI,GAAG,SAAS,CAE/B;IAED;;OAEG;IACH,IAAI,aAAa,IAAI,SAAS,MAAM,EAAE,CAErC;IAED;;OAEG;IACH,KAAK,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAE7B;IAED;;OAEG;IACH,OAAO,CAAC,MAAM,EAAE,SAAS,EAAE,EAAE,EAAE,IAAI,GAAG,IAAI,CAIzC;IAED;;;;;;;OAOG;IACH,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,SAAS,EAAE,EAAE,EAAE,IAAI,GAAG,IAAI,CAK7D;CACF"}

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

@@ -0,0 +1,77 @@
+/**
+ * One run of a state machine.
+ *
+ * An execution holds what it has done as well as where it got to, because the
+ * states it visited are what a test asserts on. Real Step Functions keeps the
+ * same record and answers it through `GetExecutionHistory`.
+ */
+export class SimStatesExecution {
+    arn;
+    name;
+    stateMachineArn;
+    input;
+    startDate;
+    #status = "RUNNING";
+    #output;
+    #error;
+    #cause;
+    #stopDate;
+    #visited = [];
+    constructor(properties) {
+        this.arn = properties.arn;
+        this.name = properties.name;
+        this.stateMachineArn = properties.stateMachineArn;
+        this.input = properties.input;
+        this.startDate = properties.startDate;
+    }
+    get status() {
+        return this.#status;
+    }
+    get output() {
+        return this.#output;
+    }
+    get error() {
+        return this.#error;
+    }
+    get cause() {
+        return this.#cause;
+    }
+    get stopDate() {
+        return this.#stopDate;
+    }
+    /**
+     * The states this execution has entered, in the order it entered them.
+     */
+    get visitedStates() {
+        return [...this.#visited];
+    }
+    /**
+     * Record that the execution has entered a state.
+     */
+    enter(stateName) {
+        this.#visited.push(stateName);
+    }
+    /**
+     * End the execution with the value its last state produced.
+     */
+    succeed(output, at) {
+        this.#status = "SUCCEEDED";
+        this.#output = output;
+        this.#stopDate = at;
+    }
+    /**
+     * End the execution with the error that stopped it.
+     *
+     * Nothing is thrown from here. An execution failing is as often the thing a
+     * test is asserting on as it is a fault, and advancing the clock past a
+     * failure elsewhere in the same test would otherwise raise from that
+     * caller's `advanceBy`.
+     */
+    fail(error, cause, at) {
+        this.#status = "FAILED";
+        this.#error = error;
+        this.#cause = cause;
+        this.#stopDate = at;
+    }
+}
+//# sourceMappingURL=sim-states-execution.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-execution.js","sourceRoot":"","sources":["../../../../src/service/stepfunctions/execution/sim-states-execution.ts"],"names":[],"mappings":"AAiBA;;;;;;GAMG;AACH,MAAM,OAAO,kBAAkB;IACpB,GAAG,CAAS;IACZ,IAAI,CAAS;IACb,eAAe,CAAS;IACxB,KAAK,CAAY;IACjB,SAAS,CAAO;IAEzB,OAAO,GAA6B,SAAS,CAAC;IAC9C,OAAO,CAAwB;IAC/B,MAAM,CAAqB;IAC3B,MAAM,CAAqB;IAC3B,SAAS,CAAmB;IACnB,QAAQ,GAAa,EAAE,CAAC;IAEjC,YAAY,UAAwC;QAClD,IAAI,CAAC,GAAG,GAAG,UAAU,CAAC,GAAG,CAAC;QAC1B,IAAI,CAAC,IAAI,GAAG,UAAU,CAAC,IAAI,CAAC;QAC5B,IAAI,CAAC,eAAe,GAAG,UAAU,CAAC,eAAe,CAAC;QAClD,IAAI,CAAC,KAAK,GAAG,UAAU,CAAC,KAAK,CAAC;QAC9B,IAAI,CAAC,SAAS,GAAG,UAAU,CAAC,SAAS,CAAC;IACxC,CAAC;IAED,IAAI,MAAM;QACR,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IAED,IAAI,MAAM;QACR,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IAED,IAAI,KAAK;QACP,OAAO,IAAI,CAAC,MAAM,CAAC;IACrB,CAAC;IAED,IAAI,KAAK;QACP,OAAO,IAAI,CAAC,MAAM,CAAC;IACrB,CAAC;IAED,IAAI,QAAQ;QACV,OAAO,IAAI,CAAC,SAAS,CAAC;IACxB,CAAC;IAED;;OAEG;IACH,IAAI,aAAa;QACf,OAAO,CAAC,GAAG,IAAI,CAAC,QAAQ,CAAC,CAAC;IAC5B,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,SAAiB;QACrB,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;IAChC,CAAC;IAED;;OAEG;IACH,OAAO,CAAC,MAAiB,EAAE,EAAQ;QACjC,IAAI,CAAC,OAAO,GAAG,WAAW,CAAC;QAC3B,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC;QACtB,IAAI,CAAC,SAAS,GAAG,EAAE,CAAC;IACtB,CAAC;IAED;;;;;;;OAOG;IACH,IAAI,CAAC,KAAa,EAAE,KAAyB,EAAE,EAAQ;QACrD,IAAI,CAAC,OAAO,GAAG,QAAQ,CAAC;QACxB,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;QACpB,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC;QACpB,IAAI,CAAC,SAAS,GAAG,EAAE,CAAC;IACtB,CAAC;CACF"}

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

@@ -0,0 +1,24 @@
+import type { SimStatesSettledOutcome } from "./sim-states-state-outcome.js";
+/**
+ * Read the Amazon States Language error name off whatever was raised.
+ */
+export declare function simStatesFailureFrom(error: unknown): SimStatesSettledOutcome;
+/**
+ * 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 declare const simStatesMaximumTransitions = 25000;
+/**
+ * The failure an execution whose states form a cycle ends with.
+ */
+export declare function simStatesCycleFailure(): SimStatesSettledOutcome;
+/**
+ * The failure a transition naming no state ends the execution with.
+ */
+export declare function simStatesUnknownStateFailure(name: string): SimStatesSettledOutcome;
+//# sourceMappingURL=sim-states-failure.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-failure.d.ts","sourceRoot":"","sources":["../../../../src/service/stepfunctions/execution/sim-states-failure.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,+BAA+B,CAAC;AAE7E;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,GAAG,uBAAuB,CAc5E;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,2BAA2B,QAAS,CAAC;AAElD;;GAEG;AACH,wBAAgB,qBAAqB,IAAI,uBAAuB,CAQ/D;AAED;;GAEG;AACH,wBAAgB,4BAA4B,CAC1C,IAAI,EAAE,MAAM,GACX,uBAAuB,CAMzB"}

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