@kensio/yulin 1.20.0 → 1.20.2

package/dist/service/stepfunctions/choice/sim-states-comparison-families.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-comparison-families.d.ts","sourceRoot":"","sources":["../../../../src/service/stepfunctions/choice/sim-states-comparison-families.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AAClE,OAAO,EACL,mBAAmB,EACnB,KAAK,oBAAoB,EAC1B,MAAM,4BAA4B,CAAC;AAEpC;;GAEG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,SAAS,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAM3E;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,SAAS,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAM3E;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAClC,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,oBAAoB,EACjC,IAAI,EAAE,CAAC,KAAK,EAAE,SAAS,GAAG,SAAS,KAAK,CAAC,GAAG,SAAS,GACpD,mBAAmB,EAAE,CA6BvB;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CACtB,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,CAAC,QAAQ,EAAE,SAAS,GAAG,SAAS,KAAK,OAAO,GACtD,mBAAmB,CAQrB"}

package/dist/service/stepfunctions/choice/sim-states-comparison-families.js

@@ -0,0 +1,65 @@
+import { SimStatesComparison, } from "./sim-states-comparison.js";
+/**
+ * Read a JSON value as a string, or as nothing where it is not one.
+ */
+export function readString(value) {
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    return value;
+}
+/**
+ * Read a JSON value as a number, or as nothing where it is not one.
+ */
+export function readNumber(value) {
+    if (typeof value !== "number") {
+        return undefined;
+    }
+    return value;
+}
+/**
+ * The five ordering comparators over one JSON type.
+ *
+ * A value of the wrong type on either side answers false rather than failing.
+ * `StringEquals` against a number is a comparison that does not hold, and a
+ * rule the input does not match is the ordinary case in a `Choice` state.
+ */
+export function orderedComparisons(prefix, operandType, read) {
+    const comparison = (suffix, holds) => new SimStatesComparison({
+        name: `${prefix}${suffix}`,
+        operandType,
+        needsValue: true,
+        operandIsPath: false,
+        holds: (variable, operand) => {
+            const left = read(variable);
+            const right = read(operand);
+            if (left === undefined || right === undefined) {
+                return false;
+            }
+            return holds(left, right);
+        },
+    });
+    return [
+        comparison("Equals", (left, right) => left === right),
+        comparison("LessThan", (left, right) => left < right),
+        comparison("GreaterThan", (left, right) => left > right),
+        comparison("LessThanEquals", (left, right) => left <= right),
+        comparison("GreaterThanEquals", (left, right) => left >= right),
+    ];
+}
+/**
+ * One data-test comparator, such as `IsString`.
+ *
+ * These are the comparators that answer for a `Variable` selecting nothing,
+ * which is what makes `IsPresent` usable as the first test in an `And`.
+ */
+export function dataTest(name, describes) {
+    return new SimStatesComparison({
+        name,
+        operandType: "boolean",
+        needsValue: false,
+        operandIsPath: false,
+        holds: (variable, operand) => describes(variable) === operand,
+    });
+}
+//# sourceMappingURL=sim-states-comparison-families.js.map

package/dist/service/stepfunctions/choice/sim-states-comparison-families.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-comparison-families.js","sourceRoot":"","sources":["../../../../src/service/stepfunctions/choice/sim-states-comparison-families.ts"],"names":[],"mappings":"AACA,OAAO,EACL,mBAAmB,GAEpB,MAAM,4BAA4B,CAAC;AAEpC;;GAEG;AACH,MAAM,UAAU,UAAU,CAAC,KAA4B;IACrD,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;QAC9B,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,UAAU,CAAC,KAA4B;IACrD,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;QAC9B,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,kBAAkB,CAChC,MAAc,EACd,WAAiC,EACjC,IAAqD;IAErD,MAAM,UAAU,GAAG,CACjB,MAAc,EACd,KAAqC,EAChB,EAAE,CACvB,IAAI,mBAAmB,CAAC;QACtB,IAAI,EAAE,GAAG,MAAM,GAAG,MAAM,EAAE;QAC1B,WAAW;QACX,UAAU,EAAE,IAAI;QAChB,aAAa,EAAE,KAAK;QACpB,KAAK,EAAE,CAAC,QAAQ,EAAE,OAAO,EAAW,EAAE;YACpC,MAAM,IAAI,GAAG,IAAI,CAAC,QAAQ,CAAC,CAAC;YAC5B,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC;YAE5B,IAAI,IAAI,KAAK,SAAS,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;gBAC9C,OAAO,KAAK,CAAC;YACf,CAAC;YAED,OAAO,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;QAC5B,CAAC;KACF,CAAC,CAAC;IAEL,OAAO;QACL,UAAU,CAAC,QAAQ,EAAE,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC,IAAI,KAAK,KAAK,CAAC;QACrD,UAAU,CAAC,UAAU,EAAE,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC,IAAI,GAAG,KAAK,CAAC;QACrD,UAAU,CAAC,aAAa,EAAE,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC,IAAI,GAAG,KAAK,CAAC;QACxD,UAAU,CAAC,gBAAgB,EAAE,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC,IAAI,IAAI,KAAK,CAAC;QAC5D,UAAU,CAAC,mBAAmB,EAAE,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC,IAAI,IAAI,KAAK,CAAC;KAChE,CAAC;AACJ,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,QAAQ,CACtB,IAAY,EACZ,SAAuD;IAEvD,OAAO,IAAI,mBAAmB,CAAC;QAC7B,IAAI;QACJ,WAAW,EAAE,SAAS;QACtB,UAAU,EAAE,KAAK;QACjB,aAAa,EAAE,KAAK;QACpB,KAAK,EAAE,CAAC,QAAQ,EAAE,OAAO,EAAW,EAAE,CAAC,SAAS,CAAC,QAAQ,CAAC,KAAK,OAAO;KACvE,CAAC,CAAC;AACL,CAAC"}

