aws-local-stepfunctions 0.7.0 → 1.1.0

package/build/main.node.cjs

@@ -50,7 +50,7 @@ var main_exports = {};
 __export(main_exports, {
   ExecutionAbortedError: () => ExecutionAbortedError,
   ExecutionError: () => ExecutionError,
-  ExecutionTimeoutError: () => StatesTimeoutError,
+  ExecutionTimeoutError: () => ExecutionTimeoutError,
   StateMachine: () => StateMachine
 });
 module.exports = __toCommonJS(main_exports);
@@ -63,44 +63,35 @@ var ExecutionAbortedError = class extends Error {
   }
 };
 
-// src/error/RuntimeError.ts
-var RuntimeError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "RuntimeError";
-    this.retryable = true;
-    this.catchable = true;
-  }
-  get isRetryable() {
-    return this.retryable;
-  }
-  get isCatchable() {
-    return this.catchable;
+// src/error/ExecutionTimeoutError.ts
+var ExecutionTimeoutError = class extends Error {
+  constructor() {
+    super("Execution timed out");
+    this.name = "ExecutionTimeoutError";
   }
 };
 
-// src/error/predefined/StatesTimeoutError.ts
-var StatesTimeoutError = class extends RuntimeError {
-  constructor() {
-    super("States.Timeout");
-    this.name = "States.Timeout";
+// 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) {
@@ -134,40 +125,65 @@ function sfc32(a, b, c, d) {
     return (t >>> 0) / 4294967296;
   };
 }
-function getRandomNumber(min, max, rngGenerator = Math.random) {
-  return Math.floor(rngGenerator() * (max - min + 1)) + min;
+function getRandomNumber(min, max, rng = Math.random) {
+  return Math.floor(rng() * (max - min + 1)) + min;
 }
 
 // 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) {
   return new Promise((resolve) => {
-    const timeout = setTimeout(resolve, ms);
-    abortSignal?.addEventListener("abort", () => {
+    if (abortSignal?.aborted) {
+      return resolve();
+    }
+    const onAbort = () => {
       clearTimeout(timeout);
-    });
+      resolve();
+    };
+    const timeout = setTimeout(() => {
+      abortSignal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    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);
+}
 
-// 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/predefined/StatesResultPathMatchFailureError.ts
-var StatesResultPathMatchFailureError = class extends RuntimeError {
-  constructor() {
-    super("States.ResultPathMatchFailure");
-    this.name = "States.ResultPathMatchFailure";
+// src/error/RuntimeError.ts
+var RuntimeError = class extends ErrorWithCause {
+  constructor(message, cause) {
+    super(message, { cause });
+    this.name = "RuntimeError";
+    this.retryable = true;
+    this.catchable = true;
+  }
+  get isRetryable() {
+    return this.retryable;
+  }
+  get isCatchable() {
+    return this.catchable;
   }
 };
 
@@ -181,6 +197,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;
@@ -897,8 +950,9 @@ function processOutputPath(path, result, context) {
 
 // src/stateMachine/stateActions/BaseStateAction.ts
 var BaseStateAction = class {
-  constructor(stateDefinition) {
+  constructor(stateDefinition, stateName) {
     this.stateDefinition = stateDefinition;
+    this.stateName = stateName;
   }
   buildExecutionResult(stateResult) {
     const executionResult = { stateResult, nextState: "", isEndState: false };
@@ -920,212 +974,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) {
-    super(stateDefinition);
+  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 };
       }
@@ -1147,22 +1289,40 @@ var FailStateError = class extends RuntimeError {
 
 // src/stateMachine/stateActions/FailStateAction.ts
 var FailStateAction = class extends BaseStateAction {
-  constructor(stateDefinition) {
-    super(stateDefinition);
+  constructor(stateDefinition, stateName) {
+    super(stateDefinition, stateName);
   }
   async execute(input, context, options) {
     throw new FailStateError(this.stateDefinition.Error, this.stateDefinition.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/stateActions/MapStateAction.ts
 var import_p_limit = __toESM(require("p-limit"), 1);
 var DEFAULT_MAX_CONCURRENCY = 40;
 var MapStateAction = class extends BaseStateAction {
-  constructor(stateDefinition) {
-    super(stateDefinition);
+  constructor(stateDefinition, stateName) {
+    super(stateDefinition, stateName);
     this.executionAbortFuncs = [];
   }
+  async forwardEventsToRootEventLogger(eventLogger, executionEventLogs, index, parentStateRawInput) {
+    if (!eventLogger)
+      return;
+    for await (const event of executionEventLogs) {
+      eventLogger.forwardNestedMapEvent(event, index, this.stateName, parentStateRawInput);
+    }
+  }
   processItem(stateMachine, item, input, context, index, options) {
     const state = this.stateDefinition;
     let paramValue;
@@ -1175,22 +1335,25 @@ var MapStateAction = class extends BaseStateAction {
     if (state.Parameters) {
       paramValue = processPayloadTemplate(state.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);
     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 }
+      ...options.stateMachineOptions,
+      validationOptions: { noValidate: true }
     });
     const limit = (0, import_p_limit.default)(state.MaxConcurrency || DEFAULT_MAX_CONCURRENCY);
     const processedItemsPromise = items.map(
@@ -1202,7 +1365,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 {
@@ -1215,17 +1378,25 @@ var MapStateAction = class extends BaseStateAction {
 var import_p_limit2 = __toESM(require("p-limit"), 1);
 var DEFAULT_CONCURRENCY = 40;
 var ParallelStateAction = class extends BaseStateAction {
-  constructor(stateDefinition) {
-    super(stateDefinition);
+  constructor(stateDefinition, stateName) {
+    super(stateDefinition, stateName);
     this.executionAbortFuncs = [];
   }
+  async forwardEventsToRootEventLogger(eventLogger, executionEventLogs, parentStateRawInput) {
+    if (!eventLogger)
+      return;
+    for await (const event of executionEventLogs) {
+      eventLogger.forwardNestedParallelEvent(event, this.stateName, parentStateRawInput);
+    }
+  }
   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);
     return execution.result;
   }
   async execute(input, context, options) {
@@ -1240,7 +1411,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;
     }
@@ -1249,8 +1420,8 @@ var ParallelStateAction = class extends BaseStateAction {
 
 // src/stateMachine/stateActions/PassStateAction.ts
 var PassStateAction = class extends BaseStateAction {
-  constructor(stateDefinition) {
-    super(stateDefinition);
+  constructor(stateDefinition, stateName) {
+    super(stateDefinition, stateName);
   }
   async execute(input, context, options) {
     if (this.stateDefinition.Result) {
@@ -1262,8 +1433,8 @@ var PassStateAction = class extends BaseStateAction {
 
 // src/stateMachine/stateActions/SucceedStateAction.ts
 var SucceedStateAction = class extends BaseStateAction {
-  constructor(stateDefinition) {
-    super(stateDefinition);
+  constructor(stateDefinition, stateName) {
+    super(stateDefinition, stateName);
   }
   async execute(input, context, options) {
     return { stateResult: input, nextState: "", isEndState: true };
@@ -1273,13 +1444,28 @@ var SucceedStateAction = class extends BaseStateAction {
 // 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) {
@@ -1302,6 +1488,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) {
@@ -1318,7 +1510,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;
   }
@@ -1326,53 +1522,90 @@ var LambdaClient = class {
 
 // src/stateMachine/stateActions/TaskStateAction.ts
 var TaskStateAction = class extends BaseStateAction {
-  constructor(stateDefinition) {
-    super(stateDefinition);
+  constructor(stateDefinition, stateName) {
+    super(stateDefinition, stateName);
   }
   async execute(input, context, options) {
     const state = this.stateDefinition;
-    if (options?.overrideFn) {
+    if (options.overrideFn) {
       const result2 = await options.overrideFn(input);
       return this.buildExecutionResult(result2);
     }
-    const lambdaClient = new LambdaClient(options?.awsConfig);
+    const lambdaClient = new LambdaClient(options.awsConfig);
     const result = await lambdaClient.invokeFunction(state.Resource, input);
     return this.buildExecutionResult(result);
   }
 };
 
+// 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}`
+          );
+        }
+      }
+    };
+  }
+};
+
 // src/stateMachine/stateActions/WaitStateAction.ts
 var WaitStateAction = class extends BaseStateAction {
-  constructor(stateDefinition) {
-    super(stateDefinition);
+  constructor(stateDefinition, stateName) {
+    super(stateDefinition, stateName);
   }
   async execute(input, context, options) {
     const state = this.stateDefinition;
-    if (options?.waitTimeOverrideOption !== void 0) {
+    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);
+      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);
+      await sleep(timeDiff, options.abortSignal);
     } else if (state.SecondsPath) {
-      const seconds = jsonPathQuery(state.SecondsPath, input, context);
-      await sleep(seconds * 1e3, options?.abortSignal);
+      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);
+      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;
@@ -1410,6 +1643,7 @@ var StateExecutor = class {
       } = await this.stateHandlers[this.stateDefinition.Type](
         // @ts-expect-error Indexing `this.stateActions` by non-literal value produces a `never` type for the `this.stateDefinition` parameter of the handler being called
         this.stateDefinition,
+        rawInput,
         processedInput,
         context,
         this.stateName,
@@ -1418,13 +1652,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) {
+      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;
@@ -1482,7 +1737,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 };
         }
       }
     }
@@ -1510,7 +1765,7 @@ var StateExecutor = class {
             Cause: error.message
           };
           const resultPath = catcher.ResultPath;
-          return { nextState, errorOutput, resultPath };
+          return { nextState, errorOutput, resultPath, catcherIndex: i };
         }
       }
     }
@@ -1522,10 +1777,10 @@ var StateExecutor = class {
    * Invokes the Lambda function specified in the `Resource` field
    * and sets the current result of the state machine to the value returned by the Lambda.
    */
-  async executeTaskState(stateDefinition, input, context, stateName, options) {
+  async executeTaskState(stateDefinition, rawInput, input, context, stateName, options) {
     const overrideFn = options.runOptions?.overrides?.taskResourceLocalHandlers?.[stateName];
     const awsConfig = options.stateMachineOptions?.awsConfig;
-    const taskStateAction = new TaskStateAction(stateDefinition);
+    const taskStateAction = new TaskStateAction(stateDefinition, stateName);
     const executionResult = await taskStateAction.execute(input, context, { overrideFn, awsConfig });
     return executionResult;
   }
@@ -1535,11 +1790,13 @@ var StateExecutor = class {
    * Creates a new state machine for each of the branches specified in the `Branches` field,
    * and then executes each branch state machine by passing them the Parallel state input.
    */
-  async executeParallelState(stateDefinition, input, context, stateName, options) {
-    const parallelStateAction = new ParallelStateAction(stateDefinition);
+  async executeParallelState(stateDefinition, rawInput, input, context, stateName, options) {
+    const parallelStateAction = new ParallelStateAction(stateDefinition, stateName);
     const executionResult = await parallelStateAction.execute(input, context, {
       stateMachineOptions: options.stateMachineOptions,
-      runOptions: options.runOptions
+      runOptions: options.runOptions,
+      eventLogger: options.eventLogger,
+      rawInput
     });
     return executionResult;
   }
@@ -1550,11 +1807,13 @@ var StateExecutor = class {
    * by the `ItemsPath` field, and then processes each item by passing it
    * as the input to the state machine specified in the `Iterator` field.
    */
-  async executeMapState(stateDefinition, input, context, stateName, options) {
-    const mapStateAction = new MapStateAction(stateDefinition);
+  async executeMapState(stateDefinition, rawInput, input, context, stateName, options) {
+    const mapStateAction = new MapStateAction(stateDefinition, stateName);
     const executionResult = await mapStateAction.execute(input, context, {
       stateMachineOptions: options.stateMachineOptions,
-      runOptions: options.runOptions
+      runOptions: options.runOptions,
+      eventLogger: options.eventLogger,
+      rawInput
     });
     return executionResult;
   }
@@ -1564,8 +1823,8 @@ var StateExecutor = class {
    * If the `Result` field is specified, copies `Result` into the current result.
    * Else, copies the current input into the current result.
    */
-  async executePassState(stateDefinition, input, context, stateName, options) {
-    const passStateAction = new PassStateAction(stateDefinition);
+  async executePassState(stateDefinition, rawInput, input, context, stateName, options) {
+    const passStateAction = new PassStateAction(stateDefinition, stateName);
     const executionResult = await passStateAction.execute(input, context);
     return executionResult;
   }
@@ -1575,13 +1834,12 @@ var StateExecutor = class {
    * Pauses the state machine execution for a certain amount of time
    * based on one of the `Seconds`, `Timestamp`, `SecondsPath` or `TimestampPath` fields.
    */
-  async executeWaitState(stateDefinition, input, context, stateName, options) {
+  async executeWaitState(stateDefinition, rawInput, input, context, stateName, options) {
     const waitTimeOverrideOption = options.runOptions?.overrides?.waitTimeOverrides?.[stateName];
-    const abortSignal = options.abortSignal;
-    const waitStateAction = new WaitStateAction(stateDefinition);
+    const waitStateAction = new WaitStateAction(stateDefinition, stateName);
     const executionResult = await waitStateAction.execute(input, context, {
       waitTimeOverrideOption,
-      abortSignal
+      abortSignal: options.abortSignal
     });
     return executionResult;
   }
@@ -1599,8 +1857,8 @@ var StateExecutor = class {
    * If no rule matches and the `Default` field is not specified, throws a
    * States.NoChoiceMatched error.
    */
-  async executeChoiceState(stateDefinition, input, context, stateName, options) {
-    const choiceStateAction = new ChoiceStateAction(stateDefinition);
+  async executeChoiceState(stateDefinition, rawInput, input, context, stateName, options) {
+    const choiceStateAction = new ChoiceStateAction(stateDefinition, stateName);
     const executionResult = await choiceStateAction.execute(input, context);
     return executionResult;
   }
@@ -1609,8 +1867,8 @@ var StateExecutor = class {
    *
    * Ends the state machine execution successfully.
    */
-  async executeSucceedState(stateDefinition, input, context, stateName, options) {
-    const succeedStateAction = new SucceedStateAction(stateDefinition);
+  async executeSucceedState(stateDefinition, rawInput, input, context, stateName, options) {
+    const succeedStateAction = new SucceedStateAction(stateDefinition, stateName);
     const executionResult = await succeedStateAction.execute(input, context);
     return executionResult;
   }
@@ -1619,17 +1877,222 @@ var StateExecutor = class {
    *
    * Ends the state machine execution and marks it as a failure.
    */
-  async executeFailState(stateDefinition, input, context, stateName, options) {
-    const failStateAction = new FailStateAction(stateDefinition);
+  async executeFailState(stateDefinition, rawInput, input, context, stateName, options) {
+    const failStateAction = new FailStateAction(stateDefinition, stateName);
     const executionResult = await failStateAction.execute(input, context);
     return executionResult;
   }
 };
 
+// src/stateMachine/EventLogger.ts
+var EventLogger = class {
+  constructor() {
+    this.eventTarget = new EventTarget();
+    this.eventQueue = [];
+    this.isLoggerClosed = false;
+  }
+  async *getEvents() {
+    while (true) {
+      if (this.eventQueue.length === 0) {
+        await this.waitForNewEvent();
+      }
+      let event = null;
+      while (event = this.eventQueue.shift()) {
+        yield event;
+      }
+      if (this.isLoggerClosed)
+        return;
+    }
+  }
+  /**
+   * Forward nested events created by `Map` states, to the root state machine event logger.
+   * @param event An event dispatched by the nested state machine spawned by a `Map` state.
+   * @param index Index of the current iteration being processed.
+   * @param mapStateName Name of the `Map` state being executed.
+   * @param mapStateRawInput Raw input passed to the `Map` state being executed.
+   */
+  forwardNestedMapEvent(event, index, mapStateName, mapStateRawInput) {
+    switch (event.type) {
+      case "ExecutionStarted":
+        this.dispatchMapIterationStartedEvent(event, index, mapStateName, mapStateRawInput);
+        break;
+      case "ExecutionSucceeded":
+        this.dispatchMapIterationSucceededEvent(event, index, mapStateName, mapStateRawInput);
+        break;
+      case "ExecutionFailed":
+        this.dispatchMapIterationFailedEvent(event, index, mapStateName, mapStateRawInput);
+        break;
+      case "StateEntered":
+      case "StateExited":
+      case "StateFailed":
+      case "StateRetried":
+      case "StateCaught":
+        event.index = index;
+        this.dispatch(event);
+        break;
+      case "ExecutionAborted":
+      case "ExecutionTimeout":
+        return;
+      default:
+        this.dispatch(event);
+        break;
+    }
+  }
+  /**
+   * Forward nested events created by `Parallel` states, to the root state machine event logger.
+   * @param event An event dispatched by the nested state machines spawned by a `Parallel` state.
+   * @param parallelStateName Name of the `Parallel` state being executed.
+   * @param parallelStateRawInput Raw input passed to the `Parallel` state being executed.
+   */
+  forwardNestedParallelEvent(event, parallelStateName, parallelStateRawInput) {
+    switch (event.type) {
+      case "ExecutionStarted":
+        this.dispatchParallelBranchStartedEvent(event, parallelStateName, parallelStateRawInput);
+        break;
+      case "ExecutionSucceeded":
+        this.dispatchParallelBranchSucceededEvent(event, parallelStateName, parallelStateRawInput);
+        break;
+      case "ExecutionFailed":
+        this.dispatchParallelBranchFailedEvent(event, parallelStateName, parallelStateRawInput);
+        break;
+      case "ExecutionAborted":
+      case "ExecutionTimeout":
+        return;
+      default:
+        this.dispatch(event);
+        break;
+    }
+  }
+  dispatchExecutionStartedEvent(input) {
+    this.dispatch({ type: "ExecutionStarted", timestamp: Date.now(), input });
+  }
+  dispatchExecutionSucceededEvent(output) {
+    this.dispatch({ type: "ExecutionSucceeded", timestamp: Date.now(), output });
+    this.close();
+  }
+  dispatchExecutionFailedEvent(error) {
+    this.dispatch({
+      type: "ExecutionFailed",
+      timestamp: Date.now(),
+      Error: error.name,
+      Cause: error.cause ?? error.message
+    });
+    this.close();
+  }
+  dispatchExecutionAbortedEvent() {
+    this.dispatch({ type: "ExecutionAborted", timestamp: Date.now() });
+    this.close();
+  }
+  dispatchExecutionTimeoutEvent() {
+    this.dispatch({ type: "ExecutionTimeout", timestamp: Date.now() });
+    this.close();
+  }
+  dispatchStateEnteredEvent(stateName, stateType, input) {
+    this.dispatch({
+      type: "StateEntered",
+      timestamp: Date.now(),
+      state: { name: stateName, type: stateType, input }
+    });
+  }
+  dispatchStateExitedEvent(stateName, stateType, input, output) {
+    this.dispatch({
+      type: "StateExited",
+      timestamp: Date.now(),
+      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,
+      type: "MapIterationStarted",
+      index,
+      parentState: { type: "Map", name: mapStateName, input: mapStateRawInput }
+    });
+  }
+  dispatchMapIterationSucceededEvent(event, index, mapStateName, mapStateRawInput) {
+    this.dispatch({
+      ...event,
+      type: "MapIterationSucceeded",
+      index,
+      parentState: { type: "Map", name: mapStateName, input: mapStateRawInput }
+    });
+  }
+  dispatchMapIterationFailedEvent(event, index, mapStateName, mapStateRawInput) {
+    this.dispatch({
+      ...event,
+      type: "MapIterationFailed",
+      index,
+      parentState: { type: "Map", name: mapStateName, input: mapStateRawInput }
+    });
+  }
+  dispatchParallelBranchStartedEvent(event, parallelStateName, parallelStateRawInput) {
+    this.dispatch({
+      ...event,
+      type: "ParallelBranchStarted",
+      parentState: { type: "Parallel", name: parallelStateName, input: parallelStateRawInput }
+    });
+  }
+  dispatchParallelBranchSucceededEvent(event, parallelStateName, parallelStateRawInput) {
+    this.dispatch({
+      ...event,
+      type: "ParallelBranchSucceeded",
+      parentState: { type: "Parallel", name: parallelStateName, input: parallelStateRawInput }
+    });
+  }
+  dispatchParallelBranchFailedEvent(event, parallelStateName, parallelStateRawInput) {
+    this.dispatch({
+      ...event,
+      type: "ParallelBranchFailed",
+      parentState: { type: "Parallel", name: parallelStateName, input: parallelStateRawInput }
+    });
+  }
+  close() {
+    this.isLoggerClosed = true;
+    this.eventTarget.dispatchEvent(new Event("newEvent"));
+  }
+  dispatch(event) {
+    if (this.isLoggerClosed)
+      return;
+    this.eventQueue.push(event);
+    this.eventTarget.dispatchEvent(new Event("newEvent"));
+  }
+  waitForNewEvent() {
+    if (this.isLoggerClosed)
+      return;
+    return new Promise((resolve) => {
+      this.eventTarget.addEventListener("newEvent", resolve, { once: true });
+    });
+  }
+};
+
 // src/stateMachine/StateMachine.ts
 var import_asl_validator = __toESM(require("asl-validator"), 1);
 var import_cloneDeep3 = __toESM(require("lodash/cloneDeep.js"), 1);
-var DEFAULT_MAX_EXECUTION_TIMEOUT = 2147483647e-3;
 var StateMachine = class {
   /**
    * Constructs a new state machine.
@@ -1638,7 +2101,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,
@@ -1657,6 +2120,9 @@ var StateMachine = class {
    * If the execution fails, the result will throw an `ExecutionError` explaining why the
    * execution failed.
    *
+   * If the execution times out because the number of seconds specified in
+   * the `TimeoutSeconds` top-level field has elapsed, the result will throw an `ExecutionTimeoutError`.
+   *
    * By default, if the execution is aborted, the result will throw an `ExecutionAbortedError`. This behavior can be changed by setting
    * the `noThrowOnAbort` option to `true`, in which case the result will be `null`.
    *
@@ -1665,40 +2131,65 @@ var StateMachine = class {
    */
   run(input, options) {
     const abortController = new AbortController();
-    const timeoutSeconds = this.definition.TimeoutSeconds ?? DEFAULT_MAX_EXECUTION_TIMEOUT;
+    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) {
-        onAbortHandler = () => resolve(null);
+        onAbortHandler = () => {
+          eventLogger.dispatchExecutionAbortedEvent();
+          resolve(null);
+        };
       } else {
-        onAbortHandler = () => reject(new ExecutionAbortedError());
+        onAbortHandler = () => {
+          eventLogger.dispatchExecutionAbortedEvent();
+          reject(new ExecutionAbortedError());
+        };
       }
       abortController.signal.addEventListener("abort", onAbortHandler);
     });
+    let rejectOnTimeout;
     let timeoutId;
-    const rejectOnTimeout = new Promise((_, reject) => {
-      timeoutId = setTimeout(() => {
-        abortController.signal.removeEventListener("abort", onAbortHandler);
-        abortController.abort();
-        reject(new StatesTimeoutError());
-      }, timeoutSeconds * 1e3);
-    });
+    if (this.definition.TimeoutSeconds !== void 0) {
+      rejectOnTimeout = new Promise((_, reject) => {
+        timeoutId = setTimeout(() => {
+          abortController.signal.removeEventListener("abort", onAbortHandler);
+          abortController.abort();
+          eventLogger.dispatchExecutionTimeoutEvent();
+          reject(new ExecutionTimeoutError());
+        }, this.definition.TimeoutSeconds * 1e3);
+      });
+    }
     const executionResult = this.execute(
       input,
       {
         stateMachineOptions: this.stateMachineOptions,
-        runOptions: options,
-        abortSignal: abortController.signal
+        runOptions: { ...options, _rootAbortSignal: options?._rootAbortSignal ?? abortController.signal },
+        abortSignal: abortController.signal,
+        eventLogger
       },
       () => {
         abortController.signal.removeEventListener("abort", onAbortHandler);
+        options?._rootAbortSignal?.removeEventListener("abort", rootSignalAbortHandler);
         clearTimeout(timeoutId);
       }
     );
-    const racingPromises = [executionResult, settleOnAbort, rejectOnTimeout];
+    const racingPromises = [executionResult, settleOnAbort];
+    if (rejectOnTimeout) {
+      racingPromises.push(rejectOnTimeout);
+    }
     const result = Promise.race(racingPromises);
     return {
       abort: () => abortController.abort(),
+      eventLogs: eventLogger.getEvents(),
       result
     };
   }
@@ -1706,26 +2197,31 @@ var StateMachine = class {
    * Helper method that handles the execution of the machine states and the transitions between them.
    */
   async execute(input, options, cleanupFn) {
+    options.eventLogger.dispatchExecutionStartedEvent(input);
+    const context = options.runOptions?.context ?? {};
     let currState = this.definition.States[this.definition.StartAt];
     let currStateName = this.definition.StartAt;
     let currInput = (0, import_cloneDeep3.default)(input);
     let currResult = null;
     let nextState = "";
     let isEndState = false;
-    let context = {};
     try {
       do {
+        options.eventLogger.dispatchStateEnteredEvent(currStateName, currState.Type, currInput);
         const stateExecutor = new StateExecutor(currStateName, currState);
         ({ stateResult: currResult, nextState, isEndState } = await stateExecutor.execute(currInput, context, options));
+        options.eventLogger.dispatchStateExitedEvent(currStateName, currState.Type, currInput, currResult);
         currInput = currResult;
         currState = this.definition.States[nextState];
         currStateName = nextState;
       } while (!isEndState && !options.abortSignal.aborted);
     } catch (error) {
+      options.eventLogger.dispatchExecutionFailedEvent(error);
       throw new ExecutionError(error);
     } finally {
       cleanupFn();
     }
+    options.eventLogger.dispatchExecutionSucceededEvent(currResult);
     return currResult;
   }
 };