aws-local-stepfunctions 0.3.2 → 0.5.0

package/build/main.node.esm.js

@@ -0,0 +1,964 @@
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateGet = (obj, member, getter) => {
+  __accessCheck(obj, member, "read from private field");
+  return getter ? getter.call(obj) : member.get(obj);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateSet = (obj, member, value, setter) => {
+  __accessCheck(obj, member, "write to private field");
+  setter ? setter.call(obj, value) : member.set(obj, value);
+  return value;
+};
+
+// src/error/ExecutionAbortedError.ts
+var ExecutionAbortedError = class extends Error {
+  constructor() {
+    super("Execution aborted");
+    this.name = "ExecutionAbortedError";
+  }
+};
+
+// src/error/ExecutionError.ts
+var _wrappedError;
+var ExecutionError = class extends Error {
+  constructor(caughtError) {
+    super(`Execution has failed with the following error: ${caughtError.message}`);
+    __privateAdd(this, _wrappedError, void 0);
+    this.name = "ExecutionError";
+    __privateSet(this, _wrappedError, caughtError);
+  }
+  get getWrappedError() {
+    return __privateGet(this, _wrappedError);
+  }
+};
+_wrappedError = new WeakMap();
+
+// src/util/index.ts
+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", () => {
+      clearTimeout(timeout);
+    });
+  });
+}
+
+// src/stateMachine/JsonPath.ts
+import { JSONPath as jp } from "jsonpath-plus";
+function jsonPathQuery(pathExpression, json, context) {
+  if (pathExpression.startsWith("$$")) {
+    return jp({ path: pathExpression.slice(1), json: context ?? null, wrap: false });
+  }
+  return jp({ path: pathExpression, json, wrap: false });
+}
+
+// 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/predefined/StatesResultPathMatchFailureError.ts
+var StatesResultPathMatchFailureError = class extends RuntimeError {
+  constructor() {
+    super("States.ResultPathMatchFailure");
+    this.name = "States.ResultPathMatchFailure";
+  }
+};
+
+// src/stateMachine/InputOutputProcessing.ts
+import cloneDeep from "lodash/cloneDeep.js";
+import set from "lodash/set.js";
+function processInputPath(path, input, context) {
+  if (path === void 0) {
+    return input;
+  }
+  if (path === null) {
+    return {};
+  }
+  return jsonPathQuery(path, input, context);
+}
+function processPayloadTemplate(payloadTemplate, json, context) {
+  const resolvedProperties = Object.entries(payloadTemplate).map(([key, value]) => {
+    let sanitizedKey = key;
+    let resolvedValue = value;
+    if (isPlainObj(value)) {
+      resolvedValue = processPayloadTemplate(value, json);
+    }
+    if (key.endsWith(".$") && typeof value === "string") {
+      sanitizedKey = key.replace(".$", "");
+      resolvedValue = jsonPathQuery(value, json, context);
+    }
+    return [sanitizedKey, resolvedValue];
+  });
+  return Object.fromEntries(resolvedProperties);
+}
+function processResultPath(path, rawInput, result) {
+  if (path === void 0) {
+    return result;
+  }
+  if (path === null) {
+    return rawInput;
+  }
+  const sanitizedPath = path.replace("$.", "");
+  if (isPlainObj(rawInput)) {
+    const clonedRawInput = cloneDeep(rawInput);
+    return set(clonedRawInput, sanitizedPath, result);
+  }
+  throw new StatesResultPathMatchFailureError();
+}
+function processOutputPath(path, result, context) {
+  if (path === void 0) {
+    return result;
+  }
+  if (path === null) {
+    return {};
+  }
+  return jsonPathQuery(path, result, context);
+}
+
+// src/stateMachine/stateActions/BaseStateAction.ts
+var BaseStateAction = class {
+  constructor(stateDefinition) {
+    this.stateDefinition = stateDefinition;
+  }
+  buildExecutionResult(stateResult) {
+    const executionResult = { stateResult, nextState: "", isEndState: false };
+    if ("Next" in this.stateDefinition) {
+      executionResult.nextState = this.stateDefinition.Next;
+    }
+    if ("End" in this.stateDefinition) {
+      executionResult.isEndState = this.stateDefinition.End;
+    }
+    return executionResult;
+  }
+};
+
+// src/error/predefined/StatesNoChoiceMatchedError.ts
+var StatesNoChoiceMatchedError = class extends RuntimeError {
+  constructor() {
+    super("States.NoChoiceMatched");
+    this.name = "States.NoChoiceMatched";
+  }
+};
+
+// src/stateMachine/stateActions/ChoiceStateAction.ts
+import wcmatch from "wildcard-match";
+var ChoiceStateAction = class extends BaseStateAction {
+  constructor(stateDefinition) {
+    super(stateDefinition);
+  }
+  testChoiceRule(choiceRule, input) {
+    if ("And" in choiceRule) {
+      return choiceRule.And.every((rule) => this.testChoiceRule(rule, input));
+    }
+    if ("Or" in choiceRule) {
+      return choiceRule.Or.some((rule) => this.testChoiceRule(rule, input));
+    }
+    if ("Not" in choiceRule) {
+      return !this.testChoiceRule(choiceRule.Not, input);
+    }
+    if ("StringEquals" in choiceRule) {
+      const varValue = jsonPathQuery(choiceRule.Variable, input);
+      return varValue === choiceRule.StringEquals;
+    }
+    if ("StringEqualsPath" in choiceRule) {
+      const varValue = jsonPathQuery(choiceRule.Variable, input);
+      const stringValue = jsonPathQuery(choiceRule.StringEqualsPath, input);
+      return varValue === stringValue;
+    }
+    if ("StringLessThan" in choiceRule) {
+      const varValue = jsonPathQuery(choiceRule.Variable, input);
+      return varValue < choiceRule.StringLessThan;
+    }
+    if ("StringLessThanPath" in choiceRule) {
+      const varValue = jsonPathQuery(choiceRule.Variable, input);
+      const stringValue = jsonPathQuery(choiceRule.StringLessThanPath, input);
+      return varValue < stringValue;
+    }
+    if ("StringGreaterThan" in choiceRule) {
+      const varValue = jsonPathQuery(choiceRule.Variable, input);
+      return varValue > choiceRule.StringGreaterThan;
+    }
+    if ("StringGreaterThanPath" in choiceRule) {
+      const varValue = jsonPathQuery(choiceRule.Variable, input);
+      const stringValue = jsonPathQuery(choiceRule.StringGreaterThanPath, input);
+      return varValue > stringValue;
+    }
+    if ("StringLessThanEquals" in choiceRule) {
+      const varValue = jsonPathQuery(choiceRule.Variable, input);
+      return varValue <= choiceRule.StringLessThanEquals;
+    }
+    if ("StringLessThanEqualsPath" in choiceRule) {
+      const varValue = jsonPathQuery(choiceRule.Variable, input);
+      const stringValue = jsonPathQuery(choiceRule.StringLessThanEqualsPath, input);
+      return varValue <= stringValue;
+    }
+    if ("StringGreaterThanEquals" in choiceRule) {
+      const varValue = jsonPathQuery(choiceRule.Variable, input);
+      return varValue >= choiceRule.StringGreaterThanEquals;
+    }
+    if ("StringGreaterThanEqualsPath" in choiceRule) {
+      const varValue = jsonPathQuery(choiceRule.Variable, input);
+      const stringValue = jsonPathQuery(choiceRule.StringGreaterThanEqualsPath, input);
+      return varValue >= stringValue;
+    }
+    if ("StringMatches" in choiceRule) {
+      const varValue = jsonPathQuery(choiceRule.Variable, input);
+      const isMatch = wcmatch(choiceRule.StringMatches, { separator: false });
+      return isMatch(varValue);
+    }
+    if ("NumericEquals" in choiceRule) {
+      const varValue = jsonPathQuery(choiceRule.Variable, input);
+      return varValue === choiceRule.NumericEquals;
+    }
+    if ("NumericEqualsPath" in choiceRule) {
+      const varValue = jsonPathQuery(choiceRule.Variable, input);
+      const numberValue = jsonPathQuery(choiceRule.NumericEqualsPath, input);
+      return varValue === numberValue;
+    }
+    if ("NumericLessThan" in choiceRule) {
+      const varValue = jsonPathQuery(choiceRule.Variable, input);
+      return varValue < choiceRule.NumericLessThan;
+    }
+    if ("NumericLessThanPath" in choiceRule) {
+      const varValue = jsonPathQuery(choiceRule.Variable, input);
+      const numberValue = jsonPathQuery(choiceRule.NumericLessThanPath, input);
+      return varValue < numberValue;
+    }
+    if ("NumericGreaterThan" in choiceRule) {
+      const varValue = jsonPathQuery(choiceRule.Variable, input);
+      return varValue > choiceRule.NumericGreaterThan;
+    }
+    if ("NumericGreaterThanPath" in choiceRule) {
+      const varValue = jsonPathQuery(choiceRule.Variable, input);
+      const numberValue = jsonPathQuery(choiceRule.NumericGreaterThanPath, input);
+      return varValue > numberValue;
+    }
+    if ("NumericLessThanEquals" in choiceRule) {
+      const varValue = jsonPathQuery(choiceRule.Variable, input);
+      return varValue <= choiceRule.NumericLessThanEquals;
+    }
+    if ("NumericLessThanEqualsPath" in choiceRule) {
+      const varValue = jsonPathQuery(choiceRule.Variable, input);
+      const numberValue = jsonPathQuery(choiceRule.NumericLessThanEqualsPath, input);
+      return varValue <= numberValue;
+    }
+    if ("NumericGreaterThanEquals" in choiceRule) {
+      const varValue = jsonPathQuery(choiceRule.Variable, input);
+      return varValue >= choiceRule.NumericGreaterThanEquals;
+    }
+    if ("NumericGreaterThanEqualsPath" in choiceRule) {
+      const varValue = jsonPathQuery(choiceRule.Variable, input);
+      const numberValue = jsonPathQuery(choiceRule.NumericGreaterThanEqualsPath, input);
+      return varValue >= numberValue;
+    }
+    if ("BooleanEquals" in choiceRule) {
+      const varValue = jsonPathQuery(choiceRule.Variable, input);
+      return varValue === choiceRule.BooleanEquals;
+    }
+    if ("BooleanEqualsPath" in choiceRule) {
+      const varValue = jsonPathQuery(choiceRule.Variable, input);
+      const booleanValue = jsonPathQuery(choiceRule.BooleanEqualsPath, input);
+      return varValue === booleanValue;
+    }
+    if ("TimestampEquals" in choiceRule) {
+      const varValue = new Date(jsonPathQuery(choiceRule.Variable, input));
+      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));
+      return varValue.getTime() === timestampValue.getTime();
+    }
+    if ("TimestampLessThan" in choiceRule) {
+      const varValue = new Date(jsonPathQuery(choiceRule.Variable, input));
+      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));
+      return varValue < timestampValue;
+    }
+    if ("TimestampGreaterThan" in choiceRule) {
+      const varValue = new Date(jsonPathQuery(choiceRule.Variable, input));
+      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));
+      return varValue > timestampValue;
+    }
+    if ("TimestampLessThanEquals" in choiceRule) {
+      const varValue = new Date(jsonPathQuery(choiceRule.Variable, input));
+      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));
+      return varValue <= timestampValue;
+    }
+    if ("TimestampGreaterThanEquals" in choiceRule) {
+      const varValue = new Date(jsonPathQuery(choiceRule.Variable, input));
+      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));
+      return varValue >= timestampValue;
+    }
+    if ("IsNull" in choiceRule) {
+      const varValue = jsonPathQuery(choiceRule.Variable, input);
+      const isNullTrue = choiceRule.IsNull;
+      return isNullTrue && varValue === null;
+    }
+    if ("IsPresent" in choiceRule) {
+      const varValue = jsonPathQuery(choiceRule.Variable, input);
+      const IsPresentTrue = choiceRule.IsPresent;
+      return IsPresentTrue && varValue !== void 0;
+    }
+    if ("IsNumeric" in choiceRule) {
+      const varValue = jsonPathQuery(choiceRule.Variable, input);
+      const IsNumericTrue = choiceRule.IsNumeric;
+      return IsNumericTrue && typeof varValue === "number";
+    }
+    if ("IsString" in choiceRule) {
+      const varValue = jsonPathQuery(choiceRule.Variable, input);
+      const IsStringTrue = choiceRule.IsString;
+      return IsStringTrue && typeof varValue === "string";
+    }
+    if ("IsBoolean" in choiceRule) {
+      const varValue = jsonPathQuery(choiceRule.Variable, input);
+      const IsBooleanTrue = choiceRule.IsBoolean;
+      return IsBooleanTrue && typeof varValue === "boolean";
+    }
+    if ("IsTimestamp" in choiceRule) {
+      const varValue = jsonPathQuery(choiceRule.Variable, input);
+      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 false;
+  }
+  async execute(input, context, options) {
+    const state = this.stateDefinition;
+    for (const choice of state.Choices) {
+      const choiceIsMatch = this.testChoiceRule(choice, input);
+      if (choiceIsMatch) {
+        return { stateResult: input, nextState: choice.Next, isEndState: false };
+      }
+    }
+    if (state.Default) {
+      return { stateResult: input, nextState: state.Default, isEndState: false };
+    }
+    throw new StatesNoChoiceMatchedError();
+  }
+};
+
+// src/error/FailStateError.ts
+var FailStateError = class extends RuntimeError {
+  constructor(name = "FailStateError", message = "Execution failed because of a Fail state") {
+    super(message);
+    this.name = name;
+  }
+};
+
+// src/stateMachine/stateActions/FailStateAction.ts
+var FailStateAction = class extends BaseStateAction {
+  constructor(stateDefinition) {
+    super(stateDefinition);
+  }
+  async execute(input, context, options) {
+    throw new FailStateError(this.stateDefinition.Error, this.stateDefinition.Cause);
+  }
+};
+
+// src/error/predefined/StatesRuntimeError.ts
+var StatesRuntimeError = class extends RuntimeError {
+  constructor(message = "States.Runtime") {
+    super(message);
+    this.name = "States.Runtime";
+    this.retryable = false;
+    this.catchable = false;
+  }
+};
+
+// src/stateMachine/stateActions/MapStateAction.ts
+import pLimit from "p-limit";
+var DEFAULT_MAX_CONCURRENCY = 40;
+var MapStateAction = class extends BaseStateAction {
+  constructor(stateDefinition) {
+    super(stateDefinition);
+    this.executionAbortFuncs = [];
+  }
+  processItem(stateMachine, item, input, context, index, options) {
+    const state = this.stateDefinition;
+    let paramValue;
+    context["Map"] = {
+      Item: {
+        Index: index,
+        Value: item
+      }
+    };
+    if (state.Parameters) {
+      paramValue = processPayloadTemplate(state.Parameters, input, context);
+    }
+    const execution = stateMachine.run(paramValue ?? item, options?.runOptions);
+    this.executionAbortFuncs.push(execution.abort);
+    return execution.result;
+  }
+  async execute(input, context, options) {
+    const state = this.stateDefinition;
+    let items = input;
+    if (state.ItemsPath) {
+      items = jsonPathQuery(state.ItemsPath, input, context);
+    }
+    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);
+    const limit = pLimit(state.MaxConcurrency || DEFAULT_MAX_CONCURRENCY);
+    const processedItemsPromise = items.map(
+      (item, i) => limit(() => this.processItem(iteratorStateMachine, item, input, context, i, options))
+    );
+    try {
+      const result = await Promise.all(processedItemsPromise);
+      return this.buildExecutionResult(result);
+    } catch (error) {
+      this.executionAbortFuncs.forEach((abort) => abort());
+      if (error instanceof ExecutionError) {
+        throw error.getWrappedError;
+      }
+      throw error;
+    } finally {
+      delete context["Map"];
+    }
+  }
+};
+
+// src/stateMachine/stateActions/ParallelStateAction.ts
+import pLimit2 from "p-limit";
+var DEFAULT_CONCURRENCY = 40;
+var ParallelStateAction = class extends BaseStateAction {
+  constructor(stateDefinition) {
+    super(stateDefinition);
+    this.executionAbortFuncs = [];
+  }
+  processBranch(branch, input, context, options) {
+    const stateMachine = new StateMachine(branch, options?.stateMachineOptions);
+    const execution = stateMachine.run(input, options?.runOptions);
+    this.executionAbortFuncs.push(execution.abort);
+    return execution.result;
+  }
+  async execute(input, context, options) {
+    const state = this.stateDefinition;
+    const limit = pLimit2(DEFAULT_CONCURRENCY);
+    const processedBranchesPromise = state.Branches.map(
+      (branch) => limit(() => this.processBranch(branch, input, context, options))
+    );
+    try {
+      const result = await Promise.all(processedBranchesPromise);
+      return this.buildExecutionResult(result);
+    } catch (error) {
+      this.executionAbortFuncs.forEach((abort) => abort());
+      if (error instanceof ExecutionError) {
+        throw error.getWrappedError;
+      }
+      throw error;
+    }
+  }
+};
+
+// src/stateMachine/stateActions/PassStateAction.ts
+var PassStateAction = class extends BaseStateAction {
+  constructor(stateDefinition) {
+    super(stateDefinition);
+  }
+  async execute(input, context, options) {
+    if (this.stateDefinition.Result) {
+      return this.buildExecutionResult(this.stateDefinition.Result);
+    }
+    return this.buildExecutionResult(input);
+  }
+};
+
+// src/stateMachine/stateActions/SucceedStateAction.ts
+var SucceedStateAction = class extends BaseStateAction {
+  constructor(stateDefinition) {
+    super(stateDefinition);
+  }
+  async execute(input, context, options) {
+    return { stateResult: input, nextState: "", isEndState: true };
+  }
+};
+
+// src/aws/LambdaClient.ts
+import { LambdaClient as AWSLambdaClient, InvokeCommand } from "@aws-sdk/client-lambda";
+import { fromCognitoIdentityPool } from "@aws-sdk/credential-providers";
+var LambdaClient = class {
+  constructor(config) {
+    this.client = new AWSLambdaClient({});
+    if (config) {
+      if (!config.region) {
+        throw new Error("`awsConfig` option was specified for state machine, but `region` property is not set");
+      }
+      if (config.credentials) {
+        const credentialsTypes = Object.keys(config.credentials);
+        const credentialsNames = credentialsTypes.map((name) => `\`${name}\``).join(", ");
+        if (credentialsTypes.length > 1) {
+          throw new Error(
+            `More than one type of AWS credentials were specified: ${credentialsNames}. Only one type may be specified`
+          );
+        }
+      }
+      if (config.credentials?.cognitoIdentityPool) {
+        this.client = new AWSLambdaClient({
+          region: config.region,
+          credentials: fromCognitoIdentityPool({
+            ...config.credentials.cognitoIdentityPool,
+            clientConfig: { region: config.region }
+          })
+        });
+      } else if (config.credentials?.accessKeys) {
+        this.client = new AWSLambdaClient({ region: config.region, credentials: config.credentials.accessKeys });
+      }
+    }
+  }
+  async invokeFunction(funcNameOrArn, payload) {
+    const payloadBuffer = new TextEncoder().encode(JSON.stringify(payload));
+    const invokeCommand = new InvokeCommand({
+      FunctionName: funcNameOrArn,
+      Payload: payloadBuffer
+    });
+    const invocationResult = await this.client.send(invokeCommand);
+    let resultValue = null;
+    if (invocationResult.Payload) {
+      resultValue = new TextDecoder().decode(invocationResult.Payload);
+      resultValue = JSON.parse(resultValue);
+    }
+    if (invocationResult.FunctionError) {
+      const errorResult = resultValue;
+      throw new FailStateError(errorResult.errorType, `Execution of Lambda function "${funcNameOrArn}" failed`);
+    }
+    return resultValue;
+  }
+};
+
+// src/stateMachine/stateActions/TaskStateAction.ts
+var TaskStateAction = class extends BaseStateAction {
+  constructor(stateDefinition) {
+    super(stateDefinition);
+  }
+  async execute(input, context, options) {
+    const state = this.stateDefinition;
+    if (options?.overrideFn) {
+      const result2 = await options.overrideFn(input);
+      return this.buildExecutionResult(result2);
+    }
+    const lambdaClient = new LambdaClient(options?.awsConfig);
+    const result = await lambdaClient.invokeFunction(state.Resource, input);
+    return this.buildExecutionResult(result);
+  }
+};
+
+// src/stateMachine/stateActions/WaitStateAction.ts
+var WaitStateAction = class extends BaseStateAction {
+  constructor(stateDefinition) {
+    super(stateDefinition);
+  }
+  async execute(input, context, options) {
+    const state = this.stateDefinition;
+    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);
+    } else if (state.Timestamp) {
+      const dateTimestamp = new Date(state.Timestamp);
+      const currentTime = Date.now();
+      const timeDiff = dateTimestamp.getTime() - currentTime;
+      await sleep(timeDiff, options?.abortSignal);
+    } else if (state.SecondsPath) {
+      const seconds = jsonPathQuery(state.SecondsPath, input, context);
+      await sleep(seconds * 1e3, options?.abortSignal);
+    } else if (state.TimestampPath) {
+      const timestamp = jsonPathQuery(state.TimestampPath, input, context);
+      const dateTimestamp = new Date(timestamp);
+      const currentTime = Date.now();
+      const timeDiff = dateTimestamp.getTime() - currentTime;
+      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
+import cloneDeep2 from "lodash/cloneDeep.js";
+var DEFAULT_MAX_ATTEMPTS = 3;
+var DEFAULT_INTERVAL_SECONDS = 1;
+var DEFAULT_BACKOFF_RATE = 2;
+var WILDCARD_ERROR = "States.ALL";
+var TASK_STATE_WILDCARD_ERROR = "States.TaskFailed";
+var StateExecutor = class {
+  constructor(stateName, stateDefinition) {
+    this.stateName = stateName;
+    this.stateDefinition = stateDefinition;
+    this.retrierAttempts = "Retry" in this.stateDefinition ? new Array(this.stateDefinition.Retry.length).fill(0) : [];
+    this.stateHandlers = {
+      Task: this.executeTaskState,
+      Parallel: this.executeParallelState,
+      Map: this.executeMapState,
+      Pass: this.executePassState,
+      Wait: this.executeWaitState,
+      Choice: this.executeChoiceState,
+      Succeed: this.executeSucceedState,
+      Fail: this.executeFailState
+    };
+  }
+  /**
+   * Execute the current state.
+   */
+  async execute(input, context, options) {
+    const rawInput = cloneDeep2(input);
+    try {
+      const processedInput = this.processInput(input, context);
+      const {
+        stateResult: currResult,
+        nextState,
+        isEndState
+      } = 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,
+        processedInput,
+        context,
+        this.stateName,
+        options
+      );
+      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);
+        return this.execute(input, context, options);
+      }
+      const { nextState, errorOutput, resultPath } = this.catchError(error);
+      if (nextState && errorOutput) {
+        return { stateResult: processResultPath(resultPath, rawInput, errorOutput), nextState, isEndState: false };
+      }
+      throw error;
+    }
+  }
+  /**
+   * Process the current input according to the `InputPath` and `Parameters` fields.
+   */
+  processInput(input, context) {
+    let processedInput = input;
+    if ("InputPath" in this.stateDefinition) {
+      processedInput = processInputPath(this.stateDefinition.InputPath, processedInput, context);
+    }
+    if ("Parameters" in this.stateDefinition && this.stateDefinition.Type !== "Map") {
+      processedInput = processPayloadTemplate(this.stateDefinition.Parameters, processedInput, context);
+    }
+    return processedInput;
+  }
+  /**
+   * Process the current result according to the `ResultSelector`, `ResultPath` and `OutputPath` fields.
+   */
+  processResult(result, rawInput, context) {
+    let processedResult = result;
+    if ("ResultSelector" in this.stateDefinition) {
+      processedResult = processPayloadTemplate(this.stateDefinition.ResultSelector, processedResult, context);
+    }
+    if ("ResultPath" in this.stateDefinition) {
+      processedResult = processResultPath(this.stateDefinition.ResultPath, rawInput, processedResult);
+    }
+    if ("OutputPath" in this.stateDefinition) {
+      processedResult = processOutputPath(this.stateDefinition.OutputPath, processedResult, context);
+    }
+    return processedResult;
+  }
+  /**
+   * Decide whether this state should be retried, according to the `Retry` field.
+   */
+  shouldRetry(error) {
+    if (!("Retry" in this.stateDefinition)) {
+      return { shouldRetry: false };
+    }
+    for (let i = 0; i < this.stateDefinition.Retry.length; i++) {
+      const retrier = this.stateDefinition.Retry[i];
+      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 retryable = error.isRetryable ?? true;
+      for (const retrierError of retrier.ErrorEquals) {
+        const isErrorMatch = retrierError === error.name;
+        const isErrorWildcard = retrierError === WILDCARD_ERROR;
+        const isErrorTaskWildcard = retrierError === TASK_STATE_WILDCARD_ERROR && this.stateDefinition.Type === "Task" && !(error instanceof StatesTimeoutError);
+        const maybeShouldRetry = retryable && (isErrorMatch || isErrorWildcard || isErrorTaskWildcard);
+        if (maybeShouldRetry) {
+          if (this.retrierAttempts[i] >= maxAttempts)
+            return { shouldRetry: false };
+          this.retrierAttempts[i]++;
+          return { shouldRetry: true, waitTimeBeforeRetry };
+        }
+      }
+    }
+    return { shouldRetry: false };
+  }
+  /**
+   * Try to match the current error with a catcher, according to the `Catch` field.
+   */
+  catchError(error) {
+    if (!("Catch" in this.stateDefinition)) {
+      return { nextState: "" };
+    }
+    for (let i = 0; i < this.stateDefinition.Catch.length; i++) {
+      const catcher = this.stateDefinition.Catch[i];
+      const catchable = error.isCatchable ?? true;
+      for (const catcherError of catcher.ErrorEquals) {
+        const isErrorMatch = catcherError === error.name;
+        const isErrorWildcard = catcherError === WILDCARD_ERROR;
+        const isErrorTaskWildcard = catcherError === TASK_STATE_WILDCARD_ERROR && this.stateDefinition.Type === "Task" && !(error instanceof StatesTimeoutError);
+        const shouldCatch = catchable && (isErrorMatch || isErrorWildcard || isErrorTaskWildcard);
+        if (shouldCatch) {
+          const nextState = catcher.Next;
+          const errorOutput = {
+            Error: error.name,
+            Cause: error.message
+          };
+          const resultPath = catcher.ResultPath;
+          return { nextState, errorOutput, resultPath };
+        }
+      }
+    }
+    return { nextState: "" };
+  }
+  /**
+   * Handler for task states.
+   *
+   * 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) {
+    const overrideFn = options.runOptions?.overrides?.taskResourceLocalHandlers?.[stateName];
+    const awsConfig = options.stateMachineOptions?.awsConfig;
+    const taskStateAction = new TaskStateAction(stateDefinition);
+    const executionResult = await taskStateAction.execute(input, context, { overrideFn, awsConfig });
+    return executionResult;
+  }
+  /**
+   * Handler for parallel states.
+   *
+   * 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);
+    const executionResult = await parallelStateAction.execute(input, context, {
+      stateMachineOptions: options.stateMachineOptions,
+      runOptions: options.runOptions
+    });
+    return executionResult;
+  }
+  /**
+   * Handler for map states.
+   *
+   * Iterates over the current input items or the items of an array specified
+   * 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);
+    const executionResult = await mapStateAction.execute(input, context, {
+      stateMachineOptions: options.stateMachineOptions,
+      runOptions: options.runOptions
+    });
+    return executionResult;
+  }
+  /**
+   * Handler for pass states.
+   *
+   * 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);
+    const executionResult = await passStateAction.execute(input, context);
+    return executionResult;
+  }
+  /**
+   * Handler for wait states.
+   *
+   * 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) {
+    const waitTimeOverrideOption = options.runOptions?.overrides?.waitTimeOverrides?.[stateName];
+    const abortSignal = options.abortSignal;
+    const waitStateAction = new WaitStateAction(stateDefinition);
+    const executionResult = await waitStateAction.execute(input, context, {
+      waitTimeOverrideOption,
+      abortSignal
+    });
+    return executionResult;
+  }
+  /**
+   * Handler for choice states.
+   *
+   * Evaluates each choice rule specified in the `Choices` field.
+   *
+   * If one of the rules matches, then the state machine transitions to the
+   * state specified in the `Next` field for that choice rule.
+   *
+   * If no rule matches but the `Default` field is specified,
+   * then the next state will be the state specified in said field.
+   *
+   * 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);
+    const executionResult = await choiceStateAction.execute(input, context);
+    return executionResult;
+  }
+  /**
+   * Handler for succeed states.
+   *
+   * Ends the state machine execution successfully.
+   */
+  async executeSucceedState(stateDefinition, input, context, stateName, options) {
+    const succeedStateAction = new SucceedStateAction(stateDefinition);
+    const executionResult = await succeedStateAction.execute(input, context);
+    return executionResult;
+  }
+  /**
+   * Handler for fail states.
+   *
+   * Ends the state machine execution and marks it as a failure.
+   */
+  async executeFailState(stateDefinition, input, context, stateName, options) {
+    const failStateAction = new FailStateAction(stateDefinition);
+    const executionResult = await failStateAction.execute(input, context);
+    return executionResult;
+  }
+};
+
+// src/stateMachine/StateMachine.ts
+import aslValidator from "asl-validator";
+import cloneDeep3 from "lodash/cloneDeep.js";
+var StateMachine = class {
+  /**
+   * Constructs a new state machine.
+   * @param definition The state machine definition defined using the Amazon States Language (https://states-language.net/spec.html).
+   * @param stateMachineOptions Options to control certain settings of the state machine.
+   * 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) {
+    const { isValid, errorsText } = aslValidator(definition, {
+      checkArn: true,
+      checkPaths: true,
+      ...stateMachineOptions?.validationOptions
+    });
+    if (!isValid) {
+      throw new Error(`State machine definition is invalid, see error(s) below:
+ ${errorsText("\n")}`);
+    }
+    this.definition = definition;
+    this.stateMachineOptions = stateMachineOptions;
+  }
+  /**
+   * Executes the state machine, running through the states specified in the definition.
+   * If the execution fails, the result will throw an `ExecutionError` explaining why the
+   * execution failed.
+   *
+   * 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`.
+   *
+   * @param input The input to pass to this state machine execution.
+   * @param options Miscellaneous options to control certain behaviors of the execution.
+   */
+  run(input, options) {
+    const abortController = new AbortController();
+    const settleOnAbort = new Promise((resolve, reject) => {
+      if (options?.noThrowOnAbort) {
+        abortController.signal.addEventListener("abort", () => resolve(null));
+      } else {
+        abortController.signal.addEventListener("abort", () => reject(new ExecutionAbortedError()));
+      }
+    });
+    const executionResult = this.execute(input, {
+      stateMachineOptions: this.stateMachineOptions,
+      runOptions: options,
+      abortSignal: abortController.signal
+    });
+    const result = Promise.race([executionResult, settleOnAbort]);
+    return {
+      abort: () => abortController.abort(),
+      result
+    };
+  }
+  /**
+   * Helper method that handles the execution of the machine states and the transitions between them.
+   */
+  async execute(input, options) {
+    let currState = this.definition.States[this.definition.StartAt];
+    let currStateName = this.definition.StartAt;
+    let currInput = cloneDeep3(input);
+    let currResult = null;
+    let nextState = "";
+    let isEndState = false;
+    let context = {};
+    try {
+      do {
+        const stateExecutor = new StateExecutor(currStateName, currState);
+        ({ stateResult: currResult, nextState, isEndState } = await stateExecutor.execute(currInput, context, options));
+        currInput = currResult;
+        currState = this.definition.States[nextState];
+        currStateName = nextState;
+      } while (!isEndState && !options.abortSignal.aborted);
+    } catch (error) {
+      throw new ExecutionError(error);
+    }
+    return currResult;
+  }
+};
+export {
+  ExecutionAbortedError,
+  ExecutionError,
+  StateMachine
+};