package/dist/service/stepfunctions/choice/sim-states-comparison-parse.d.ts

@@ -0,0 +1,15 @@
+import type { JSONValue } from "../../../util/type-guard/json.js";
+import { type SimStatesChoiceTest } from "./sim-states-choice-test.js";
+import type { SimStatesComparison } from "./sim-states-comparison.js";
+interface SimStatesComparisonTestProperties {
+    readonly stateName: string;
+    readonly record: Record<string, JSONValue>;
+    readonly comparison: SimStatesComparison;
+    readonly written: JSONValue;
+}
+/**
+ * Read a comparison of the value at a `Variable` path against an operand.
+ */
+export declare function parseSimStatesComparisonTest(properties: SimStatesComparisonTestProperties): SimStatesChoiceTest;
+export {};
+//# sourceMappingURL=sim-states-comparison-parse.d.ts.map

package/dist/service/stepfunctions/choice/sim-states-comparison-parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-comparison-parse.d.ts","sourceRoot":"","sources":["../../../../src/service/stepfunctions/choice/sim-states-comparison-parse.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AAQlE,OAAO,EACL,KAAK,mBAAmB,EAEzB,MAAM,6BAA6B,CAAC;AACrC,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAEtE,UAAU,iCAAiC;IACzC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAAC;IAC3C,QAAQ,CAAC,UAAU,EAAE,mBAAmB,CAAC;IACzC,QAAQ,CAAC,OAAO,EAAE,SAAS,CAAC;CAC7B;AAED;;GAEG;AACH,wBAAgB,4BAA4B,CAC1C,UAAU,EAAE,iCAAiC,GAC5C,mBAAmB,CAmBrB"}

package/dist/service/stepfunctions/choice/sim-states-comparison-parse.js

@@ -0,0 +1,43 @@
+import { parseSimStatesReferencePath } from "../data/sim-states-reference-path.js";
+import { SimStatesInvalidDefinition } from "../error/sim-step-functions.error.js";
+import { SimStatesLiteralOperand, SimStatesPathOperand, } from "./sim-states-choice-operand.js";
+import { SimStatesVariableTest, } from "./sim-states-choice-test.js";
+/**
+ * Read a comparison of the value at a `Variable` path against an operand.
+ */
+export function parseSimStatesComparisonTest(properties) {
+    const { stateName, record, comparison, written } = properties;
+    const variable = record["Variable"];
+    if (typeof variable !== "string") {
+        throw new SimStatesInvalidDefinition(`A ${comparison.name} rule in the Choice state ${stateName} has no ` +
+            "Variable naming the value to compare.");
+    }
+    checkOperandType(stateName, comparison, written);
+    return new SimStatesVariableTest({
+        path: variable,
+        segments: parseSimStatesReferencePath(variable),
+        comparison,
+        operand: readOperand(comparison, written),
+    });
+}
+/**
+ * Read a comparator's operand, either as written or as a path to read it from.
+ */
+function readOperand(comparison, written) {
+    if (typeof written === "string" && comparison.operandIsPath) {
+        return new SimStatesPathOperand(written, parseSimStatesReferencePath(written));
+    }
+    return new SimStatesLiteralOperand(written);
+}
+/**
+ * Check that a comparator's operand is the kind of value it compares.
+ */
+function checkOperandType(stateName, comparison, written) {
+    if (typeof written === comparison.operandType) {
+        return;
+    }
+    throw new SimStatesInvalidDefinition(`A ${comparison.name} rule in the Choice state ${stateName} compares ` +
+        `against ${JSON.stringify(written)}, and ${comparison.name} takes a ` +
+        `${comparison.operandType}.`);
+}
+//# sourceMappingURL=sim-states-comparison-parse.js.map

package/dist/service/stepfunctions/choice/sim-states-comparison-parse.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-comparison-parse.js","sourceRoot":"","sources":["../../../../src/service/stepfunctions/choice/sim-states-comparison-parse.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,2BAA2B,EAAE,MAAM,sCAAsC,CAAC;AACnF,OAAO,EAAE,0BAA0B,EAAE,MAAM,sCAAsC,CAAC;AAClF,OAAO,EAEL,uBAAuB,EACvB,oBAAoB,GACrB,MAAM,gCAAgC,CAAC;AACxC,OAAO,EAEL,qBAAqB,GACtB,MAAM,6BAA6B,CAAC;AAUrC;;GAEG;AACH,MAAM,UAAU,4BAA4B,CAC1C,UAA6C;IAE7C,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,OAAO,EAAE,GAAG,UAAU,CAAC;IAC9D,MAAM,QAAQ,GAAG,MAAM,CAAC,UAAU,CAAC,CAAC;IAEpC,IAAI,OAAO,QAAQ,KAAK,QAAQ,EAAE,CAAC;QACjC,MAAM,IAAI,0BAA0B,CAClC,KAAK,UAAU,CAAC,IAAI,6BAA6B,SAAS,UAAU;YAClE,uCAAuC,CAC1C,CAAC;IACJ,CAAC;IAED,gBAAgB,CAAC,SAAS,EAAE,UAAU,EAAE,OAAO,CAAC,CAAC;IAEjD,OAAO,IAAI,qBAAqB,CAAC;QAC/B,IAAI,EAAE,QAAQ;QACd,QAAQ,EAAE,2BAA2B,CAAC,QAAQ,CAAC;QAC/C,UAAU;QACV,OAAO,EAAE,WAAW,CAAC,UAAU,EAAE,OAAO,CAAC;KAC1C,CAAC,CAAC;AACL,CAAC;AAED;;GAEG;AACH,SAAS,WAAW,CAClB,UAA+B,EAC/B,OAAkB;IAElB,IAAI,OAAO,OAAO,KAAK,QAAQ,IAAI,UAAU,CAAC,aAAa,EAAE,CAAC;QAC5D,OAAO,IAAI,oBAAoB,CAC7B,OAAO,EACP,2BAA2B,CAAC,OAAO,CAAC,CACrC,CAAC;IACJ,CAAC;IAED,OAAO,IAAI,uBAAuB,CAAC,OAAO,CAAC,CAAC;AAC9C,CAAC;AAED;;GAEG;AACH,SAAS,gBAAgB,CACvB,SAAiB,EACjB,UAA+B,EAC/B,OAAkB;IAElB,IAAI,OAAO,OAAO,KAAK,UAAU,CAAC,WAAW,EAAE,CAAC;QAC9C,OAAO;IACT,CAAC;IAED,MAAM,IAAI,0BAA0B,CAClC,KAAK,UAAU,CAAC,IAAI,6BAA6B,SAAS,YAAY;QACpE,WAAW,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,SAAS,UAAU,CAAC,IAAI,WAAW;QACrE,GAAG,UAAU,CAAC,WAAW,GAAG,CAC/B,CAAC;AACJ,CAAC"}

