@kensio/yulin 1.19.4 → 1.20.1

package/dist/service/stepfunctions/error/sim-step-functions.error.d.ts

@@ -0,0 +1,158 @@
+/**
+ * Base class for simulated Step Functions errors.
+ *
+ * Every failure inside a state machine carries the name Amazon States Language
+ * gives it. That name is what a `Retry` or a `Catch` matches on, so it is held
+ * here rather than derived at the point one is evaluated.
+ */
+export declare class SimStepFunctionsError extends Error {
+    readonly statesErrorName: string;
+    constructor(message: string, statesErrorName: string);
+}
+/**
+ * A Reference Path this simulator cannot read.
+ *
+ * Real Step Functions rejects a malformed path when the state machine is
+ * created. It is raised here as well for a path outside the subset this reads,
+ * which is a narrower thing and worth telling apart in the message.
+ */
+export declare class SimStatesPathError extends SimStepFunctionsError {
+    readonly name = "SimStatesPathError";
+    constructor(message: string);
+}
+/**
+ * A path selecting nothing where the state needed a value.
+ *
+ * `InputPath`, `OutputPath` and a Payload Template field all fail this way when
+ * the document holds nothing at the path.
+ */
+export declare class SimStatesPathMatchFailure extends SimStepFunctionsError {
+    readonly name = "SimStatesPathMatchFailure";
+    constructor(message: string);
+}
+/**
+ * A `ResultPath` that cannot be written into the state input.
+ */
+export declare class SimStatesResultPathMatchFailure extends SimStepFunctionsError {
+    readonly name = "SimStatesResultPathMatchFailure";
+    constructor(message: string);
+}
+/**
+ * An intrinsic function that cannot be parsed, or that was called wrongly.
+ */
+export declare class SimStatesIntrinsicFailure extends SimStepFunctionsError {
+    readonly name = "SimStatesIntrinsicFailure";
+    constructor(message: string);
+}
+/**
+ * A `Choice` state none of whose rules matched, where it carries no `Default`.
+ */
+export declare class SimStatesNoChoiceMatched extends SimStepFunctionsError {
+    readonly name = "SimStatesNoChoiceMatched";
+    constructor(message: string);
+}
+/**
+ * A `Task` state that could not do its work.
+ *
+ * The task itself failed rather than the handler it reached: the function was
+ * not there, the execution role could not be assumed, or the role is not
+ * allowed to invoke it. Real Step Functions names each of these after the
+ * failure a task had, and this is the name a `Retry` or a `Catch` matches.
+ */
+export declare class SimStatesTaskFailure extends SimStepFunctionsError {
+    readonly name = "SimStatesTaskFailure";
+    constructor(message: string);
+}
+/**
+ * A handler that raised, reported under its own error type.
+ *
+ * A `Task` state whose `Resource` is a function ARN is talking to the function
+ * rather than to the Lambda API, and the error name it fails with is the one
+ * the handler raised. `NotEligible` thrown in a handler is `NotEligible` here.
+ *
+ * The error type the handler raised under is the states error name, so it is
+ * given where this is raised rather than fixed by the class.
+ */
+export declare class SimStatesTaskHandlerFailure extends SimStepFunctionsError {
+    readonly name = "SimStatesTaskHandlerFailure";
+}
+/**
+ * A state that could not run on the data it was given.
+ *
+ * A `Choice` rule comparing a field that is not there, or a `Wait` reading a
+ * duration from a path holding something else. Real Step Functions fails the
+ * execution with `States.Runtime` for both.
+ */
+export declare class SimStatesRuntimeFailure extends SimStepFunctionsError {
+    readonly name = "SimStatesRuntimeFailure";
+    constructor(message: string);
+}
+/**
+ * A state machine definition that Amazon States Language itself refuses.
+ *
+ * A malformed definition, a state type that does not exist, a transition to a
+ * state that is not there. Real Step Functions rejects each of these when the
+ * state machine is created, and so does this.
+ */
+export declare class SimStatesInvalidDefinition extends SimStepFunctionsError {
+    readonly name = "InvalidDefinition";
+    constructor(message: string);
+}
+/**
+ * An Amazon States Language construct this simulator does not run.
+ *
+ * Raised when a state machine is read rather than when a state runs. A
+ * definition using something unsimulated is refused whole, since a state
+ * machine missing one state runs wrong, and running wrong is worse than
+ * refusing.
+ */
+export declare class SimStatesUnsimulatedInput extends SimStepFunctionsError {
+    readonly name = "SimStatesUnsimulatedInput";
+    constructor(message: string);
+}
+/**
+ * A state machine an ARN names nothing for.
+ */
+export declare class SimStatesResourceNotFound extends SimStepFunctionsError {
+    readonly name = "StateMachineDoesNotExist";
+    constructor(message: string);
+}
+/**
+ * An execution an ARN names nothing for.
+ *
+ * Real Step Functions tells this apart from a missing state machine, and a
+ * caller branching on the error name needs the same two names.
+ */
+export declare class SimStatesExecutionNotFound extends SimStepFunctionsError {
+    readonly name = "ExecutionDoesNotExist";
+    constructor(message: string);
+}
+/**
+ * A name outside what Step Functions allows.
+ */
+export declare class SimStatesInvalidName extends SimStepFunctionsError {
+    readonly name = "InvalidName";
+    constructor(message: string);
+}
+/**
+ * A state machine of that name is already there.
+ */
+export declare class SimStateMachineAlreadyExists extends SimStepFunctionsError {
+    readonly name = "StateMachineAlreadyExists";
+    constructor(message: string);
+}
+/**
+ * An execution of that name has already been started.
+ */
+export declare class SimStatesExecutionAlreadyExists extends SimStepFunctionsError {
+    readonly name = "ExecutionAlreadyExists";
+    constructor(message: string);
+}
+/**
+ * A request whose own input is wrong, before anything is looked up.
+ */
+export declare class SimStatesInvalidRequest extends SimStepFunctionsError {
+    readonly name = "InvalidArn";
+    constructor(message: string);
+}
+//# sourceMappingURL=sim-step-functions.error.d.ts.map

