aws-local-stepfunctions 1.0.0 → 1.2.0

package/build/main.node.cjs

@@ -71,20 +71,27 @@ var ExecutionTimeoutError = class extends Error {
   }
 };
 
+// src/error/ErrorWithCause.ts
+var _errorCause;
+var ErrorWithCause = class extends Error {
+  constructor(message, options) {
+    super(message);
+    __privateAdd(this, _errorCause, void 0);
+    __privateSet(this, _errorCause, options?.cause);
+  }
+  get cause() {
+    return __privateGet(this, _errorCause);
+  }
+};
+_errorCause = new WeakMap();
+
 // src/error/ExecutionError.ts
-var _wrappedError;
-var ExecutionError = class extends Error {
+var ExecutionError = class extends ErrorWithCause {
   constructor(caughtError) {
-    super(`Execution has failed with the following error: ${caughtError.message}`);
-    __privateAdd(this, _wrappedError, void 0);
+    super(`Execution has failed with the following error: ${caughtError.message}`, { cause: caughtError });
     this.name = "ExecutionError";
-    __privateSet(this, _wrappedError, caughtError);
-  }
-  get getWrappedError() {
-    return __privateGet(this, _wrappedError);
   }
 };
-_wrappedError = new WeakMap();
 
 // src/util/random.ts
 function cyrb128(str) {
@@ -123,46 +130,58 @@ function getRandomNumber(min, max, rng = Math.random) {
 }
 
 // src/util/index.ts
+var isBrowserEnvironment = typeof window !== "undefined" && typeof window.document !== "undefined";
 function isPlainObj(value) {
   return !!value && Object.getPrototypeOf(value) === Object.prototype;
 }
-function sleep(ms, abortSignal, rootAbortSignal) {
+function sleep(ms, abortSignal) {
   return new Promise((resolve) => {
-    if (abortSignal?.aborted || rootAbortSignal?.aborted) {
+    if (abortSignal?.aborted) {
       return resolve();
     }
     const onAbort = () => {
-      abortSignal?.removeEventListener("abort", onAbort);
-      rootAbortSignal?.removeEventListener("abort", onAbort);
       clearTimeout(timeout);
       resolve();
     };
     const timeout = setTimeout(() => {
       abortSignal?.removeEventListener("abort", onAbort);
-      rootAbortSignal?.removeEventListener("abort", onAbort);
       resolve();
     }, ms);
-    abortSignal?.addEventListener("abort", onAbort);
-    rootAbortSignal?.addEventListener("abort", onAbort);
+    abortSignal?.addEventListener("abort", onAbort, { once: true });
   });
 }
 function byteToHex(byte) {
   return byte.toString(16).padStart(2, "0");
 }
+function isRFC3339Timestamp(date) {
+  const regex = /^\d{4}-(0[1-9]|1[012])-(0[1-9]|[12][0-9]|3[01])T([01][0-9]|2[0-3]):([0-5][0-9]):([0-5][0-9])(\.\d+)?(Z|(\+|-)([01][0-9]|2[0-3]):([0-5][0-9]))$/;
+  return regex.test(date);
+}
+function stringifyJSONValue(value) {
+  return JSON.stringify(value);
+}
+function clamp(value, min, max) {
+  if (min && value < min)
+    return min;
+  if (max && value > max)
+    return max;
+  return value;
+}
 
-// src/stateMachine/JsonPath.ts
+// src/stateMachine/jsonPath/JsonPath.ts
 var import_jsonpath_plus = require("jsonpath-plus");
-function jsonPathQuery(pathExpression, json, context) {
-  if (pathExpression.startsWith("$$")) {
-    return (0, import_jsonpath_plus.JSONPath)({ path: pathExpression.slice(1), json: context ?? null, wrap: false });
+
+// src/stateMachine/jsonPath/constraints/BaseJsonPathConstraint.ts
+var BaseJSONPathConstraint = class {
+  constructor(pathExpression) {
+    this.pathExpression = pathExpression;
   }
-  return (0, import_jsonpath_plus.JSONPath)({ path: pathExpression, json, wrap: false });
-}
+};
 
 // src/error/RuntimeError.ts
-var RuntimeError = class extends Error {
-  constructor(message) {
-    super(message);
+var RuntimeError = class extends ErrorWithCause {
+  constructor(message, cause) {
+    super(message, { cause });
     this.name = "RuntimeError";
     this.retryable = true;
     this.catchable = true;
@@ -175,14 +194,6 @@ var RuntimeError = class extends Error {
   }
 };
 
-// src/error/predefined/StatesResultPathMatchFailureError.ts
-var StatesResultPathMatchFailureError = class extends RuntimeError {
-  constructor() {
-    super("States.ResultPathMatchFailure");
-    this.name = "States.ResultPathMatchFailure";
-  }
-};
-
 // src/error/predefined/StatesRuntimeError.ts
 var StatesRuntimeError = class extends RuntimeError {
   constructor(message = "States.Runtime") {
@@ -193,6 +204,43 @@ var StatesRuntimeError = class extends RuntimeError {
   }
 };
 
+// src/stateMachine/jsonPath/constraints/DefinedValueConstraint.ts
+var DefinedValueConstraint = class extends BaseJSONPathConstraint {
+  test(value) {
+    if (typeof value === "undefined") {
+      throw new StatesRuntimeError(`Path expression '${this.pathExpression}' does not point to a value`);
+    }
+  }
+};
+
+// src/stateMachine/jsonPath/JsonPath.ts
+function jsonPathQuery(pathExpression, json, context, options) {
+  const defaultConstraints = [];
+  if (!options?.ignoreDefinedValueConstraint) {
+    defaultConstraints.push(DefinedValueConstraint);
+  }
+  const constraints = [...defaultConstraints, ...options?.constraints ?? []];
+  let evaluation;
+  if (pathExpression.startsWith("$$")) {
+    evaluation = (0, import_jsonpath_plus.JSONPath)({ path: pathExpression.slice(1), json: context ?? null, wrap: false });
+  } else {
+    evaluation = (0, import_jsonpath_plus.JSONPath)({ path: pathExpression, json, wrap: false });
+  }
+  for (const Constraint of constraints) {
+    const constraintObject = new Constraint(pathExpression);
+    constraintObject.test(evaluation);
+  }
+  return evaluation;
+}
+
+// src/error/predefined/StatesResultPathMatchFailureError.ts
+var StatesResultPathMatchFailureError = class extends RuntimeError {
+  constructor() {
+    super("States.ResultPathMatchFailure");
+    this.name = "States.ResultPathMatchFailure";
+  }
+};
+
 // src/stateMachine/intrinsicFunctions/ArgumentHandling.ts
 function validateArgumentType(allowedTypes, argPosition, funcArg, funcName) {
   let matchesAllowedType = false;
@@ -933,212 +981,300 @@ var StatesNoChoiceMatchedError = class extends RuntimeError {
   }
 };
 
+// src/stateMachine/jsonPath/constraints/StringConstraint.ts
+var StringConstraint = class extends BaseJSONPathConstraint {
+  test(value) {
+    if (typeof value !== "string") {
+      throw new StatesRuntimeError(
+        `Path expression '${this.pathExpression}' evaluated to ${stringifyJSONValue(value)}, but expected a string`
+      );
+    }
+  }
+};
+
+// src/stateMachine/jsonPath/constraints/NumberConstraint.ts
+var NumberConstraint = class extends BaseJSONPathConstraint {
+  test(value) {
+    if (typeof value !== "number") {
+      throw new StatesRuntimeError(
+        `Path expression '${this.pathExpression}' evaluated to ${stringifyJSONValue(value)}, but expected a number`
+      );
+    }
+  }
+};
+
+// src/stateMachine/jsonPath/constraints/BooleanConstraint.ts
+var BooleanConstraint = class extends BaseJSONPathConstraint {
+  test(value) {
+    if (typeof value !== "boolean") {
+      throw new StatesRuntimeError(
+        `Path expression '${this.pathExpression}' evaluated to ${stringifyJSONValue(value)}, but expected a boolean`
+      );
+    }
+  }
+};
+
+// src/stateMachine/jsonPath/constraints/RFC3339TimestampConstraint.ts
+var RFC3339TimestampConstraint = class extends BaseJSONPathConstraint {
+  test(value) {
+    if (typeof value !== "string" || !isRFC3339Timestamp(value)) {
+      throw new StatesRuntimeError(
+        `Path expression '${this.pathExpression}' evaluated to ${stringifyJSONValue(
+          value
+        )}, but expected a timestamp conforming to the RFC3339 profile`
+      );
+    }
+  }
+};
+
 // src/stateMachine/stateActions/ChoiceStateAction.ts
 var import_wildcard_match = __toESM(require("wildcard-match"), 1);
 var ChoiceStateAction = class extends BaseStateAction {
   constructor(stateDefinition, stateName) {
     super(stateDefinition, stateName);
   }
-  testChoiceRule(choiceRule, input) {
+  testChoiceRule(choiceRule, input, context) {
     if ("And" in choiceRule) {
-      return choiceRule.And.every((rule) => this.testChoiceRule(rule, input));
+      return choiceRule.And.every((rule) => this.testChoiceRule(rule, input, context));
     }
     if ("Or" in choiceRule) {
-      return choiceRule.Or.some((rule) => this.testChoiceRule(rule, input));
+      return choiceRule.Or.some((rule) => this.testChoiceRule(rule, input, context));
     }
     if ("Not" in choiceRule) {
-      return !this.testChoiceRule(choiceRule.Not, input);
+      return !this.testChoiceRule(choiceRule.Not, input, context);
     }
     if ("StringEquals" in choiceRule) {
-      const varValue = jsonPathQuery(choiceRule.Variable, input);
+      const varValue = jsonPathQuery(choiceRule.Variable, input, context);
       return varValue === choiceRule.StringEquals;
     }
     if ("StringEqualsPath" in choiceRule) {
-      const varValue = jsonPathQuery(choiceRule.Variable, input);
-      const stringValue = jsonPathQuery(choiceRule.StringEqualsPath, input);
+      const varValue = jsonPathQuery(choiceRule.Variable, input, context);
+      const stringValue = jsonPathQuery(choiceRule.StringEqualsPath, input, context, {
+        constraints: [StringConstraint]
+      });
       return varValue === stringValue;
     }
     if ("StringLessThan" in choiceRule) {
-      const varValue = jsonPathQuery(choiceRule.Variable, input);
+      const varValue = jsonPathQuery(choiceRule.Variable, input, context);
       return varValue < choiceRule.StringLessThan;
     }
     if ("StringLessThanPath" in choiceRule) {
-      const varValue = jsonPathQuery(choiceRule.Variable, input);
-      const stringValue = jsonPathQuery(choiceRule.StringLessThanPath, input);
+      const varValue = jsonPathQuery(choiceRule.Variable, input, context);
+      const stringValue = jsonPathQuery(choiceRule.StringLessThanPath, input, context, {
+        constraints: [StringConstraint]
+      });
       return varValue < stringValue;
     }
     if ("StringGreaterThan" in choiceRule) {
-      const varValue = jsonPathQuery(choiceRule.Variable, input);
+      const varValue = jsonPathQuery(choiceRule.Variable, input, context);
       return varValue > choiceRule.StringGreaterThan;
     }
     if ("StringGreaterThanPath" in choiceRule) {
-      const varValue = jsonPathQuery(choiceRule.Variable, input);
-      const stringValue = jsonPathQuery(choiceRule.StringGreaterThanPath, input);
+      const varValue = jsonPathQuery(choiceRule.Variable, input, context);
+      const stringValue = jsonPathQuery(choiceRule.StringGreaterThanPath, input, context, {
+        constraints: [StringConstraint]
+      });
       return varValue > stringValue;
     }
     if ("StringLessThanEquals" in choiceRule) {
-      const varValue = jsonPathQuery(choiceRule.Variable, input);
+      const varValue = jsonPathQuery(choiceRule.Variable, input, context);
       return varValue <= choiceRule.StringLessThanEquals;
     }
     if ("StringLessThanEqualsPath" in choiceRule) {
-      const varValue = jsonPathQuery(choiceRule.Variable, input);
-      const stringValue = jsonPathQuery(choiceRule.StringLessThanEqualsPath, input);
+      const varValue = jsonPathQuery(choiceRule.Variable, input, context);
+      const stringValue = jsonPathQuery(choiceRule.StringLessThanEqualsPath, input, context, {
+        constraints: [StringConstraint]
+      });
       return varValue <= stringValue;
     }
     if ("StringGreaterThanEquals" in choiceRule) {
-      const varValue = jsonPathQuery(choiceRule.Variable, input);
+      const varValue = jsonPathQuery(choiceRule.Variable, input, context);
       return varValue >= choiceRule.StringGreaterThanEquals;
     }
     if ("StringGreaterThanEqualsPath" in choiceRule) {
-      const varValue = jsonPathQuery(choiceRule.Variable, input);
-      const stringValue = jsonPathQuery(choiceRule.StringGreaterThanEqualsPath, input);
+      const varValue = jsonPathQuery(choiceRule.Variable, input, context);
+      const stringValue = jsonPathQuery(choiceRule.StringGreaterThanEqualsPath, input, context, {
+        constraints: [StringConstraint]
+      });
       return varValue >= stringValue;
     }
     if ("StringMatches" in choiceRule) {
-      const varValue = jsonPathQuery(choiceRule.Variable, input);
+      const varValue = jsonPathQuery(choiceRule.Variable, input, context);
       const isMatch = (0, import_wildcard_match.default)(choiceRule.StringMatches, { separator: false });
       return isMatch(varValue);
     }
     if ("NumericEquals" in choiceRule) {
-      const varValue = jsonPathQuery(choiceRule.Variable, input);
+      const varValue = jsonPathQuery(choiceRule.Variable, input, context);
       return varValue === choiceRule.NumericEquals;
     }
     if ("NumericEqualsPath" in choiceRule) {
-      const varValue = jsonPathQuery(choiceRule.Variable, input);
-      const numberValue = jsonPathQuery(choiceRule.NumericEqualsPath, input);
+      const varValue = jsonPathQuery(choiceRule.Variable, input, context);
+      const numberValue = jsonPathQuery(choiceRule.NumericEqualsPath, input, context, {
+        constraints: [NumberConstraint]
+      });
       return varValue === numberValue;
     }
     if ("NumericLessThan" in choiceRule) {
-      const varValue = jsonPathQuery(choiceRule.Variable, input);
+      const varValue = jsonPathQuery(choiceRule.Variable, input, context);
       return varValue < choiceRule.NumericLessThan;
     }
     if ("NumericLessThanPath" in choiceRule) {
-      const varValue = jsonPathQuery(choiceRule.Variable, input);
-      const numberValue = jsonPathQuery(choiceRule.NumericLessThanPath, input);
+      const varValue = jsonPathQuery(choiceRule.Variable, input, context);
+      const numberValue = jsonPathQuery(choiceRule.NumericLessThanPath, input, context, {
+        constraints: [NumberConstraint]
+      });
       return varValue < numberValue;
     }
     if ("NumericGreaterThan" in choiceRule) {
-      const varValue = jsonPathQuery(choiceRule.Variable, input);
+      const varValue = jsonPathQuery(choiceRule.Variable, input, context);
       return varValue > choiceRule.NumericGreaterThan;
     }
     if ("NumericGreaterThanPath" in choiceRule) {
-      const varValue = jsonPathQuery(choiceRule.Variable, input);
-      const numberValue = jsonPathQuery(choiceRule.NumericGreaterThanPath, input);
+      const varValue = jsonPathQuery(choiceRule.Variable, input, context);
+      const numberValue = jsonPathQuery(choiceRule.NumericGreaterThanPath, input, context, {
+        constraints: [NumberConstraint]
+      });
       return varValue > numberValue;
     }
     if ("NumericLessThanEquals" in choiceRule) {
-      const varValue = jsonPathQuery(choiceRule.Variable, input);
+      const varValue = jsonPathQuery(choiceRule.Variable, input, context);
       return varValue <= choiceRule.NumericLessThanEquals;
     }
     if ("NumericLessThanEqualsPath" in choiceRule) {
-      const varValue = jsonPathQuery(choiceRule.Variable, input);
-      const numberValue = jsonPathQuery(choiceRule.NumericLessThanEqualsPath, input);
+      const varValue = jsonPathQuery(choiceRule.Variable, input, context);
+      const numberValue = jsonPathQuery(choiceRule.NumericLessThanEqualsPath, input, context, {
+        constraints: [NumberConstraint]
+      });
       return varValue <= numberValue;
     }
     if ("NumericGreaterThanEquals" in choiceRule) {
-      const varValue = jsonPathQuery(choiceRule.Variable, input);
+      const varValue = jsonPathQuery(choiceRule.Variable, input, context);
       return varValue >= choiceRule.NumericGreaterThanEquals;
     }
     if ("NumericGreaterThanEqualsPath" in choiceRule) {
-      const varValue = jsonPathQuery(choiceRule.Variable, input);
-      const numberValue = jsonPathQuery(choiceRule.NumericGreaterThanEqualsPath, input);
+      const varValue = jsonPathQuery(choiceRule.Variable, input, context);
+      const numberValue = jsonPathQuery(choiceRule.NumericGreaterThanEqualsPath, input, context, {
+        constraints: [NumberConstraint]
+      });
       return varValue >= numberValue;
     }
     if ("BooleanEquals" in choiceRule) {
-      const varValue = jsonPathQuery(choiceRule.Variable, input);
+      const varValue = jsonPathQuery(choiceRule.Variable, input, context);
       return varValue === choiceRule.BooleanEquals;
     }
     if ("BooleanEqualsPath" in choiceRule) {
-      const varValue = jsonPathQuery(choiceRule.Variable, input);
-      const booleanValue = jsonPathQuery(choiceRule.BooleanEqualsPath, input);
+      const varValue = jsonPathQuery(choiceRule.Variable, input, context);
+      const booleanValue = jsonPathQuery(choiceRule.BooleanEqualsPath, input, context, {
+        constraints: [BooleanConstraint]
+      });
       return varValue === booleanValue;
     }
     if ("TimestampEquals" in choiceRule) {
-      const varValue = new Date(jsonPathQuery(choiceRule.Variable, input));
+      const varValue = new Date(jsonPathQuery(choiceRule.Variable, input, context));
       const timestampValue = new Date(choiceRule.TimestampEquals);
       return varValue.getTime() === timestampValue.getTime();
     }
     if ("TimestampEqualsPath" in choiceRule) {
-      const varValue = new Date(jsonPathQuery(choiceRule.Variable, input));
-      const timestampValue = new Date(jsonPathQuery(choiceRule.TimestampEqualsPath, input));
+      const varValue = new Date(jsonPathQuery(choiceRule.Variable, input, context));
+      const timestampValue = new Date(
+        jsonPathQuery(choiceRule.TimestampEqualsPath, input, context, {
+          constraints: [RFC3339TimestampConstraint]
+        })
+      );
       return varValue.getTime() === timestampValue.getTime();
     }
     if ("TimestampLessThan" in choiceRule) {
-      const varValue = new Date(jsonPathQuery(choiceRule.Variable, input));
+      const varValue = new Date(jsonPathQuery(choiceRule.Variable, input, context));
       const timestampValue = new Date(choiceRule.TimestampLessThan);
       return varValue < timestampValue;
     }
     if ("TimestampLessThanPath" in choiceRule) {
-      const varValue = new Date(jsonPathQuery(choiceRule.Variable, input));
-      const timestampValue = new Date(jsonPathQuery(choiceRule.TimestampLessThanPath, input));
+      const varValue = new Date(jsonPathQuery(choiceRule.Variable, input, context));
+      const timestampValue = new Date(
+        jsonPathQuery(choiceRule.TimestampLessThanPath, input, context, {
+          constraints: [RFC3339TimestampConstraint]
+        })
+      );
       return varValue < timestampValue;
     }
     if ("TimestampGreaterThan" in choiceRule) {
-      const varValue = new Date(jsonPathQuery(choiceRule.Variable, input));
+      const varValue = new Date(jsonPathQuery(choiceRule.Variable, input, context));
       const timestampValue = new Date(choiceRule.TimestampGreaterThan);
       return varValue > timestampValue;
     }
     if ("TimestampGreaterThanPath" in choiceRule) {
-      const varValue = new Date(jsonPathQuery(choiceRule.Variable, input));
-      const timestampValue = new Date(jsonPathQuery(choiceRule.TimestampGreaterThanPath, input));
+      const varValue = new Date(jsonPathQuery(choiceRule.Variable, input, context));
+      const timestampValue = new Date(
+        jsonPathQuery(choiceRule.TimestampGreaterThanPath, input, context, {
+          constraints: [RFC3339TimestampConstraint]
+        })
+      );
       return varValue > timestampValue;
     }
     if ("TimestampLessThanEquals" in choiceRule) {
-      const varValue = new Date(jsonPathQuery(choiceRule.Variable, input));
+      const varValue = new Date(jsonPathQuery(choiceRule.Variable, input, context));
       const timestampValue = new Date(choiceRule.TimestampLessThanEquals);
       return varValue <= timestampValue;
     }
     if ("TimestampLessThanEqualsPath" in choiceRule) {
-      const varValue = new Date(jsonPathQuery(choiceRule.Variable, input));
-      const timestampValue = new Date(jsonPathQuery(choiceRule.TimestampLessThanEqualsPath, input));
+      const varValue = new Date(jsonPathQuery(choiceRule.Variable, input, context));
+      const timestampValue = new Date(
+        jsonPathQuery(choiceRule.TimestampLessThanEqualsPath, input, context, {
+          constraints: [RFC3339TimestampConstraint]
+        })
+      );
       return varValue <= timestampValue;
     }
     if ("TimestampGreaterThanEquals" in choiceRule) {
-      const varValue = new Date(jsonPathQuery(choiceRule.Variable, input));
+      const varValue = new Date(jsonPathQuery(choiceRule.Variable, input, context));
       const timestampValue = new Date(choiceRule.TimestampGreaterThanEquals);
       return varValue >= timestampValue;
     }
     if ("TimestampGreaterThanEqualsPath" in choiceRule) {
-      const varValue = new Date(jsonPathQuery(choiceRule.Variable, input));
-      const timestampValue = new Date(jsonPathQuery(choiceRule.TimestampGreaterThanEqualsPath, input));
+      const varValue = new Date(jsonPathQuery(choiceRule.Variable, input, context));
+      const timestampValue = new Date(
+        jsonPathQuery(choiceRule.TimestampGreaterThanEqualsPath, input, context, {
+          constraints: [RFC3339TimestampConstraint]
+        })
+      );
       return varValue >= timestampValue;
     }
     if ("IsNull" in choiceRule) {
-      const varValue = jsonPathQuery(choiceRule.Variable, input);
+      const varValue = jsonPathQuery(choiceRule.Variable, input, context);
       const isNullTrue = choiceRule.IsNull;
       return isNullTrue && varValue === null;
     }
     if ("IsPresent" in choiceRule) {
-      const varValue = jsonPathQuery(choiceRule.Variable, input);
+      const varValue = jsonPathQuery(choiceRule.Variable, input, context, { ignoreDefinedValueConstraint: true });
       const IsPresentTrue = choiceRule.IsPresent;
       return IsPresentTrue && varValue !== void 0;
     }
     if ("IsNumeric" in choiceRule) {
-      const varValue = jsonPathQuery(choiceRule.Variable, input);
+      const varValue = jsonPathQuery(choiceRule.Variable, input, context);
       const IsNumericTrue = choiceRule.IsNumeric;
       return IsNumericTrue && typeof varValue === "number";
     }
     if ("IsString" in choiceRule) {
-      const varValue = jsonPathQuery(choiceRule.Variable, input);
+      const varValue = jsonPathQuery(choiceRule.Variable, input, context);
       const IsStringTrue = choiceRule.IsString;
       return IsStringTrue && typeof varValue === "string";
     }
     if ("IsBoolean" in choiceRule) {
-      const varValue = jsonPathQuery(choiceRule.Variable, input);
+      const varValue = jsonPathQuery(choiceRule.Variable, input, context);
       const IsBooleanTrue = choiceRule.IsBoolean;
       return IsBooleanTrue && typeof varValue === "boolean";
     }
     if ("IsTimestamp" in choiceRule) {
-      const varValue = jsonPathQuery(choiceRule.Variable, input);
+      const varValue = jsonPathQuery(choiceRule.Variable, input, context);
       const IsTimestampTrue = choiceRule.IsTimestamp;
-      return IsTimestampTrue && /\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(Z|(\+|-)\d{2}:\d{2})/.test(varValue);
+      return IsTimestampTrue && isRFC3339Timestamp(varValue);
     }
     return false;
   }
   async execute(input, context, options) {
     const state = this.stateDefinition;
     for (const choice of state.Choices) {
-      const choiceIsMatch = this.testChoiceRule(choice, input);
+      const choiceIsMatch = this.testChoiceRule(choice, input, context);
       if (choiceIsMatch) {
         return { stateResult: input, nextState: choice.Next, isEndState: false };
       }
@@ -1164,7 +1300,56 @@ var FailStateAction = class extends BaseStateAction {
     super(stateDefinition, stateName);
   }
   async execute(input, context, options) {
-    throw new FailStateError(this.stateDefinition.Error, this.stateDefinition.Cause);
+    const state = this.stateDefinition;
+    let error = state.Error;
+    let cause = state.Cause;
+    if (state.ErrorPath) {
+      error = jsonPathQuery(state.ErrorPath, input, context, {
+        constraints: [StringConstraint]
+      });
+    }
+    if (state.CausePath) {
+      cause = jsonPathQuery(state.CausePath, input, context, {
+        constraints: [StringConstraint]
+      });
+    }
+    throw new FailStateError(error, cause);
+  }
+};
+
+// src/stateMachine/jsonPath/constraints/ArrayConstraint.ts
+var ArrayConstraint = class extends BaseJSONPathConstraint {
+  test(value) {
+    if (!Array.isArray(value)) {
+      throw new StatesRuntimeError(
+        `Path expression '${this.pathExpression}' evaluated to ${stringifyJSONValue(value)}, but expected an array`
+      );
+    }
+  }
+};
+
+// src/stateMachine/jsonPath/constraints/IntegerConstraint.ts
+var IntegerConstraint = class extends BaseJSONPathConstraint {
+  test(value) {
+    if (!Number.isInteger(value)) {
+      throw new StatesRuntimeError(
+        `Path expression '${this.pathExpression}' evaluated to ${stringifyJSONValue(value)}, but expected an integer`
+      );
+    }
+  }
+  static greaterThanOrEqual(n) {
+    return class extends this {
+      test(value) {
+        super.test(value);
+        if (value < n) {
+          throw new StatesRuntimeError(
+            `Path expression '${this.pathExpression}' evaluated to ${stringifyJSONValue(
+              value
+            )}, but expected an integer >= ${n}`
+          );
+        }
+      }
+    };
   }
 };
 
@@ -1192,28 +1377,39 @@ var MapStateAction = class extends BaseStateAction {
         Value: item
       }
     };
-    if (state.Parameters) {
-      paramValue = processPayloadTemplate(state.Parameters, input, context);
+    if (state.Parameters || state.ItemSelector) {
+      const parameters = state.ItemSelector ?? state.Parameters;
+      paramValue = processPayloadTemplate(parameters, input, context);
     }
-    const execution = stateMachine.run(paramValue ?? item, options?.runOptions);
+    const execution = stateMachine.run(paramValue ?? item, options.runOptions);
     this.executionAbortFuncs.push(execution.abort);
-    this.forwardEventsToRootEventLogger(options?.eventLogger, execution.eventLogs, index, options?.rawInput);
+    this.forwardEventsToRootEventLogger(options.eventLogger, execution.eventLogs, index, options.rawInput);
     return execution.result;
   }
   async execute(input, context, options) {
     const state = this.stateDefinition;
     let items = input;
     if (state.ItemsPath) {
-      items = jsonPathQuery(state.ItemsPath, input, context);
+      items = jsonPathQuery(state.ItemsPath, input, context, {
+        constraints: [ArrayConstraint]
+      });
     }
     if (!Array.isArray(items)) {
       throw new StatesRuntimeError("Input of Map state must be an array or ItemsPath property must point to an array");
     }
-    const iteratorStateMachine = new StateMachine(state.Iterator, {
-      ...options?.stateMachineOptions,
-      validationOptions: { _noValidate: true }
+    const iteratorDefinition = state.ItemProcessor ?? state.Iterator;
+    const iteratorStateMachine = new StateMachine(iteratorDefinition, {
+      ...options.stateMachineOptions,
+      validationOptions: { noValidate: true }
     });
-    const limit = (0, import_p_limit.default)(state.MaxConcurrency || DEFAULT_MAX_CONCURRENCY);
+    let maxConcurrency = state.MaxConcurrency;
+    if (state.MaxConcurrencyPath) {
+      maxConcurrency = jsonPathQuery(state.MaxConcurrencyPath, input, context, {
+        constraints: [IntegerConstraint.greaterThanOrEqual(0)],
+        ignoreDefinedValueConstraint: true
+      });
+    }
+    const limit = (0, import_p_limit.default)(maxConcurrency || DEFAULT_MAX_CONCURRENCY);
     const processedItemsPromise = items.map(
       (item, i) => limit(() => this.processItem(iteratorStateMachine, item, input, context, i, options))
     );
@@ -1223,7 +1419,7 @@ var MapStateAction = class extends BaseStateAction {
     } catch (error) {
       this.executionAbortFuncs.forEach((abort) => abort());
       if (error instanceof ExecutionError) {
-        throw error.getWrappedError;
+        throw error.cause;
       }
       throw error;
     } finally {
@@ -1249,12 +1445,12 @@ var ParallelStateAction = class extends BaseStateAction {
   }
   processBranch(branch, input, context, options) {
     const stateMachine = new StateMachine(branch, {
-      ...options?.stateMachineOptions,
-      validationOptions: { _noValidate: true }
+      ...options.stateMachineOptions,
+      validationOptions: { noValidate: true }
     });
-    const execution = stateMachine.run(input, options?.runOptions);
+    const execution = stateMachine.run(input, options.runOptions);
     this.executionAbortFuncs.push(execution.abort);
-    this.forwardEventsToRootEventLogger(options?.eventLogger, execution.eventLogs, options?.rawInput);
+    this.forwardEventsToRootEventLogger(options.eventLogger, execution.eventLogs, options.rawInput);
     return execution.result;
   }
   async execute(input, context, options) {
@@ -1269,7 +1465,7 @@ var ParallelStateAction = class extends BaseStateAction {
     } catch (error) {
       this.executionAbortFuncs.forEach((abort) => abort());
       if (error instanceof ExecutionError) {
-        throw error.getWrappedError;
+        throw error.cause;
       }
       throw error;
     }
@@ -1299,16 +1495,39 @@ var SucceedStateAction = class extends BaseStateAction {
   }
 };
 
+// src/error/predefined/StatesTimeoutError.ts
+var StatesTimeoutError = class extends RuntimeError {
+  constructor() {
+    super("States.Timeout");
+    this.name = "States.Timeout";
+  }
+};
+
 // src/aws/LambdaClient.ts
 var import_client_lambda = require("@aws-sdk/client-lambda");
 var import_credential_providers = require("@aws-sdk/credential-providers");
+
+// src/error/LambdaInvocationError.ts
+var LambdaInvocationError = class extends RuntimeError {
+  constructor(name, message, cause) {
+    super(message, cause);
+    this.name = name;
+  }
+};
+
+// src/aws/LambdaClient.ts
 var LambdaClient = class {
   constructor(config) {
     this.client = new import_client_lambda.LambdaClient({});
     if (config) {
       if (!config.region) {
         throw new StatesRuntimeError(
-          "'awsConfig' option was specified for state machine, but 'region' property is not set"
+          "'awsConfig' option was specified in state machine constructor, but 'region' property is not set."
+        );
+      }
+      if (!config.credentials) {
+        throw new StatesRuntimeError(
+          "'awsConfig' option was specified in state machine constructor, but 'credentials' property is not set."
         );
       }
       if (config.credentials) {
@@ -1331,6 +1550,12 @@ var LambdaClient = class {
       } else if (config.credentials?.accessKeys) {
         this.client = new import_client_lambda.LambdaClient({ region: config.region, credentials: config.credentials.accessKeys });
       }
+    } else {
+      if (isBrowserEnvironment) {
+        throw new StatesRuntimeError(
+          "aws-local-stepfunctions is running in a browser environment and your state machine definition contains a state of type 'Task'. In order to invoke the Lambda function, you must provide an AWS region and credentials in the state machine constructor by passing the 'awsConfig' option."
+        );
+      }
     }
   }
   async invokeFunction(funcNameOrArn, payload) {
@@ -1347,7 +1572,11 @@ var LambdaClient = class {
     }
     if (invocationResult.FunctionError) {
       const errorResult = resultValue;
-      throw new FailStateError(errorResult.errorType, `Execution of Lambda function '${funcNameOrArn}' failed`);
+      throw new LambdaInvocationError(
+        errorResult.errorType,
+        `${errorResult.errorType}: ${errorResult.errorMessage}`,
+        errorResult
+      );
     }
     return resultValue;
   }
@@ -1357,15 +1586,46 @@ var LambdaClient = class {
 var TaskStateAction = class extends BaseStateAction {
   constructor(stateDefinition, stateName) {
     super(stateDefinition, stateName);
+    this.timeoutAbortController = new AbortController();
+  }
+  createTimeoutPromise(input, context) {
+    const state = this.stateDefinition;
+    if (!state.TimeoutSeconds && !state.TimeoutSecondsPath)
+      return;
+    let timeout;
+    if (state.TimeoutSeconds) {
+      timeout = state.TimeoutSeconds;
+    } else if (state.TimeoutSecondsPath) {
+      timeout = jsonPathQuery(state.TimeoutSecondsPath, input, context, {
+        constraints: [IntegerConstraint.greaterThanOrEqual(1)]
+      });
+    }
+    return new Promise((_, reject) => {
+      const handleTimeoutAbort = () => clearTimeout(timeoutId);
+      const timeoutId = setTimeout(() => {
+        this.timeoutAbortController.signal.removeEventListener("abort", handleTimeoutAbort);
+        reject(new StatesTimeoutError());
+      }, timeout * 1e3);
+      this.timeoutAbortController.signal.addEventListener("abort", handleTimeoutAbort, { once: true });
+    });
   }
   async execute(input, context, options) {
     const state = this.stateDefinition;
-    if (options?.overrideFn) {
-      const result2 = await options.overrideFn(input);
-      return this.buildExecutionResult(result2);
+    const racingPromises = [];
+    const timeoutPromise = this.createTimeoutPromise(input, context);
+    if (options.overrideFn) {
+      const resultPromise = options.overrideFn(input);
+      racingPromises.push(resultPromise);
+    } else {
+      const lambdaClient = new LambdaClient(options.awsConfig);
+      const resultPromise = lambdaClient.invokeFunction(state.Resource, input);
+      racingPromises.push(resultPromise);
+    }
+    if (timeoutPromise) {
+      racingPromises.push(timeoutPromise);
     }
-    const lambdaClient = new LambdaClient(options?.awsConfig);
-    const result = await lambdaClient.invokeFunction(state.Resource, input);
+    const result = await Promise.race(racingPromises);
+    this.timeoutAbortController.abort();
     return this.buildExecutionResult(result);
   }
 };
@@ -1377,44 +1637,41 @@ var WaitStateAction = class extends BaseStateAction {
   }
   async execute(input, context, options) {
     const state = this.stateDefinition;
-    if (options?.waitTimeOverrideOption !== void 0) {
-      await sleep(options.waitTimeOverrideOption, options.abortSignal, options.rootAbortSignal);
+    if (options.waitTimeOverrideOption !== void 0) {
+      await sleep(options.waitTimeOverrideOption, options.abortSignal);
       return this.buildExecutionResult(input);
     }
     if (state.Seconds) {
-      await sleep(state.Seconds * 1e3, options?.abortSignal, options?.rootAbortSignal);
+      await sleep(state.Seconds * 1e3, options.abortSignal);
     } else if (state.Timestamp) {
       const dateTimestamp = new Date(state.Timestamp);
       const currentTime = Date.now();
       const timeDiff = dateTimestamp.getTime() - currentTime;
-      await sleep(timeDiff, options?.abortSignal, options?.rootAbortSignal);
+      await sleep(timeDiff, options.abortSignal);
     } else if (state.SecondsPath) {
-      const seconds = jsonPathQuery(state.SecondsPath, input, context);
-      await sleep(seconds * 1e3, options?.abortSignal, options?.rootAbortSignal);
+      const seconds = jsonPathQuery(state.SecondsPath, input, context, {
+        constraints: [IntegerConstraint.greaterThanOrEqual(0)]
+      });
+      await sleep(seconds * 1e3, options.abortSignal);
     } else if (state.TimestampPath) {
-      const timestamp = jsonPathQuery(state.TimestampPath, input, context);
+      const timestamp = jsonPathQuery(state.TimestampPath, input, context, {
+        constraints: [RFC3339TimestampConstraint]
+      });
       const dateTimestamp = new Date(timestamp);
       const currentTime = Date.now();
       const timeDiff = dateTimestamp.getTime() - currentTime;
-      await sleep(timeDiff, options?.abortSignal, options?.rootAbortSignal);
+      await sleep(timeDiff, options.abortSignal);
     }
     return this.buildExecutionResult(input);
   }
 };
 
-// src/error/predefined/StatesTimeoutError.ts
-var StatesTimeoutError = class extends RuntimeError {
-  constructor() {
-    super("States.Timeout");
-    this.name = "States.Timeout";
-  }
-};
-
 // src/stateMachine/StateExecutor.ts
 var import_cloneDeep2 = __toESM(require("lodash/cloneDeep.js"), 1);
 var DEFAULT_MAX_ATTEMPTS = 3;
 var DEFAULT_INTERVAL_SECONDS = 1;
 var DEFAULT_BACKOFF_RATE = 2;
+var DEFAULT_JITTER_STRATEGY = "NONE";
 var WILDCARD_ERROR = "States.ALL";
 var TASK_STATE_WILDCARD_ERROR = "States.TaskFailed";
 var StateExecutor = class {
@@ -1456,13 +1713,34 @@ var StateExecutor = class {
       const processedResult = this.processResult(currResult, rawInput, context);
       return { stateResult: processedResult, nextState, isEndState };
     } catch (error) {
-      const { shouldRetry, waitTimeBeforeRetry } = this.shouldRetry(error);
-      if (shouldRetry && waitTimeBeforeRetry) {
-        await sleep(waitTimeBeforeRetry, options.abortSignal, options.runOptions?._rootAbortSignal);
+      options.eventLogger.dispatchStateFailedEvent(
+        this.stateName,
+        this.stateDefinition.Type,
+        input,
+        error
+      );
+      const { shouldRetry, waitTimeBeforeRetry, retrierIndex } = this.shouldRetry(error);
+      if (shouldRetry) {
+        const stateDefinition = this.stateDefinition;
+        await sleep(waitTimeBeforeRetry, options.abortSignal);
+        options.eventLogger.dispatchStateRetriedEvent(
+          this.stateName,
+          stateDefinition.Type,
+          input,
+          stateDefinition.Retry[retrierIndex],
+          this.retrierAttempts[retrierIndex]
+        );
         return this.execute(input, context, options);
       }
-      const { nextState, errorOutput, resultPath } = this.catchError(error);
+      const { nextState, errorOutput, resultPath, catcherIndex } = this.catchError(error);
       if (nextState && errorOutput) {
+        const stateDefinition = this.stateDefinition;
+        options.eventLogger.dispatchStateCaughtEvent(
+          this.stateName,
+          stateDefinition.Type,
+          input,
+          stateDefinition.Catch[catcherIndex]
+        );
         return { stateResult: processResultPath(resultPath, rawInput, errorOutput), nextState, isEndState: false };
       }
       throw error;
@@ -1506,11 +1784,16 @@ var StateExecutor = class {
     }
     for (let i = 0; i < this.stateDefinition.Retry.length; i++) {
       const retrier = this.stateDefinition.Retry[i];
+      const jitterStrategy = retrier.JitterStrategy ?? DEFAULT_JITTER_STRATEGY;
       const maxAttempts = retrier.MaxAttempts ?? DEFAULT_MAX_ATTEMPTS;
       const intervalSeconds = retrier.IntervalSeconds ?? DEFAULT_INTERVAL_SECONDS;
       const backoffRate = retrier.BackoffRate ?? DEFAULT_BACKOFF_RATE;
-      const waitTimeBeforeRetry = intervalSeconds * Math.pow(backoffRate, this.retrierAttempts[i]) * 1e3;
+      const waitInterval = intervalSeconds * Math.pow(backoffRate, this.retrierAttempts[i]);
       const retryable = error.isRetryable ?? true;
+      let waitTimeBeforeRetry = clamp(waitInterval, 1, retrier.MaxDelaySeconds) * 1e3;
+      if (jitterStrategy === "FULL") {
+        waitTimeBeforeRetry = getRandomNumber(0, waitTimeBeforeRetry);
+      }
       for (const retrierError of retrier.ErrorEquals) {
         const isErrorMatch = retrierError === error.name;
         const isErrorWildcard = retrierError === WILDCARD_ERROR;
@@ -1520,7 +1803,7 @@ var StateExecutor = class {
           if (this.retrierAttempts[i] >= maxAttempts)
             return { shouldRetry: false };
           this.retrierAttempts[i]++;
-          return { shouldRetry: true, waitTimeBeforeRetry };
+          return { shouldRetry: true, waitTimeBeforeRetry, retrierIndex: i };
         }
       }
     }
@@ -1548,7 +1831,7 @@ var StateExecutor = class {
             Cause: error.message
           };
           const resultPath = catcher.ResultPath;
-          return { nextState, errorOutput, resultPath };
+          return { nextState, errorOutput, resultPath, catcherIndex: i };
         }
       }
     }
@@ -1622,8 +1905,7 @@ var StateExecutor = class {
     const waitStateAction = new WaitStateAction(stateDefinition, stateName);
     const executionResult = await waitStateAction.execute(input, context, {
       waitTimeOverrideOption,
-      abortSignal: options.abortSignal,
-      rootAbortSignal: options.runOptions?._rootAbortSignal
+      abortSignal: options.abortSignal
     });
     return executionResult;
   }
@@ -1708,6 +1990,9 @@ var EventLogger = class {
         break;
       case "StateEntered":
       case "StateExited":
+      case "StateFailed":
+      case "StateRetried":
+      case "StateCaught":
         event.index = index;
         this.dispatch(event);
         break;
@@ -1752,7 +2037,12 @@ var EventLogger = class {
     this.close();
   }
   dispatchExecutionFailedEvent(error) {
-    this.dispatch({ type: "ExecutionFailed", timestamp: Date.now(), Error: error.name, Cause: error.message });
+    this.dispatch({
+      type: "ExecutionFailed",
+      timestamp: Date.now(),
+      Error: error.name,
+      Cause: error.cause ?? error.message
+    });
     this.close();
   }
   dispatchExecutionAbortedEvent() {
@@ -1777,6 +2067,31 @@ var EventLogger = class {
       state: { name: stateName, type: stateType, input, output }
     });
   }
+  dispatchStateFailedEvent(stateName, stateType, input, error) {
+    this.dispatch({
+      type: "StateFailed",
+      timestamp: Date.now(),
+      state: { name: stateName, type: stateType, input },
+      Error: error.name,
+      Cause: error.cause ?? error.message
+    });
+  }
+  dispatchStateRetriedEvent(stateName, stateType, input, retrier, retryAttempt) {
+    this.dispatch({
+      type: "StateRetried",
+      timestamp: Date.now(),
+      state: { name: stateName, type: stateType, input },
+      retry: { retrier, attempt: retryAttempt }
+    });
+  }
+  dispatchStateCaughtEvent(stateName, stateType, input, catcher) {
+    this.dispatch({
+      type: "StateCaught",
+      timestamp: Date.now(),
+      state: { name: stateName, type: stateType, input },
+      catch: { catcher }
+    });
+  }
   dispatchMapIterationStartedEvent(event, index, mapStateName, mapStateRawInput) {
     this.dispatch({
       ...event,
@@ -1852,7 +2167,7 @@ var StateMachine = class {
    * These options also apply to state machines defined in the `Iterator` field of `Map` states and in the `Branches` field of `Parallel` states.
    */
   constructor(definition, stateMachineOptions) {
-    if (!stateMachineOptions?.validationOptions?._noValidate) {
+    if (!stateMachineOptions?.validationOptions?.noValidate) {
       const { isValid, errorsText } = (0, import_asl_validator.default)(definition, {
         checkArn: true,
         checkPaths: true,
@@ -1883,6 +2198,15 @@ var StateMachine = class {
   run(input, options) {
     const abortController = new AbortController();
     const eventLogger = new EventLogger();
+    let rootSignalAbortHandler;
+    if (options?._rootAbortSignal) {
+      rootSignalAbortHandler = () => abortController.abort();
+      if (options._rootAbortSignal.aborted) {
+        rootSignalAbortHandler();
+      } else {
+        options._rootAbortSignal.addEventListener("abort", rootSignalAbortHandler);
+      }
+    }
     let onAbortHandler;
     const settleOnAbort = new Promise((resolve, reject) => {
       if (options?.noThrowOnAbort) {
@@ -1920,6 +2244,7 @@ var StateMachine = class {
       },
       () => {
         abortController.signal.removeEventListener("abort", onAbortHandler);
+        options?._rootAbortSignal?.removeEventListener("abort", rootSignalAbortHandler);
         clearTimeout(timeoutId);
       }
     );