package/dist/service/stepfunctions/choice/sim-states-comparison.d.ts

@@ -0,0 +1,49 @@
+import type { JSONValue } from "../../../util/type-guard/json.js";
+/**
+ * What the definition writes as a comparator's operand.
+ */
+export type SimStatesOperandType = "string" | "number" | "boolean";
+interface SimStatesComparisonProperties {
+    readonly name: string;
+    readonly operandType: SimStatesOperandType;
+    readonly needsValue: boolean;
+    readonly operandIsPath: boolean;
+    readonly holds: SimStatesComparisonHolds;
+}
+export type SimStatesComparisonHolds = (variable: JSONValue | undefined, operand: JSONValue) => boolean;
+/**
+ * One `Choice` comparator, such as `NumericGreaterThan`.
+ *
+ * A comparator knows what its operand has to be, so a definition writing the
+ * wrong kind is refused when the state machine is created rather than
+ * answering false at every rule it appears in.
+ */
+export declare class SimStatesComparison {
+    #private;
+    readonly name: string;
+    readonly operandType: SimStatesOperandType;
+    /**
+     * Whether the rule's `Variable` has to select something.
+     *
+     * The data-test comparators, `IsPresent` and its siblings, are the ones that
+     * answer for a field that is not there. Every other comparator fails the
+     * execution instead, as real Step Functions does.
+     */
+    readonly needsValue: boolean;
+    /** Whether the operand is a Reference Path into the state's input. */
+    readonly operandIsPath: boolean;
+    constructor(properties: SimStatesComparisonProperties);
+    /**
+     * Whether the value at the rule's `Variable` compares as the rule asks.
+     */
+    holds(variable: JSONValue | undefined, operand: JSONValue): boolean;
+    /**
+     * The same comparator with its operand read from the state's input.
+     *
+     * Every comparator taking an operand has a `Path` twin, which compares two
+     * places in the same document instead of a place and a literal.
+     */
+    readingItsOperandFromAPath(): SimStatesComparison;
+}
+export {};
+//# sourceMappingURL=sim-states-comparison.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-comparison.d.ts","sourceRoot":"","sources":["../../../../src/service/stepfunctions/choice/sim-states-comparison.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AAElE;;GAEG;AACH,MAAM,MAAM,oBAAoB,GAAG,QAAQ,GAAG,QAAQ,GAAG,SAAS,CAAC;AAEnE,UAAU,6BAA6B;IACrC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,WAAW,EAAE,oBAAoB,CAAC;IAC3C,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAC7B,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC;IAChC,QAAQ,CAAC,KAAK,EAAE,wBAAwB,CAAC;CAC1C;AAED,MAAM,MAAM,wBAAwB,GAAG,CACrC,QAAQ,EAAE,SAAS,GAAG,SAAS,EAC/B,OAAO,EAAE,SAAS,KACf,OAAO,CAAC;AAEb;;;;;;GAMG;AACH,qBAAa,mBAAmB;;IAC9B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,WAAW,EAAE,oBAAoB,CAAC;IAC3C;;;;;;OAMG;IACH,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAC7B,sEAAsE;IACtE,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC;IAIhC,YAAY,UAAU,EAAE,6BAA6B,EAMpD;IAED;;OAEG;IACH,KAAK,CAAC,QAAQ,EAAE,SAAS,GAAG,SAAS,EAAE,OAAO,EAAE,SAAS,GAAG,OAAO,CAElE;IAED;;;;;OAKG;IACH,0BAA0B,IAAI,mBAAmB,CAQhD;CACF"}

package/dist/service/stepfunctions/choice/sim-states-comparison.js