package/dist/service/stepfunctions/error/sim-step-functions.error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-step-functions.error.d.ts","sourceRoot":"","sources":["../../../../src/service/stepfunctions/error/sim-step-functions.error.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,qBAAa,qBAAsB,SAAQ,KAAK;aAG5B,eAAe,EAAE,MAAM;IAFzC,YACE,OAAO,EAAE,MAAM,EACC,eAAe,EAAE,MAAM,EAGxC;CACF;AAED;;;;;;GAMG;AACH,qBAAa,kBAAmB,SAAQ,qBAAqB;IAC3D,SAAyB,IAAI,wBAAwB;IAErD,YAAY,OAAO,EAAE,MAAM,EAE1B;CACF;AAED;;;;;GAKG;AACH,qBAAa,yBAA0B,SAAQ,qBAAqB;IAClE,SAAyB,IAAI,+BAA+B;IAE5D,YAAY,OAAO,EAAE,MAAM,EAE1B;CACF;AAED;;GAEG;AACH,qBAAa,+BAAgC,SAAQ,qBAAqB;IACxE,SAAyB,IAAI,qCAAqC;IAElE,YAAY,OAAO,EAAE,MAAM,EAE1B;CACF;AAED;;GAEG;AACH,qBAAa,yBAA0B,SAAQ,qBAAqB;IAClE,SAAyB,IAAI,+BAA+B;IAE5D,YAAY,OAAO,EAAE,MAAM,EAE1B;CACF;AAED;;GAEG;AACH,qBAAa,wBAAyB,SAAQ,qBAAqB;IACjE,SAAyB,IAAI,8BAA8B;IAE3D,YAAY,OAAO,EAAE,MAAM,EAE1B;CACF;AAED;;;;;;;GAOG;AACH,qBAAa,oBAAqB,SAAQ,qBAAqB;IAC7D,SAAyB,IAAI,0BAA0B;IAEvD,YAAY,OAAO,EAAE,MAAM,EAE1B;CACF;AAED;;;;;;;;;GASG;AACH,qBAAa,2BAA4B,SAAQ,qBAAqB;IACpE,SAAyB,IAAI,iCAAiC;CAC/D;AAED;;;;;;GAMG;AACH,qBAAa,uBAAwB,SAAQ,qBAAqB;IAChE,SAAyB,IAAI,6BAA6B;IAE1D,YAAY,OAAO,EAAE,MAAM,EAE1B;CACF;AAED;;;;;;GAMG;AACH,qBAAa,0BAA2B,SAAQ,qBAAqB;IACnE,SAAyB,IAAI,uBAAuB;IAEpD,YAAY,OAAO,EAAE,MAAM,EAE1B;CACF;AAED;;;;;;;GAOG;AACH,qBAAa,yBAA0B,SAAQ,qBAAqB;IAClE,SAAyB,IAAI,+BAA+B;IAE5D,YAAY,OAAO,EAAE,MAAM,EAE1B;CACF;AAED;;GAEG;AACH,qBAAa,yBAA0B,SAAQ,qBAAqB;IAClE,SAAyB,IAAI,8BAA8B;IAE3D,YAAY,OAAO,EAAE,MAAM,EAE1B;CACF;AAED;;;;;GAKG;AACH,qBAAa,0BAA2B,SAAQ,qBAAqB;IACnE,SAAyB,IAAI,2BAA2B;IAExD,YAAY,OAAO,EAAE,MAAM,EAE1B;CACF;AAED;;GAEG;AACH,qBAAa,oBAAqB,SAAQ,qBAAqB;IAC7D,SAAyB,IAAI,iBAAiB;IAE9C,YAAY,OAAO,EAAE,MAAM,EAE1B;CACF;AAED;;GAEG;AACH,qBAAa,4BAA6B,SAAQ,qBAAqB;IACrE,SAAyB,IAAI,+BAA+B;IAE5D,YAAY,OAAO,EAAE,MAAM,EAE1B;CACF;AAED;;GAEG;AACH,qBAAa,+BAAgC,SAAQ,qBAAqB;IACxE,SAAyB,IAAI,4BAA4B;IAEzD,YAAY,OAAO,EAAE,MAAM,EAE1B;CACF;AAED;;GAEG;AACH,qBAAa,uBAAwB,SAAQ,qBAAqB;IAChE,SAAyB,IAAI,gBAAgB;IAE7C,YAAY,OAAO,EAAE,MAAM,EAE1B;CACF"}