@@ -0,0 +1,51 @@
+/**
+ * One `Choice` comparator, such as `NumericGreaterThan`.
+ *
+ * A comparator knows what its operand has to be, so a definition writing the
+ * wrong kind is refused when the state machine is created rather than
+ * answering false at every rule it appears in.
+ */
+export class SimStatesComparison {
+    name;
+    operandType;
+    /**
+     * Whether the rule's `Variable` has to select something.
+     *
+     * The data-test comparators, `IsPresent` and its siblings, are the ones that
+     * answer for a field that is not there. Every other comparator fails the
+     * execution instead, as real Step Functions does.
+     */
+    needsValue;
+    /** Whether the operand is a Reference Path into the state's input. */
+    operandIsPath;
+    #holds;
+    constructor(properties) {
+        this.name = properties.name;
+        this.operandType = properties.operandType;
+        this.needsValue = properties.needsValue;
+        this.operandIsPath = properties.operandIsPath;
+        this.#holds = properties.holds;
+    }
+    /**
+     * Whether the value at the rule's `Variable` compares as the rule asks.
+     */
+    holds(variable, operand) {
+        return this.#holds(variable, operand);
+    }
+    /**
+     * The same comparator with its operand read from the state's input.
+     *
+     * Every comparator taking an operand has a `Path` twin, which compares two
+     * places in the same document instead of a place and a literal.
+     */
+    readingItsOperandFromAPath() {
+        return new SimStatesComparison({
+            name: `${this.name}Path`,
+            operandType: "string",
+            needsValue: this.needsValue,
+            operandIsPath: true,
+            holds: this.#holds,
+        });
+    }
+}
+//# sourceMappingURL=sim-states-comparison.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-comparison.js","sourceRoot":"","sources":["../../../../src/service/stepfunctions/choice/sim-states-comparison.ts"],"names":[],"mappings":"AAoBA;;;;;;GAMG;AACH,MAAM,OAAO,mBAAmB;IACrB,IAAI,CAAS;IACb,WAAW,CAAuB;IAC3C;;;;;;OAMG;IACM,UAAU,CAAU;IAC7B,sEAAsE;IAC7D,aAAa,CAAU;IAEvB,MAAM,CAA2B;IAE1C,YAAY,UAAyC;QACnD,IAAI,CAAC,IAAI,GAAG,UAAU,CAAC,IAAI,CAAC;QAC5B,IAAI,CAAC,WAAW,GAAG,UAAU,CAAC,WAAW,CAAC;QAC1C,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC,UAAU,CAAC;QACxC,IAAI,CAAC,aAAa,GAAG,UAAU,CAAC,aAAa,CAAC;QAC9C,IAAI,CAAC,MAAM,GAAG,UAAU,CAAC,KAAK,CAAC;IACjC,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,QAA+B,EAAE,OAAkB;QACvD,OAAO,IAAI,CAAC,MAAM,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;IACxC,CAAC;IAED;;;;;OAKG;IACH,0BAA0B;QACxB,OAAO,IAAI,mBAAmB,CAAC;YAC7B,IAAI,EAAE,GAAG,IAAI,CAAC,IAAI,MAAM;YACxB,WAAW,EAAE,QAAQ;YACrB,UAAU,EAAE,IAAI,CAAC,UAAU;YAC3B,aAAa,EAAE,IAAI;YACnB,KAAK,EAAE,IAAI,CAAC,MAAM;SACnB,CAAC,CAAC;IACL,CAAC;CACF"}

package/dist/service/stepfunctions/choice/sim-states-comparisons.d.ts

@@ -0,0 +1,6 @@
+import { SimStatesComparison } from "./sim-states-comparison.js";
+/**
+ * The comparator of a name, or nothing where no comparator has it.
+ */
+export declare function findSimStatesComparison(name: string): SimStatesComparison | undefined;
+//# sourceMappingURL=sim-states-comparisons.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-comparisons.d.ts","sourceRoot":"","sources":["../../../../src/service/stepfunctions/choice/sim-states-comparisons.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AA2EjE;;GAEG;AACH,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,MAAM,GACX,mBAAmB,GAAG,SAAS,CAEjC"}

package/dist/service/stepfunctions/choice/sim-states-comparisons.js

@@ -0,0 +1,64 @@
+import { readSimStatesTimestamp } from "../data/sim-states-timestamp.js";
+import { SimStatesComparison } from "./sim-states-comparison.js";
+import { dataTest, orderedComparisons, readNumber, readString, } from "./sim-states-comparison-families.js";
+import { simStatesGlobMatches } from "./sim-states-glob.js";
+/**
+ * `StringMatches`, which is the one comparator taking a wildcard pattern.
+ *
+ * Amazon States Language gives it no `Path` twin, so neither does this.
+ */
+const stringMatches = new SimStatesComparison({
+    name: "StringMatches",
+    operandType: "string",
+    needsValue: true,
+    operandIsPath: false,
+    holds: (variable, operand) => {
+        const value = readString(variable);
+        const pattern = readString(operand);
+        if (value === undefined || pattern === undefined) {
+            return false;
+        }
+        return simStatesGlobMatches(pattern, value);
+    },
+});
+const booleanEquals = new SimStatesComparison({
+    name: "BooleanEquals",
+    operandType: "boolean",
+    needsValue: true,
+    operandIsPath: false,
+    holds: (variable, operand) => typeof variable === "boolean" && variable === operand,
+});
+/**
+ * Every comparator a `Choice` rule can be written with.
+ *
+ * Each comparator taking an operand has a `Path` twin reading that operand
+ * from the state's input. The data tests take a boolean the definition writes
+ * out, and have none.
+ */
+function allComparisons() {
+    const compared = [
+        ...orderedComparisons("String", "string", readString),
+        ...orderedComparisons("Numeric", "number", readNumber),
+        ...orderedComparisons("Timestamp", "string", readSimStatesTimestamp),
+        booleanEquals,
+    ];
+    return [
+        ...compared,
+        ...compared.map((comparison) => comparison.readingItsOperandFromAPath()),
+        stringMatches,
+        dataTest("IsPresent", (variable) => variable !== undefined),
+        dataTest("IsNull", (variable) => variable === null),
+        dataTest("IsBoolean", (variable) => typeof variable === "boolean"),
+        dataTest("IsNumeric", (variable) => typeof variable === "number"),
+        dataTest("IsString", (variable) => typeof variable === "string"),
+        dataTest("IsTimestamp", (variable) => readSimStatesTimestamp(variable) !== undefined),
+    ];
+}
+const comparisons = new Map(allComparisons().map((comparison) => [comparison.name, comparison]));
+/**
+ * The comparator of a name, or nothing where no comparator has it.
+ */
+export function findSimStatesComparison(name) {
+    return comparisons.get(name);
+}
+//# sourceMappingURL=sim-states-comparisons.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-comparisons.js","sourceRoot":"","sources":["../../../../src/service/stepfunctions/choice/sim-states-comparisons.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,iCAAiC,CAAC;AACzE,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AACjE,OAAO,EACL,QAAQ,EACR,kBAAkB,EAClB,UAAU,EACV,UAAU,GACX,MAAM,qCAAqC,CAAC;AAC7C,OAAO,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAE5D;;;;GAIG;AACH,MAAM,aAAa,GAAG,IAAI,mBAAmB,CAAC;IAC5C,IAAI,EAAE,eAAe;IACrB,WAAW,EAAE,QAAQ;IACrB,UAAU,EAAE,IAAI;IAChB,aAAa,EAAE,KAAK;IACpB,KAAK,EAAE,CAAC,QAAQ,EAAE,OAAO,EAAW,EAAE;QACpC,MAAM,KAAK,GAAG,UAAU,CAAC,QAAQ,CAAC,CAAC;QACnC,MAAM,OAAO,GAAG,UAAU,CAAC,OAAO,CAAC,CAAC;QAEpC,IAAI,KAAK,KAAK,SAAS,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;YACjD,OAAO,KAAK,CAAC;QACf,CAAC;QAED,OAAO,oBAAoB,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;IAC9C,CAAC;CACF,CAAC,CAAC;AAEH,MAAM,aAAa,GAAG,IAAI,mBAAmB,CAAC;IAC5C,IAAI,EAAE,eAAe;IACrB,WAAW,EAAE,SAAS;IACtB,UAAU,EAAE,IAAI;IAChB,aAAa,EAAE,KAAK;IACpB,KAAK,EAAE,CAAC,QAAQ,EAAE,OAAO,EAAW,EAAE,CACpC,OAAO,QAAQ,KAAK,SAAS,IAAI,QAAQ,KAAK,OAAO;CACxD,CAAC,CAAC;AAEH;;;;;;GAMG;AACH,SAAS,cAAc;IACrB,MAAM,QAAQ,GAAG;QACf,GAAG,kBAAkB,CAAC,QAAQ,EAAE,QAAQ,EAAE,UAAU,CAAC;QACrD,GAAG,kBAAkB,CAAC,SAAS,EAAE,QAAQ,EAAE,UAAU,CAAC;QACtD,GAAG,kBAAkB,CAAC,WAAW,EAAE,QAAQ,EAAE,sBAAsB,CAAC;QACpE,aAAa;KACd,CAAC;IAEF,OAAO;QACL,GAAG,QAAQ;QACX,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC,UAAU,EAAE,EAAE,CAAC,UAAU,CAAC,0BAA0B,EAAE,CAAC;QACxE,aAAa;QACb,QAAQ,CAAC,WAAW,EAAE,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,KAAK,SAAS,CAAC;QAC3D,QAAQ,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,KAAK,IAAI,CAAC;QACnD,QAAQ,CAAC,WAAW,EAAE,CAAC,QAAQ,EAAE,EAAE,CAAC,OAAO,QAAQ,KAAK,SAAS,CAAC;QAClE,QAAQ,CAAC,WAAW,EAAE,CAAC,QAAQ,EAAE,EAAE,CAAC,OAAO,QAAQ,KAAK,QAAQ,CAAC;QACjE,QAAQ,CAAC,UAAU,EAAE,CAAC,QAAQ,EAAE,EAAE,CAAC,OAAO,QAAQ,KAAK,QAAQ,CAAC;QAChE,QAAQ,CACN,aAAa,EACb,CAAC,QAAQ,EAAE,EAAE,CAAC,sBAAsB,CAAC,QAAQ,CAAC,KAAK,SAAS,CAC7D;KACF,CAAC;AACJ,CAAC;AAED,MAAM,WAAW,GAAG,IAAI,GAAG,CACzB,cAAc,EAAE,CAAC,GAAG,CAAC,CAAC,UAAU,EAAE,EAAE,CAAC,CAAC,UAAU,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC,CACpE,CAAC;AAEF;;GAEG;AACH,MAAM,UAAU,uBAAuB,CACrC,IAAY;IAEZ,OAAO,WAAW,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;AAC/B,CAAC"}

package/dist/service/stepfunctions/choice/sim-states-glob.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Whether a string matches a `StringMatches` pattern.
+ *
+ * The pattern language is the one Amazon States Language defines for
+ * `StringMatches`. `*` stands for any run of characters, and a backslash
+ * escapes the character after it, so `\*` is a literal asterisk and `\\` a
+ * literal backslash.
+ *
+ * The match is done by walking both strings. A pattern comes out of a state
+ * machine definition, and turning one into a regular expression would put the
+ * definition's author in charge of how long the match takes.
+ */
+export declare function simStatesGlobMatches(pattern: string, value: string): boolean;
+//# sourceMappingURL=sim-states-glob.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-glob.d.ts","sourceRoot":"","sources":["../../../../src/service/stepfunctions/choice/sim-states-glob.ts"],"names":[],"mappings":"AASA;;;;;;;;;;;GAWG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAE5E"}

package/dist/service/stepfunctions/choice/sim-states-glob.js