package/dist/service/stepfunctions/error/sim-step-functions.error.js

@@ -0,0 +1,191 @@
+/**
+ * Base class for simulated Step Functions errors.
+ *
+ * Every failure inside a state machine carries the name Amazon States Language
+ * gives it. That name is what a `Retry` or a `Catch` matches on, so it is held
+ * here rather than derived at the point one is evaluated.
+ */
+export class SimStepFunctionsError extends Error {
+    statesErrorName;
+    constructor(message, statesErrorName) {
+        super(message);
+        this.statesErrorName = statesErrorName;
+    }
+}
+/**
+ * A Reference Path this simulator cannot read.
+ *
+ * Real Step Functions rejects a malformed path when the state machine is
+ * created. It is raised here as well for a path outside the subset this reads,
+ * which is a narrower thing and worth telling apart in the message.
+ */
+export class SimStatesPathError extends SimStepFunctionsError {
+    name = "SimStatesPathError";
+    constructor(message) {
+        super(message, "States.QueryEvaluationError");
+    }
+}
+/**
+ * A path selecting nothing where the state needed a value.
+ *
+ * `InputPath`, `OutputPath` and a Payload Template field all fail this way when
+ * the document holds nothing at the path.
+ */
+export class SimStatesPathMatchFailure extends SimStepFunctionsError {
+    name = "SimStatesPathMatchFailure";
+    constructor(message) {
+        super(message, "States.ParameterPathFailure");
+    }
+}
+/**
+ * A `ResultPath` that cannot be written into the state input.
+ */
+export class SimStatesResultPathMatchFailure extends SimStepFunctionsError {
+    name = "SimStatesResultPathMatchFailure";
+    constructor(message) {
+        super(message, "States.ResultPathMatchFailure");
+    }
+}
+/**
+ * An intrinsic function that cannot be parsed, or that was called wrongly.
+ */
+export class SimStatesIntrinsicFailure extends SimStepFunctionsError {
+    name = "SimStatesIntrinsicFailure";
+    constructor(message) {
+        super(message, "States.IntrinsicFailure");
+    }
+}
+/**
+ * A `Choice` state none of whose rules matched, where it carries no `Default`.
+ */
+export class SimStatesNoChoiceMatched extends SimStepFunctionsError {
+    name = "SimStatesNoChoiceMatched";
+    constructor(message) {
+        super(message, "States.NoChoiceMatched");
+    }
+}
+/**
+ * A `Task` state that could not do its work.
+ *
+ * The task itself failed rather than the handler it reached: the function was
+ * not there, the execution role could not be assumed, or the role is not
+ * allowed to invoke it. Real Step Functions names each of these after the
+ * failure a task had, and this is the name a `Retry` or a `Catch` matches.
+ */
+export class SimStatesTaskFailure extends SimStepFunctionsError {
+    name = "SimStatesTaskFailure";
+    constructor(message) {
+        super(message, "States.TaskFailed");
+    }
+}
+/**
+ * A handler that raised, reported under its own error type.
+ *
+ * A `Task` state whose `Resource` is a function ARN is talking to the function
+ * rather than to the Lambda API, and the error name it fails with is the one
+ * the handler raised. `NotEligible` thrown in a handler is `NotEligible` here.
+ *
+ * The error type the handler raised under is the states error name, so it is
+ * given where this is raised rather than fixed by the class.
+ */
+export class SimStatesTaskHandlerFailure extends SimStepFunctionsError {
+    name = "SimStatesTaskHandlerFailure";
+}
+/**
+ * A state that could not run on the data it was given.
+ *
+ * A `Choice` rule comparing a field that is not there, or a `Wait` reading a
+ * duration from a path holding something else. Real Step Functions fails the
+ * execution with `States.Runtime` for both.
+ */
+export class SimStatesRuntimeFailure extends SimStepFunctionsError {
+    name = "SimStatesRuntimeFailure";
+    constructor(message) {
+        super(message, "States.Runtime");
+    }
+}
+/**
+ * A state machine definition that Amazon States Language itself refuses.
+ *
+ * A malformed definition, a state type that does not exist, a transition to a
+ * state that is not there. Real Step Functions rejects each of these when the
+ * state machine is created, and so does this.
+ */
+export class SimStatesInvalidDefinition extends SimStepFunctionsError {
+    name = "InvalidDefinition";
+    constructor(message) {
+        super(message, "States.QueryEvaluationError");
+    }
+}
+/**
+ * An Amazon States Language construct this simulator does not run.
+ *
+ * Raised when a state machine is read rather than when a state runs. A
+ * definition using something unsimulated is refused whole, since a state
+ * machine missing one state runs wrong, and running wrong is worse than
+ * refusing.
+ */
+export class SimStatesUnsimulatedInput extends SimStepFunctionsError {
+    name = "SimStatesUnsimulatedInput";
+    constructor(message) {
+        super(message, "States.QueryEvaluationError");
+    }
+}
+/**
+ * A state machine an ARN names nothing for.
+ */
+export class SimStatesResourceNotFound extends SimStepFunctionsError {
+    name = "StateMachineDoesNotExist";
+    constructor(message) {
+        super(message, "States.Runtime");
+    }
+}
+/**
+ * An execution an ARN names nothing for.
+ *
+ * Real Step Functions tells this apart from a missing state machine, and a
+ * caller branching on the error name needs the same two names.
+ */
+export class SimStatesExecutionNotFound extends SimStepFunctionsError {
+    name = "ExecutionDoesNotExist";
+    constructor(message) {
+        super(message, "States.Runtime");
+    }
+}
+/**
+ * A name outside what Step Functions allows.
+ */
+export class SimStatesInvalidName extends SimStepFunctionsError {
+    name = "InvalidName";
+    constructor(message) {
+        super(message, "States.Runtime");
+    }
+}
+/**
+ * A state machine of that name is already there.
+ */
+export class SimStateMachineAlreadyExists extends SimStepFunctionsError {
+    name = "StateMachineAlreadyExists";
+    constructor(message) {
+        super(message, "States.Runtime");
+    }
+}
+/**
+ * An execution of that name has already been started.
+ */
+export class SimStatesExecutionAlreadyExists extends SimStepFunctionsError {
+    name = "ExecutionAlreadyExists";
+    constructor(message) {
+        super(message, "States.Runtime");
+    }
+}
+/**
+ * A request whose own input is wrong, before anything is looked up.
+ */
+export class SimStatesInvalidRequest extends SimStepFunctionsError {
+    name = "InvalidArn";
+    constructor(message) {
+        super(message, "States.Runtime");
+    }
+}
+//# sourceMappingURL=sim-step-functions.error.js.map

package/dist/service/stepfunctions/error/sim-step-functions.error.js.map

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

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

@@ -0,0 +1,33 @@
+import type { SimStatesExecution } from "./sim-states-execution.js";
+/**
+ * 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 declare class SimStatesExecutionStore {
+    #private;
+    add(execution: SimStatesExecution): void;
+    find(arn: string): SimStatesExecution | undefined;
+    /**
+     * Every execution of one state machine, most recently started first.
+     */
+    forStateMachine(stateMachineArn: string): readonly SimStatesExecution[];
+    /**
+     * 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: string, name: string): SimStatesExecution | undefined;
+    /**
+     * Whether one state machine already has an execution of this name.
+     */
+    hasName(stateMachineArn: string, name: string): boolean;
+    /**
+     * Forget every execution of one state machine.
+     */
+    removeForStateMachine(stateMachineArn: string): void;
+}
+//# sourceMappingURL=sim-states-execution-store.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-execution-store.d.ts","sourceRoot":"","sources":["../../../../src/service/stepfunctions/execution/sim-states-execution-store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AAEpE;;;;;;GAMG;AACH,qBAAa,uBAAuB;;IAGlC,GAAG,CAAC,SAAS,EAAE,kBAAkB,GAAG,IAAI,CAEvC;IAED,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,kBAAkB,GAAG,SAAS,CAEhD;IAED;;OAEG;IACH,eAAe,CAAC,eAAe,EAAE,MAAM,GAAG,SAAS,kBAAkB,EAAE,CAMtE;IAED;;;;;OAKG;IACH,UAAU,CACR,eAAe,EAAE,MAAM,EACvB,IAAI,EAAE,MAAM,GACX,kBAAkB,GAAG,SAAS,CAQhC;IAED;;OAEG;IACH,OAAO,CAAC,eAAe,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAEtD;IAED;;OAEG;IACH,qBAAqB,CAAC,eAAe,EAAE,MAAM,GAAG,IAAI,CAMnD;CACF"}

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