@@ -0,0 +1,73 @@
+const wildcard = { wildcard: true };
+/**
+ * Whether a string matches a `StringMatches` pattern.
+ *
+ * The pattern language is the one Amazon States Language defines for
+ * `StringMatches`. `*` stands for any run of characters, and a backslash
+ * escapes the character after it, so `\*` is a literal asterisk and `\\` a
+ * literal backslash.
+ *
+ * The match is done by walking both strings. A pattern comes out of a state
+ * machine definition, and turning one into a regular expression would put the
+ * definition's author in charge of how long the match takes.
+ */
+export function simStatesGlobMatches(pattern, value) {
+    return matchTokens(readGlobTokens(pattern), value);
+}
+/**
+ * Split a pattern into the steps it is made of, resolving its escapes.
+ */
+function readGlobTokens(pattern) {
+    const tokens = [];
+    for (let index = 0; index < pattern.length; index++) {
+        const character = pattern.charAt(index);
+        if (character === "\\" && index + 1 < pattern.length) {
+            index += 1;
+            tokens.push({ char: pattern.charAt(index) });
+            continue;
+        }
+        if (character === "*") {
+            tokens.push(wildcard);
+            continue;
+        }
+        // A trailing backslash escapes nothing and stands for itself.
+        tokens.push({ char: character });
+    }
+    return tokens;
+}
+/**
+ * Match the tokens against a value, backtracking to the last wildcard.
+ *
+ * Each wildcard remembers where it started matching. Where the rest of the
+ * pattern then fails, that wildcard takes one more character and the match
+ * carries on from there, which is the whole of the backtracking this pattern
+ * language needs.
+ */
+function matchTokens(tokens, value) {
+    let token = 0;
+    let character = 0;
+    let lastWildcard = -1;
+    let resumeAt = 0;
+    while (character < value.length) {
+        const current = tokens.at(token);
+        if (current !== undefined && "wildcard" in current) {
+            lastWildcard = token;
+            resumeAt = character;
+            token += 1;
+            continue;
+        }
+        if (current !== undefined && current.char === value.charAt(character)) {
+            token += 1;
+            character += 1;
+            continue;
+        }
+        if (lastWildcard === -1) {
+            return false;
+        }
+        token = lastWildcard + 1;
+        resumeAt += 1;
+        character = resumeAt;
+    }
+    return tokens.slice(token).every((rest) => "wildcard" in rest);
+}
+//# sourceMappingURL=sim-states-glob.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-glob.js","sourceRoot":"","sources":["../../../../src/service/stepfunctions/choice/sim-states-glob.ts"],"names":[],"mappings":"AAOA,MAAM,QAAQ,GAAuB,EAAE,QAAQ,EAAE,IAAI,EAAE,CAAC;AAExD;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,oBAAoB,CAAC,OAAe,EAAE,KAAa;IACjE,OAAO,WAAW,CAAC,cAAc,CAAC,OAAO,CAAC,EAAE,KAAK,CAAC,CAAC;AACrD,CAAC;AAED;;GAEG;AACH,SAAS,cAAc,CAAC,OAAe;IACrC,MAAM,MAAM,GAAyB,EAAE,CAAC;IAExC,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,OAAO,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,CAAC;QACpD,MAAM,SAAS,GAAG,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QAExC,IAAI,SAAS,KAAK,IAAI,IAAI,KAAK,GAAG,CAAC,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;YACrD,KAAK,IAAI,CAAC,CAAC;YACX,MAAM,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;YAC7C,SAAS;QACX,CAAC;QAED,IAAI,SAAS,KAAK,GAAG,EAAE,CAAC;YACtB,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;YACtB,SAAS;QACX,CAAC;QAED,8DAA8D;QAC9D,MAAM,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,CAAC,CAAC;IACnC,CAAC;IAED,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;;;;;;GAOG;AACH,SAAS,WAAW,CAClB,MAAqC,EACrC,KAAa;IAEb,IAAI,KAAK,GAAG,CAAC,CAAC;IACd,IAAI,SAAS,GAAG,CAAC,CAAC;IAClB,IAAI,YAAY,GAAG,CAAC,CAAC,CAAC;IACtB,IAAI,QAAQ,GAAG,CAAC,CAAC;IAEjB,OAAO,SAAS,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC;QAChC,MAAM,OAAO,GAAG,MAAM,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC;QAEjC,IAAI,OAAO,KAAK,SAAS,IAAI,UAAU,IAAI,OAAO,EAAE,CAAC;YACnD,YAAY,GAAG,KAAK,CAAC;YACrB,QAAQ,GAAG,SAAS,CAAC;YACrB,KAAK,IAAI,CAAC,CAAC;YACX,SAAS;QACX,CAAC;QAED,IAAI,OAAO,KAAK,SAAS,IAAI,OAAO,CAAC,IAAI,KAAK,KAAK,CAAC,MAAM,CAAC,SAAS,CAAC,EAAE,CAAC;YACtE,KAAK,IAAI,CAAC,CAAC;YACX,SAAS,IAAI,CAAC,CAAC;YACf,SAAS;QACX,CAAC;QAED,IAAI,YAAY,KAAK,CAAC,CAAC,EAAE,CAAC;YACxB,OAAO,KAAK,CAAC;QACf,CAAC;QAED,KAAK,GAAG,YAAY,GAAG,CAAC,CAAC;QACzB,QAAQ,IAAI,CAAC,CAAC;QACd,SAAS,GAAG,QAAQ,CAAC;IACvB,CAAC;IAED,OAAO,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,UAAU,IAAI,IAAI,CAAC,CAAC;AACjE,CAAC"}

package/dist/service/stepfunctions/command/execution/execution.command.d.ts

@@ -0,0 +1,32 @@
+import type { SimStatesExecutionStatus } from "../../execution/sim-states-execution.js";
+export interface SimStartExecutionCommandInput {
+    readonly stateMachineArn?: string;
+    readonly name?: string;
+    readonly input?: string;
+}
+export interface SimStartExecutionCommand {
+    readonly input: SimStartExecutionCommandInput;
+}
+export interface SimStartExecutionCommandOutput {
+    readonly executionArn: string;
+    readonly startDate: Date;
+}
+export interface SimDescribeExecutionCommandInput {
+    readonly executionArn?: string;
+}
+export interface SimDescribeExecutionCommand {
+    readonly input: SimDescribeExecutionCommandInput;
+}
+export interface SimDescribeExecutionCommandOutput {
+    readonly executionArn: string;
+    readonly stateMachineArn: string;
+    readonly name: string;
+    readonly status: SimStatesExecutionStatus;
+    readonly startDate: Date;
+    readonly stopDate?: Date;
+    readonly input: string;
+    readonly output?: string;
+    readonly error?: string;
+    readonly cause?: string;
+}
+//# sourceMappingURL=execution.command.d.ts.map

package/dist/service/stepfunctions/command/execution/execution.command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"execution.command.d.ts","sourceRoot":"","sources":["../../../../../src/service/stepfunctions/command/execution/execution.command.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,yCAAyC,CAAC;AAExF,MAAM,WAAW,6BAA6B;IAC5C,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,wBAAwB;IACvC,QAAQ,CAAC,KAAK,EAAE,6BAA6B,CAAC;CAC/C;AAED,MAAM,WAAW,8BAA8B;IAC7C,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,SAAS,EAAE,IAAI,CAAC;CAC1B;AAED,MAAM,WAAW,gCAAgC;IAC/C,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;CAChC;AAED,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,CAAC,KAAK,EAAE,gCAAgC,CAAC;CAClD;AAED,MAAM,WAAW,iCAAiC;IAChD,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,wBAAwB,CAAC;IAC1C,QAAQ,CAAC,SAAS,EAAE,IAAI,CAAC;IACzB,QAAQ,CAAC,QAAQ,CAAC,EAAE,IAAI,CAAC;IACzB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;CACzB"}

package/dist/service/stepfunctions/command/execution/execution.command.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=execution.command.js.map

package/dist/service/stepfunctions/command/execution/execution.command.js.map

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

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

@@ -0,0 +1,11 @@
+import type { SimStatesExecutionStore } from "../../execution/sim-states-execution-store.js";
+import type { SimDescribeExecutionCommand, SimDescribeExecutionCommandOutput } from "./execution.command.js";
+/**
+ * The command that reads an execution back.
+ */
+export declare class SimStatesExecutionDescribe {
+    #private;
+    constructor(executions: SimStatesExecutionStore);
+    handle(command: SimDescribeExecutionCommand): SimDescribeExecutionCommandOutput;
+}
+//# sourceMappingURL=sim-states-execution-describe.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-execution-describe.d.ts","sourceRoot":"","sources":["../../../../../src/service/stepfunctions/command/execution/sim-states-execution-describe.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,+CAA+C,CAAC;AAC7F,OAAO,KAAK,EACV,2BAA2B,EAC3B,iCAAiC,EAClC,MAAM,wBAAwB,CAAC;AAGhC;;GAEG;AACH,qBAAa,0BAA0B;;IAGrC,YAAY,UAAU,EAAE,uBAAuB,EAE9C;IAED,MAAM,CACJ,OAAO,EAAE,2BAA2B,GACnC,iCAAiC,CAkBnC;CACF"}

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

@@ -0,0 +1,23 @@
+import { SimStatesExecutionNotFound, SimStatesInvalidRequest, } from "../../error/sim-step-functions.error.js";
+import { simStatesExecutionView } from "./sim-states-execution-view.js";
+/**
+ * The command that reads an execution back.
+ */
+export class SimStatesExecutionDescribe {
+    #executions;
+    constructor(executions) {
+        this.#executions = executions;
+    }
+    handle(command) {
+        const { executionArn } = command.input;
+        if (executionArn === undefined) {
+            throw new SimStatesInvalidRequest("DescribeExecution needs an executionArn.");
+        }
+        const execution = this.#executions.find(executionArn);
+        if (execution === undefined) {
+            throw new SimStatesExecutionNotFound(`${executionArn} is not a simulated execution in this Account and Region.`);
+        }
+        return simStatesExecutionView(execution);
+    }
+}
+//# sourceMappingURL=sim-states-execution-describe.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-execution-describe.js","sourceRoot":"","sources":["../../../../../src/service/stepfunctions/command/execution/sim-states-execution-describe.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,0BAA0B,EAC1B,uBAAuB,GACxB,MAAM,yCAAyC,CAAC;AAMjD,OAAO,EAAE,sBAAsB,EAAE,MAAM,gCAAgC,CAAC;AAExE;;GAEG;AACH,MAAM,OAAO,0BAA0B;IAC5B,WAAW,CAA0B;IAE9C,YAAY,UAAmC;QAC7C,IAAI,CAAC,WAAW,GAAG,UAAU,CAAC;IAChC,CAAC;IAED,MAAM,CACJ,OAAoC;QAEpC,MAAM,EAAE,YAAY,EAAE,GAAG,OAAO,CAAC,KAAK,CAAC;QAEvC,IAAI,YAAY,KAAK,SAAS,EAAE,CAAC;YAC/B,MAAM,IAAI,uBAAuB,CAC/B,0CAA0C,CAC3C,CAAC;QACJ,CAAC;QAED,MAAM,SAAS,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC;QAEtD,IAAI,SAAS,KAAK,SAAS,EAAE,CAAC;YAC5B,MAAM,IAAI,0BAA0B,CAClC,GAAG,YAAY,2DAA2D,CAC3E,CAAC;QACJ,CAAC;QAED,OAAO,sBAAsB,CAAC,SAAS,CAAC,CAAC;IAC3C,CAAC;CACF"}

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

@@ -0,0 +1,12 @@
+import type { SimStatesExecutionStore } from "../../execution/sim-states-execution-store.js";
+/**
+ * The name an execution runs under.
+ *
+ * Real Step Functions generates a UUID for an unnamed execution. A counter is
+ * used here because a simulation answering the same way twice is worth more
+ * than a name that looks right, and nothing reads meaning out of it. It steps
+ * over a name a caller has already used, so an unnamed start never fails over
+ * a name its caller never wrote.
+ */
+export declare function chooseSimStatesExecutionName(executions: SimStatesExecutionStore, stateMachineArn: string, name: string | undefined): string;
+//# sourceMappingURL=sim-states-execution-name.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-execution-name.d.ts","sourceRoot":"","sources":["../../../../../src/service/stepfunctions/command/execution/sim-states-execution-name.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,+CAA+C,CAAC;AAG7F;;;;;;;;GAQG;AACH,wBAAgB,4BAA4B,CAC1C,UAAU,EAAE,uBAAuB,EACnC,eAAe,EAAE,MAAM,EACvB,IAAI,EAAE,MAAM,GAAG,SAAS,GACvB,MAAM,CAcR"}

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

@@ -0,0 +1,23 @@
+import { checkSimStatesName } from "../../machine/sim-states-name.js";
+/**
+ * The name an execution runs under.
+ *
+ * Real Step Functions generates a UUID for an unnamed execution. A counter is
+ * used here because a simulation answering the same way twice is worth more
+ * than a name that looks right, and nothing reads meaning out of it. It steps
+ * over a name a caller has already used, so an unnamed start never fails over
+ * a name its caller never wrote.
+ */
+export function chooseSimStatesExecutionName(executions, stateMachineArn, name) {
+    if (name !== undefined) {
+        return checkSimStatesName(name, "The execution name");
+    }
+    let index = executions.forStateMachine(stateMachineArn).length;
+    let candidate;
+    do {
+        index += 1;
+        candidate = `execution-${String(index)}`;
+    } while (executions.hasName(stateMachineArn, candidate));
+    return candidate;
+}
+//# sourceMappingURL=sim-states-execution-name.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-execution-name.js","sourceRoot":"","sources":["../../../../../src/service/stepfunctions/command/execution/sim-states-execution-name.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,kBAAkB,EAAE,MAAM,kCAAkC,CAAC;AAEtE;;;;;;;;GAQG;AACH,MAAM,UAAU,4BAA4B,CAC1C,UAAmC,EACnC,eAAuB,EACvB,IAAwB;IAExB,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;QACvB,OAAO,kBAAkB,CAAC,IAAI,EAAE,oBAAoB,CAAC,CAAC;IACxD,CAAC;IAED,IAAI,KAAK,GAAG,UAAU,CAAC,eAAe,CAAC,eAAe,CAAC,CAAC,MAAM,CAAC;IAC/D,IAAI,SAAiB,CAAC;IAEtB,GAAG,CAAC;QACF,KAAK,IAAI,CAAC,CAAC;QACX,SAAS,GAAG,aAAa,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC;IAC3C,CAAC,QAAQ,UAAU,CAAC,OAAO,CAAC,eAAe,EAAE,SAAS,CAAC,EAAE;IAEzD,OAAO,SAAS,CAAC;AACnB,CAAC"}

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

@@ -0,0 +1,12 @@
+import type { SimStatesExecution } from "../../execution/sim-states-execution.js";
+import type { SimStartExecutionCommandOutput } from "./execution.command.js";
+/**
+ * Answer a start that names an execution already there.
+ *
+ * `StartExecution` on a Standard workflow is idempotent. A repeat naming an
+ * execution that is still running, and carrying the same input, answers with
+ * that execution's own response. A repeat naming one that has finished, or
+ * carrying different input, is a name collision.
+ */
+export declare function answerSimStatesRepeatedStart(already: SimStatesExecution, stateMachineName: string, input: string | undefined): SimStartExecutionCommandOutput;
+//# sourceMappingURL=sim-states-execution-repeat.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-execution-repeat.d.ts","sourceRoot":"","sources":["../../../../../src/service/stepfunctions/command/execution/sim-states-execution-repeat.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yCAAyC,CAAC;AAClF,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,wBAAwB,CAAC;AAG7E;;;;;;;GAOG;AACH,wBAAgB,4BAA4B,CAC1C,OAAO,EAAE,kBAAkB,EAC3B,gBAAgB,EAAE,MAAM,EACxB,KAAK,EAAE,MAAM,GAAG,SAAS,GACxB,8BAA8B,CAchC"}

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

@@ -0,0 +1,21 @@
+import { SimStatesExecutionAlreadyExists } from "../../error/sim-step-functions.error.js";
+import { readSimStatesExecutionInput } from "./sim-states-execution-view.js";
+/**
+ * Answer a start that names an execution already there.
+ *
+ * `StartExecution` on a Standard workflow is idempotent. A repeat naming an
+ * execution that is still running, and carrying the same input, answers with
+ * that execution's own response. A repeat naming one that has finished, or
+ * carrying different input, is a name collision.
+ */
+export function answerSimStatesRepeatedStart(already, stateMachineName, input) {
+    const sameInput = JSON.stringify(already.input) ===
+        JSON.stringify(readSimStatesExecutionInput(input));
+    if (sameInput && already.status === "RUNNING") {
+        return { executionArn: already.arn, startDate: already.startDate };
+    }
+    throw new SimStatesExecutionAlreadyExists(`${stateMachineName} already has an execution called ${already.name}. ` +
+        "A repeat is answered with the execution already there only while it " +
+        "is still running on the same input.");
+}
+//# sourceMappingURL=sim-states-execution-repeat.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sim-states-execution-repeat.js","sourceRoot":"","sources":["../../../../../src/service/stepfunctions/command/execution/sim-states-execution-repeat.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,+BAA+B,EAAE,MAAM,yCAAyC,CAAC;AAG1F,OAAO,EAAE,2BAA2B,EAAE,MAAM,gCAAgC,CAAC;AAE7E;;;;;;;GAOG;AACH,MAAM,UAAU,4BAA4B,CAC1C,OAA2B,EAC3B,gBAAwB,EACxB,KAAyB;IAEzB,MAAM,SAAS,GACb,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,KAAK,CAAC;QAC7B,IAAI,CAAC,SAAS,CAAC,2BAA2B,CAAC,KAAK,CAAC,CAAC,CAAC;IAErD,IAAI,SAAS,IAAI,OAAO,CAAC,MAAM,KAAK,SAAS,EAAE,CAAC;QAC9C,OAAO,EAAE,YAAY,EAAE,OAAO,CAAC,GAAG,EAAE,SAAS,EAAE,OAAO,CAAC,SAAS,EAAE,CAAC;IACrE,CAAC;IAED,MAAM,IAAI,+BAA+B,CACvC,GAAG,gBAAgB,oCAAoC,OAAO,CAAC,IAAI,IAAI;QACrE,sEAAsE;QACtE,qCAAqC,CACxC,CAAC;AACJ,CAAC"}