@upstash/workflow 0.1.2 → 0.1.3-crpyto-canary-2

package/astro.js

@@ -0,0 +1,2139 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// platforms/astro.ts
+var astro_exports = {};
+__export(astro_exports, {
+  serve: () => serve2
+});
+module.exports = __toCommonJS(astro_exports);
+
+// src/error.ts
+var import_qstash = require("@upstash/qstash");
+var QStashWorkflowError = class extends import_qstash.QstashError {
+  constructor(message) {
+    super(message);
+    this.name = "QStashWorkflowError";
+  }
+};
+var QStashWorkflowAbort = class extends Error {
+  stepInfo;
+  stepName;
+  constructor(stepName, stepInfo) {
+    super(
+      `This is an Upstash Workflow error thrown after a step executes. It is expected to be raised. Make sure that you await for each step. Also, if you are using try/catch blocks, you should not wrap context.run/sleep/sleepUntil/call methods with try/catch. Aborting workflow after executing step '${stepName}'.`
+    );
+    this.name = "QStashWorkflowAbort";
+    this.stepName = stepName;
+    this.stepInfo = stepInfo;
+  }
+};
+var formatWorkflowError = (error) => {
+  return error instanceof Error ? {
+    error: error.name,
+    message: error.message
+  } : {
+    error: "Error",
+    message: "An error occured while executing workflow."
+  };
+};
+
+// node_modules/neverthrow/dist/index.es.js
+var defaultErrorConfig = {
+  withStackTrace: false
+};
+var createNeverThrowError = (message, result, config = defaultErrorConfig) => {
+  const data = result.isOk() ? { type: "Ok", value: result.value } : { type: "Err", value: result.error };
+  const maybeStack = config.withStackTrace ? new Error().stack : void 0;
+  return {
+    data,
+    message,
+    stack: maybeStack
+  };
+};
+function __awaiter(thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function(resolve) {
+      resolve(value);
+    });
+  }
+  return new (P || (P = Promise))(function(resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+    step((generator = generator.apply(thisArg, [])).next());
+  });
+}
+function __values(o) {
+  var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+  if (m) return m.call(o);
+  if (o && typeof o.length === "number") return {
+    next: function() {
+      if (o && i >= o.length) o = void 0;
+      return { value: o && o[i++], done: !o };
+    }
+  };
+  throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+function __await(v) {
+  return this instanceof __await ? (this.v = v, this) : new __await(v);
+}
+function __asyncGenerator(thisArg, _arguments, generator) {
+  if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+  var g = generator.apply(thisArg, _arguments || []), i, q = [];
+  return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() {
+    return this;
+  }, i;
+  function verb(n) {
+    if (g[n]) i[n] = function(v) {
+      return new Promise(function(a, b) {
+        q.push([n, v, a, b]) > 1 || resume(n, v);
+      });
+    };
+  }
+  function resume(n, v) {
+    try {
+      step(g[n](v));
+    } catch (e) {
+      settle(q[0][3], e);
+    }
+  }
+  function step(r) {
+    r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r);
+  }
+  function fulfill(value) {
+    resume("next", value);
+  }
+  function reject(value) {
+    resume("throw", value);
+  }
+  function settle(f, v) {
+    if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]);
+  }
+}
+function __asyncDelegator(o) {
+  var i, p;
+  return i = {}, verb("next"), verb("throw", function(e) {
+    throw e;
+  }), verb("return"), i[Symbol.iterator] = function() {
+    return this;
+  }, i;
+  function verb(n, f) {
+    i[n] = o[n] ? function(v) {
+      return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v;
+    } : f;
+  }
+}
+function __asyncValues(o) {
+  if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+  var m = o[Symbol.asyncIterator], i;
+  return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() {
+    return this;
+  }, i);
+  function verb(n) {
+    i[n] = o[n] && function(v) {
+      return new Promise(function(resolve, reject) {
+        v = o[n](v), settle(resolve, reject, v.done, v.value);
+      });
+    };
+  }
+  function settle(resolve, reject, d, v) {
+    Promise.resolve(v).then(function(v2) {
+      resolve({ value: v2, done: d });
+    }, reject);
+  }
+}
+var ResultAsync = class _ResultAsync {
+  constructor(res) {
+    this._promise = res;
+  }
+  static fromSafePromise(promise) {
+    const newPromise = promise.then((value) => new Ok(value));
+    return new _ResultAsync(newPromise);
+  }
+  static fromPromise(promise, errorFn) {
+    const newPromise = promise.then((value) => new Ok(value)).catch((e) => new Err(errorFn(e)));
+    return new _ResultAsync(newPromise);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  static fromThrowable(fn, errorFn) {
+    return (...args) => {
+      return new _ResultAsync((() => __awaiter(this, void 0, void 0, function* () {
+        try {
+          return new Ok(yield fn(...args));
+        } catch (error) {
+          return new Err(errorFn ? errorFn(error) : error);
+        }
+      }))());
+    };
+  }
+  static combine(asyncResultList) {
+    return combineResultAsyncList(asyncResultList);
+  }
+  static combineWithAllErrors(asyncResultList) {
+    return combineResultAsyncListWithAllErrors(asyncResultList);
+  }
+  map(f) {
+    return new _ResultAsync(this._promise.then((res) => __awaiter(this, void 0, void 0, function* () {
+      if (res.isErr()) {
+        return new Err(res.error);
+      }
+      return new Ok(yield f(res.value));
+    })));
+  }
+  andThrough(f) {
+    return new _ResultAsync(this._promise.then((res) => __awaiter(this, void 0, void 0, function* () {
+      if (res.isErr()) {
+        return new Err(res.error);
+      }
+      const newRes = yield f(res.value);
+      if (newRes.isErr()) {
+        return new Err(newRes.error);
+      }
+      return new Ok(res.value);
+    })));
+  }
+  andTee(f) {
+    return new _ResultAsync(this._promise.then((res) => __awaiter(this, void 0, void 0, function* () {
+      if (res.isErr()) {
+        return new Err(res.error);
+      }
+      try {
+        yield f(res.value);
+      } catch (e) {
+      }
+      return new Ok(res.value);
+    })));
+  }
+  mapErr(f) {
+    return new _ResultAsync(this._promise.then((res) => __awaiter(this, void 0, void 0, function* () {
+      if (res.isOk()) {
+        return new Ok(res.value);
+      }
+      return new Err(yield f(res.error));
+    })));
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+  andThen(f) {
+    return new _ResultAsync(this._promise.then((res) => {
+      if (res.isErr()) {
+        return new Err(res.error);
+      }
+      const newValue = f(res.value);
+      return newValue instanceof _ResultAsync ? newValue._promise : newValue;
+    }));
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+  orElse(f) {
+    return new _ResultAsync(this._promise.then((res) => __awaiter(this, void 0, void 0, function* () {
+      if (res.isErr()) {
+        return f(res.error);
+      }
+      return new Ok(res.value);
+    })));
+  }
+  match(ok2, _err) {
+    return this._promise.then((res) => res.match(ok2, _err));
+  }
+  unwrapOr(t) {
+    return this._promise.then((res) => res.unwrapOr(t));
+  }
+  /**
+   * Emulates Rust's `?` operator in `safeTry`'s body. See also `safeTry`.
+   */
+  safeUnwrap() {
+    return __asyncGenerator(this, arguments, function* safeUnwrap_1() {
+      return yield __await(yield __await(yield* __asyncDelegator(__asyncValues(yield __await(this._promise.then((res) => res.safeUnwrap()))))));
+    });
+  }
+  // Makes ResultAsync implement PromiseLike<Result>
+  then(successCallback, failureCallback) {
+    return this._promise.then(successCallback, failureCallback);
+  }
+};
+var errAsync = (err2) => new ResultAsync(Promise.resolve(new Err(err2)));
+var fromPromise = ResultAsync.fromPromise;
+var fromSafePromise = ResultAsync.fromSafePromise;
+var fromAsyncThrowable = ResultAsync.fromThrowable;
+var combineResultList = (resultList) => {
+  let acc = ok([]);
+  for (const result of resultList) {
+    if (result.isErr()) {
+      acc = err(result.error);
+      break;
+    } else {
+      acc.map((list) => list.push(result.value));
+    }
+  }
+  return acc;
+};
+var combineResultAsyncList = (asyncResultList) => ResultAsync.fromSafePromise(Promise.all(asyncResultList)).andThen(combineResultList);
+var combineResultListWithAllErrors = (resultList) => {
+  let acc = ok([]);
+  for (const result of resultList) {
+    if (result.isErr() && acc.isErr()) {
+      acc.error.push(result.error);
+    } else if (result.isErr() && acc.isOk()) {
+      acc = err([result.error]);
+    } else if (result.isOk() && acc.isOk()) {
+      acc.value.push(result.value);
+    }
+  }
+  return acc;
+};
+var combineResultAsyncListWithAllErrors = (asyncResultList) => ResultAsync.fromSafePromise(Promise.all(asyncResultList)).andThen(combineResultListWithAllErrors);
+var Result;
+(function(Result2) {
+  function fromThrowable2(fn, errorFn) {
+    return (...args) => {
+      try {
+        const result = fn(...args);
+        return ok(result);
+      } catch (e) {
+        return err(errorFn ? errorFn(e) : e);
+      }
+    };
+  }
+  Result2.fromThrowable = fromThrowable2;
+  function combine(resultList) {
+    return combineResultList(resultList);
+  }
+  Result2.combine = combine;
+  function combineWithAllErrors(resultList) {
+    return combineResultListWithAllErrors(resultList);
+  }
+  Result2.combineWithAllErrors = combineWithAllErrors;
+})(Result || (Result = {}));
+var ok = (value) => new Ok(value);
+function err(err2) {
+  return new Err(err2);
+}
+var Ok = class {
+  constructor(value) {
+    this.value = value;
+  }
+  isOk() {
+    return true;
+  }
+  isErr() {
+    return !this.isOk();
+  }
+  map(f) {
+    return ok(f(this.value));
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  mapErr(_f) {
+    return ok(this.value);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+  andThen(f) {
+    return f(this.value);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+  andThrough(f) {
+    return f(this.value).map((_value) => this.value);
+  }
+  andTee(f) {
+    try {
+      f(this.value);
+    } catch (e) {
+    }
+    return ok(this.value);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+  orElse(_f) {
+    return ok(this.value);
+  }
+  asyncAndThen(f) {
+    return f(this.value);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+  asyncAndThrough(f) {
+    return f(this.value).map(() => this.value);
+  }
+  asyncMap(f) {
+    return ResultAsync.fromSafePromise(f(this.value));
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  unwrapOr(_v) {
+    return this.value;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  match(ok2, _err) {
+    return ok2(this.value);
+  }
+  safeUnwrap() {
+    const value = this.value;
+    return function* () {
+      return value;
+    }();
+  }
+  _unsafeUnwrap(_) {
+    return this.value;
+  }
+  _unsafeUnwrapErr(config) {
+    throw createNeverThrowError("Called `_unsafeUnwrapErr` on an Ok", this, config);
+  }
+};
+var Err = class {
+  constructor(error) {
+    this.error = error;
+  }
+  isOk() {
+    return false;
+  }
+  isErr() {
+    return !this.isOk();
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  map(_f) {
+    return err(this.error);
+  }
+  mapErr(f) {
+    return err(f(this.error));
+  }
+  andThrough(_f) {
+    return err(this.error);
+  }
+  andTee(_f) {
+    return err(this.error);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+  andThen(_f) {
+    return err(this.error);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+  orElse(f) {
+    return f(this.error);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  asyncAndThen(_f) {
+    return errAsync(this.error);
+  }
+  asyncAndThrough(_f) {
+    return errAsync(this.error);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  asyncMap(_f) {
+    return errAsync(this.error);
+  }
+  unwrapOr(v) {
+    return v;
+  }
+  match(_ok, err2) {
+    return err2(this.error);
+  }
+  safeUnwrap() {
+    const error = this.error;
+    return function* () {
+      yield err(error);
+      throw new Error("Do not use this generator out of `safeTry`");
+    }();
+  }
+  _unsafeUnwrap(config) {
+    throw createNeverThrowError("Called `_unsafeUnwrap` on an Err", this, config);
+  }
+  _unsafeUnwrapErr(_) {
+    return this.error;
+  }
+};
+var fromThrowable = Result.fromThrowable;
+
+// src/constants.ts
+var WORKFLOW_ID_HEADER = "Upstash-Workflow-RunId";
+var WORKFLOW_INIT_HEADER = "Upstash-Workflow-Init";
+var WORKFLOW_URL_HEADER = "Upstash-Workflow-Url";
+var WORKFLOW_FAILURE_HEADER = "Upstash-Workflow-Is-Failure";
+var WORKFLOW_FEATURE_HEADER = "Upstash-Feature-Set";
+var WORKFLOW_PROTOCOL_VERSION = "1";
+var WORKFLOW_PROTOCOL_VERSION_HEADER = "Upstash-Workflow-Sdk-Version";
+var DEFAULT_CONTENT_TYPE = "application/json";
+var NO_CONCURRENCY = 1;
+var DEFAULT_RETRIES = 3;
+
+// src/types.ts
+var StepTypes = [
+  "Initial",
+  "Run",
+  "SleepFor",
+  "SleepUntil",
+  "Call",
+  "Wait",
+  "Notify"
+];
+
+// src/workflow-requests.ts
+var triggerFirstInvocation = async (workflowContext, retries, debug) => {
+  const { headers } = getHeaders(
+    "true",
+    workflowContext.workflowRunId,
+    workflowContext.url,
+    workflowContext.headers,
+    void 0,
+    workflowContext.failureUrl,
+    retries
+  );
+  await debug?.log("SUBMIT", "SUBMIT_FIRST_INVOCATION", {
+    headers,
+    requestPayload: workflowContext.requestPayload,
+    url: workflowContext.url
+  });
+  try {
+    await workflowContext.qstashClient.publishJSON({
+      headers,
+      method: "POST",
+      body: workflowContext.requestPayload,
+      url: workflowContext.url
+    });
+    return ok("success");
+  } catch (error) {
+    const error_ = error;
+    return err(error_);
+  }
+};
+var triggerRouteFunction = async ({
+  onCleanup,
+  onStep
+}) => {
+  try {
+    await onStep();
+    await onCleanup();
+    return ok("workflow-finished");
+  } catch (error) {
+    const error_ = error;
+    return error_ instanceof QStashWorkflowAbort ? ok("step-finished") : err(error_);
+  }
+};
+var triggerWorkflowDelete = async (workflowContext, debug, cancel = false) => {
+  await debug?.log("SUBMIT", "SUBMIT_CLEANUP", {
+    deletedWorkflowRunId: workflowContext.workflowRunId
+  });
+  const result = await workflowContext.qstashClient.http.request({
+    path: ["v2", "workflows", "runs", `${workflowContext.workflowRunId}?cancel=${cancel}`],
+    method: "DELETE",
+    parseResponseAsJson: false
+  });
+  await debug?.log("SUBMIT", "SUBMIT_CLEANUP", result);
+};
+var recreateUserHeaders = (headers) => {
+  const filteredHeaders = new Headers();
+  const pairs = headers.entries();
+  for (const [header, value] of pairs) {
+    const headerLowerCase = header.toLowerCase();
+    if (!headerLowerCase.startsWith("upstash-workflow-") && !headerLowerCase.startsWith("x-vercel-") && !headerLowerCase.startsWith("x-forwarded-") && headerLowerCase !== "cf-connecting-ip") {
+      filteredHeaders.append(header, value);
+    }
+  }
+  return filteredHeaders;
+};
+var handleThirdPartyCallResult = async (request, requestPayload, client, workflowUrl, failureUrl, retries, debug) => {
+  try {
+    if (request.headers.get("Upstash-Workflow-Callback")) {
+      const callbackMessage = JSON.parse(requestPayload);
+      if (!(callbackMessage.status >= 200 && callbackMessage.status < 300) && callbackMessage.maxRetries && callbackMessage.retried !== callbackMessage.maxRetries) {
+        await debug?.log("WARN", "SUBMIT_THIRD_PARTY_RESULT", {
+          status: callbackMessage.status,
+          body: atob(callbackMessage.body)
+        });
+        console.warn(
+          `Workflow Warning: "context.call" failed with status ${callbackMessage.status} and will retry (retried ${callbackMessage.retried ?? 0} out of ${callbackMessage.maxRetries} times). Error Message:
+${atob(callbackMessage.body)}`
+        );
+        return ok("call-will-retry");
+      }
+      const workflowRunId = request.headers.get(WORKFLOW_ID_HEADER);
+      const stepIdString = request.headers.get("Upstash-Workflow-StepId");
+      const stepName = request.headers.get("Upstash-Workflow-StepName");
+      const stepType = request.headers.get("Upstash-Workflow-StepType");
+      const concurrentString = request.headers.get("Upstash-Workflow-Concurrent");
+      const contentType = request.headers.get("Upstash-Workflow-ContentType");
+      if (!(workflowRunId && stepIdString && stepName && StepTypes.includes(stepType) && concurrentString && contentType)) {
+        throw new Error(
+          `Missing info in callback message source header: ${JSON.stringify({
+            workflowRunId,
+            stepIdString,
+            stepName,
+            stepType,
+            concurrentString,
+            contentType
+          })}`
+        );
+      }
+      const userHeaders = recreateUserHeaders(request.headers);
+      const { headers: requestHeaders } = getHeaders(
+        "false",
+        workflowRunId,
+        workflowUrl,
+        userHeaders,
+        void 0,
+        failureUrl,
+        retries
+      );
+      const callResponse = {
+        status: callbackMessage.status,
+        body: atob(callbackMessage.body),
+        header: callbackMessage.header
+      };
+      const callResultStep = {
+        stepId: Number(stepIdString),
+        stepName,
+        stepType,
+        out: JSON.stringify(callResponse),
+        concurrent: Number(concurrentString)
+      };
+      await debug?.log("SUBMIT", "SUBMIT_THIRD_PARTY_RESULT", {
+        step: callResultStep,
+        headers: requestHeaders,
+        url: workflowUrl
+      });
+      const result = await client.publishJSON({
+        headers: requestHeaders,
+        method: "POST",
+        body: callResultStep,
+        url: workflowUrl
+      });
+      await debug?.log("SUBMIT", "SUBMIT_THIRD_PARTY_RESULT", {
+        messageId: result.messageId
+      });
+      return ok("is-call-return");
+    } else {
+      return ok("continue-workflow");
+    }
+  } catch (error) {
+    const isCallReturn = request.headers.get("Upstash-Workflow-Callback");
+    return err(
+      new QStashWorkflowError(
+        `Error when handling call return (isCallReturn=${isCallReturn}): ${error}`
+      )
+    );
+  }
+};
+var getHeaders = (initHeaderValue, workflowRunId, workflowUrl, userHeaders, step, failureUrl, retries) => {
+  const baseHeaders = {
+    [WORKFLOW_INIT_HEADER]: initHeaderValue,
+    [WORKFLOW_ID_HEADER]: workflowRunId,
+    [WORKFLOW_URL_HEADER]: workflowUrl
+  };
+  if (!step?.callUrl) {
+    baseHeaders[`Upstash-Forward-${WORKFLOW_PROTOCOL_VERSION_HEADER}`] = WORKFLOW_PROTOCOL_VERSION;
+  }
+  if (failureUrl) {
+    if (!step?.callUrl) {
+      baseHeaders[`Upstash-Failure-Callback-Forward-${WORKFLOW_FAILURE_HEADER}`] = "true";
+    }
+    baseHeaders["Upstash-Failure-Callback"] = failureUrl;
+  }
+  if (step?.callUrl) {
+    baseHeaders["Upstash-Retries"] = "0";
+    baseHeaders[WORKFLOW_FEATURE_HEADER] = "WF_NoDelete";
+    if (retries) {
+      baseHeaders["Upstash-Callback-Retries"] = retries.toString();
+      baseHeaders["Upstash-Failure-Callback-Retries"] = retries.toString();
+    }
+  } else if (retries !== void 0) {
+    baseHeaders["Upstash-Retries"] = retries.toString();
+  }
+  if (userHeaders) {
+    for (const header of userHeaders.keys()) {
+      if (step?.callHeaders) {
+        baseHeaders[`Upstash-Callback-Forward-${header}`] = userHeaders.get(header);
+      } else {
+        baseHeaders[`Upstash-Forward-${header}`] = userHeaders.get(header);
+      }
+    }
+  }
+  const contentType = (userHeaders ? userHeaders.get("Content-Type") : void 0) ?? DEFAULT_CONTENT_TYPE;
+  if (step?.callHeaders) {
+    const forwardedHeaders = Object.fromEntries(
+      Object.entries(step.callHeaders).map(([header, value]) => [
+        `Upstash-Forward-${header}`,
+        value
+      ])
+    );
+    return {
+      headers: {
+        ...baseHeaders,
+        ...forwardedHeaders,
+        "Upstash-Callback": workflowUrl,
+        "Upstash-Callback-Workflow-RunId": workflowRunId,
+        "Upstash-Callback-Workflow-CallType": "fromCallback",
+        "Upstash-Callback-Workflow-Init": "false",
+        "Upstash-Callback-Workflow-Url": workflowUrl,
+        "Upstash-Callback-Forward-Upstash-Workflow-Callback": "true",
+        "Upstash-Callback-Forward-Upstash-Workflow-StepId": step.stepId.toString(),
+        "Upstash-Callback-Forward-Upstash-Workflow-StepName": step.stepName,
+        "Upstash-Callback-Forward-Upstash-Workflow-StepType": step.stepType,
+        "Upstash-Callback-Forward-Upstash-Workflow-Concurrent": step.concurrent.toString(),
+        "Upstash-Callback-Forward-Upstash-Workflow-ContentType": contentType,
+        "Upstash-Workflow-CallType": "toCallback"
+      }
+    };
+  }
+  if (step?.waitEventId) {
+    return {
+      headers: {
+        ...baseHeaders,
+        "Upstash-Workflow-CallType": "step"
+      },
+      timeoutHeaders: {
+        // to include user headers:
+        ...Object.fromEntries(
+          Object.entries(baseHeaders).map(([header, value]) => [header, [value]])
+        ),
+        // note: using WORKFLOW_ID_HEADER doesn't work, because Runid -> RunId:
+        "Upstash-Workflow-Runid": [workflowRunId],
+        [WORKFLOW_INIT_HEADER]: ["false"],
+        [WORKFLOW_URL_HEADER]: [workflowUrl],
+        "Upstash-Workflow-CallType": ["step"],
+        "Content-Type": [contentType]
+      }
+    };
+  }
+  return { headers: baseHeaders };
+};
+var verifyRequest = async (body, signature, verifier) => {
+  if (!verifier) {
+    return;
+  }
+  try {
+    if (!signature) {
+      throw new Error("`Upstash-Signature` header is not passed.");
+    }
+    const isValid = await verifier.verify({
+      body,
+      signature
+    });
+    if (!isValid) {
+      throw new Error("Signature in `Upstash-Signature` header is not valid");
+    }
+  } catch (error) {
+    throw new QStashWorkflowError(
+      `Failed to verify that the Workflow request comes from QStash: ${error}
+
+If signature is missing, trigger the workflow endpoint by publishing your request to QStash instead of calling it directly.
+
+If you want to disable QStash Verification, you should clear env variables QSTASH_CURRENT_SIGNING_KEY and QSTASH_NEXT_SIGNING_KEY`
+    );
+  }
+};
+
+// src/context/auto-executor.ts
+var AutoExecutor = class _AutoExecutor {
+  context;
+  promises = /* @__PURE__ */ new WeakMap();
+  activeLazyStepList;
+  debug;
+  nonPlanStepCount;
+  steps;
+  indexInCurrentList = 0;
+  stepCount = 0;
+  planStepCount = 0;
+  executingStep = false;
+  constructor(context, steps, debug) {
+    this.context = context;
+    this.debug = debug;
+    this.steps = steps;
+    this.nonPlanStepCount = this.steps.filter((step) => !step.targetStep).length;
+  }
+  /**
+   * Adds the step function to the list of step functions to run in
+   * parallel. After adding the function, defers the execution, so
+   * that if there is another step function to be added, it's also
+   * added.
+   *
+   * After all functions are added, list of functions are executed.
+   * If there is a single function, it's executed by itself. If there
+   * are multiple, they are run in parallel.
+   *
+   * If a function is already executing (this.executingStep), this
+   * means that there is a nested step which is not allowed. In this
+   * case, addStep throws QStashWorkflowError.
+   *
+   * @param stepInfo step plan to add
+   * @returns result of the step function
+   */
+  async addStep(stepInfo) {
+    if (this.executingStep) {
+      throw new QStashWorkflowError(
+        `A step can not be run inside another step. Tried to run '${stepInfo.stepName}' inside '${this.executingStep}'`
+      );
+    }
+    this.stepCount += 1;
+    const lazyStepList = this.activeLazyStepList ?? [];
+    if (!this.activeLazyStepList) {
+      this.activeLazyStepList = lazyStepList;
+      this.indexInCurrentList = 0;
+    }
+    lazyStepList.push(stepInfo);
+    const index = this.indexInCurrentList++;
+    const requestComplete = this.deferExecution().then(async () => {
+      if (!this.promises.has(lazyStepList)) {
+        const promise2 = this.getExecutionPromise(lazyStepList);
+        this.promises.set(lazyStepList, promise2);
+        this.activeLazyStepList = void 0;
+        this.planStepCount += lazyStepList.length > 1 ? lazyStepList.length : 0;
+      }
+      const promise = this.promises.get(lazyStepList);
+      return promise;
+    });
+    const result = await requestComplete;
+    return _AutoExecutor.getResult(lazyStepList, result, index);
+  }
+  /**
+   * Wraps a step function to set this.executingStep to step name
+   * before running and set this.executingStep to False after execution
+   * ends.
+   *
+   * this.executingStep allows us to detect nested steps which are not
+   * allowed.
+   *
+   * @param stepName name of the step being wrapped
+   * @param stepFunction step function to wrap
+   * @returns wrapped step function
+   */
+  wrapStep(stepName, stepFunction) {
+    this.executingStep = stepName;
+    const result = stepFunction();
+    this.executingStep = false;
+    return result;
+  }
+  /**
+   * Executes a step:
+   * - If the step result is available in the steps, returns the result
+   * - If the result is not avaiable, runs the function
+   * - Sends the result to QStash
+   *
+   * @param lazyStep lazy step to execute
+   * @returns step result
+   */
+  async runSingle(lazyStep) {
+    if (this.stepCount < this.nonPlanStepCount) {
+      const step = this.steps[this.stepCount + this.planStepCount];
+      validateStep(lazyStep, step);
+      await this.debug?.log("INFO", "RUN_SINGLE", {
+        fromRequest: true,
+        step,
+        stepCount: this.stepCount
+      });
+      return step.out;
+    }
+    const resultStep = await lazyStep.getResultStep(NO_CONCURRENCY, this.stepCount);
+    await this.debug?.log("INFO", "RUN_SINGLE", {
+      fromRequest: false,
+      step: resultStep,
+      stepCount: this.stepCount
+    });
+    await this.submitStepsToQStash([resultStep]);
+    return resultStep.out;
+  }
+  /**
+   * Runs steps in parallel.
+   *
+   * @param stepName parallel step name
+   * @param stepFunctions list of async functions to run in parallel
+   * @returns results of the functions run in parallel
+   */
+  async runParallel(parallelSteps) {
+    const initialStepCount = this.stepCount - (parallelSteps.length - 1);
+    const parallelCallState = this.getParallelCallState(parallelSteps.length, initialStepCount);
+    const sortedSteps = sortSteps(this.steps);
+    const plannedParallelStepCount = sortedSteps[initialStepCount + this.planStepCount]?.concurrent;
+    if (parallelCallState !== "first" && plannedParallelStepCount !== parallelSteps.length) {
+      throw new QStashWorkflowError(
+        `Incompatible number of parallel steps when call state was '${parallelCallState}'. Expected ${parallelSteps.length}, got ${plannedParallelStepCount} from the request.`
+      );
+    }
+    await this.debug?.log("INFO", "RUN_PARALLEL", {
+      parallelCallState,
+      initialStepCount,
+      plannedParallelStepCount,
+      stepCount: this.stepCount,
+      planStepCount: this.planStepCount
+    });
+    switch (parallelCallState) {
+      case "first": {
+        const planSteps = parallelSteps.map(
+          (parallelStep, index) => parallelStep.getPlanStep(parallelSteps.length, initialStepCount + index)
+        );
+        await this.submitStepsToQStash(planSteps);
+        break;
+      }
+      case "partial": {
+        const planStep = this.steps.at(-1);
+        if (!planStep || planStep.targetStep === void 0) {
+          throw new QStashWorkflowError(
+            `There must be a last step and it should have targetStep larger than 0.Received: ${JSON.stringify(planStep)}`
+          );
+        }
+        const stepIndex = planStep.targetStep - initialStepCount;
+        validateStep(parallelSteps[stepIndex], planStep);
+        try {
+          const resultStep = await parallelSteps[stepIndex].getResultStep(
+            parallelSteps.length,
+            planStep.targetStep
+          );
+          await this.submitStepsToQStash([resultStep]);
+        } catch (error) {
+          if (error instanceof QStashWorkflowAbort) {
+            throw error;
+          }
+          throw new QStashWorkflowError(
+            `Error submitting steps to QStash in partial parallel step execution: ${error}`
+          );
+        }
+        break;
+      }
+      case "discard": {
+        throw new QStashWorkflowAbort("discarded parallel");
+      }
+      case "last": {
+        const parallelResultSteps = sortedSteps.filter((step) => step.stepId >= initialStepCount).slice(0, parallelSteps.length);
+        validateParallelSteps(parallelSteps, parallelResultSteps);
+        return parallelResultSteps.map((step) => step.out);
+      }
+    }
+    const fillValue = void 0;
+    return Array.from({ length: parallelSteps.length }).fill(fillValue);
+  }
+  /**
+   * Determines the parallel call state
+   *
+   * First filters the steps to get the steps which are after `initialStepCount` parameter.
+   *
+   * Depending on the remaining steps, decides the parallel state:
+   * - "first": If there are no steps
+   * - "last" If there are equal to or more than `2 * parallelStepCount`. We multiply by two
+   *   because each step in a parallel execution will have 2 steps: a plan step and a result
+   *   step.
+   * - "partial": If the last step is a plan step
+   * - "discard": If the last step is not a plan step. This means that the parallel execution
+   *   is in progress (there are still steps to run) and one step has finished and submitted
+   *   its result to QStash
+   *
+   * @param parallelStepCount number of steps to run in parallel
+   * @param initialStepCount steps after the parallel invocation
+   * @returns parallel call state
+   */
+  getParallelCallState(parallelStepCount, initialStepCount) {
+    const remainingSteps = this.steps.filter(
+      (step) => (step.targetStep || step.stepId) >= initialStepCount
+    );
+    if (remainingSteps.length === 0) {
+      return "first";
+    } else if (remainingSteps.length >= 2 * parallelStepCount) {
+      return "last";
+    } else if (remainingSteps.at(-1)?.targetStep) {
+      return "partial";
+    } else {
+      return "discard";
+    }
+  }
+  /**
+   * sends the steps to QStash as batch
+   *
+   * @param steps steps to send
+   */
+  async submitStepsToQStash(steps) {
+    if (steps.length === 0) {
+      throw new QStashWorkflowError(
+        `Unable to submit steps to QStash. Provided list is empty. Current step: ${this.stepCount}`
+      );
+    }
+    await this.debug?.log("SUBMIT", "SUBMIT_STEP", {
+      length: steps.length,
+      steps
+    });
+    if (steps[0].waitEventId && steps.length === 1) {
+      const waitStep = steps[0];
+      const { headers, timeoutHeaders } = getHeaders(
+        "false",
+        this.context.workflowRunId,
+        this.context.url,
+        this.context.headers,
+        waitStep,
+        this.context.failureUrl,
+        this.context.retries
+      );
+      const waitBody = {
+        url: this.context.url,
+        timeout: waitStep.timeout,
+        timeoutBody: void 0,
+        timeoutUrl: this.context.url,
+        timeoutHeaders,
+        step: {
+          stepId: waitStep.stepId,
+          stepType: "Wait",
+          stepName: waitStep.stepName,
+          concurrent: waitStep.concurrent,
+          targetStep: waitStep.targetStep
+        }
+      };
+      await this.context.qstashClient.http.request({
+        path: ["v2", "wait", waitStep.waitEventId],
+        body: JSON.stringify(waitBody),
+        headers,
+        method: "POST",
+        parseResponseAsJson: false
+      });
+      throw new QStashWorkflowAbort(steps[0].stepName, steps[0]);
+    }
+    const result = await this.context.qstashClient.batchJSON(
+      steps.map((singleStep) => {
+        const { headers } = getHeaders(
+          "false",
+          this.context.workflowRunId,
+          this.context.url,
+          this.context.headers,
+          singleStep,
+          this.context.failureUrl,
+          this.context.retries
+        );
+        const willWait = singleStep.concurrent === NO_CONCURRENCY || singleStep.stepId === 0;
+        singleStep.out = JSON.stringify(singleStep.out);
+        return singleStep.callUrl ? (
+          // if the step is a third party call, we call the third party
+          // url (singleStep.callUrl) and pass information about the workflow
+          // in the headers (handled in getHeaders). QStash makes the request
+          // to callUrl and returns the result to Workflow endpoint.
+          // handleThirdPartyCallResult method sends the result of the third
+          // party call to QStash.
+          {
+            headers,
+            method: singleStep.callMethod,
+            body: singleStep.callBody,
+            url: singleStep.callUrl
+          }
+        ) : (
+          // if the step is not a third party call, we use workflow
+          // endpoint (context.url) as URL when calling QStash. QStash
+          // calls us back with the updated steps list.
+          {
+            headers,
+            method: "POST",
+            body: singleStep,
+            url: this.context.url,
+            notBefore: willWait ? singleStep.sleepUntil : void 0,
+            delay: willWait ? singleStep.sleepFor : void 0
+          }
+        );
+      })
+    );
+    await this.debug?.log("INFO", "SUBMIT_STEP", {
+      messageIds: result.map((message) => {
+        return {
+          message: message.messageId
+        };
+      })
+    });
+    throw new QStashWorkflowAbort(steps[0].stepName, steps[0]);
+  }
+  /**
+   * Get the promise by executing the lazt steps list. If there is a single
+   * step, we call `runSingle`. Otherwise `runParallel` is called.
+   *
+   * @param lazyStepList steps list to execute
+   * @returns promise corresponding to the execution
+   */
+  getExecutionPromise(lazyStepList) {
+    return lazyStepList.length === 1 ? this.runSingle(lazyStepList[0]) : this.runParallel(lazyStepList);
+  }
+  /**
+   * @param lazyStepList steps we executed
+   * @param result result of the promise from `getExecutionPromise`
+   * @param index index of the current step
+   * @returns result[index] if lazyStepList > 1, otherwise result
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters
+  static getResult(lazyStepList, result, index) {
+    if (lazyStepList.length === 1) {
+      return result;
+    } else if (Array.isArray(result) && lazyStepList.length === result.length && index < lazyStepList.length) {
+      return result[index];
+    } else {
+      throw new QStashWorkflowError(
+        `Unexpected parallel call result while executing step ${index}: '${result}'. Expected ${lazyStepList.length} many items`
+      );
+    }
+  }
+  async deferExecution() {
+    await Promise.resolve();
+    await Promise.resolve();
+  }
+};
+var validateStep = (lazyStep, stepFromRequest) => {
+  if (lazyStep.stepName !== stepFromRequest.stepName) {
+    throw new QStashWorkflowError(
+      `Incompatible step name. Expected '${lazyStep.stepName}', got '${stepFromRequest.stepName}' from the request`
+    );
+  }
+  if (lazyStep.stepType !== stepFromRequest.stepType) {
+    throw new QStashWorkflowError(
+      `Incompatible step type. Expected '${lazyStep.stepType}', got '${stepFromRequest.stepType}' from the request`
+    );
+  }
+};
+var validateParallelSteps = (lazySteps, stepsFromRequest) => {
+  try {
+    for (const [index, stepFromRequest] of stepsFromRequest.entries()) {
+      validateStep(lazySteps[index], stepFromRequest);
+    }
+  } catch (error) {
+    if (error instanceof QStashWorkflowError) {
+      const lazyStepNames = lazySteps.map((lazyStep) => lazyStep.stepName);
+      const lazyStepTypes = lazySteps.map((lazyStep) => lazyStep.stepType);
+      const requestStepNames = stepsFromRequest.map((step) => step.stepName);
+      const requestStepTypes = stepsFromRequest.map((step) => step.stepType);
+      throw new QStashWorkflowError(
+        `Incompatible steps detected in parallel execution: ${error.message}
+  > Step Names from the request: ${JSON.stringify(requestStepNames)}
+    Step Types from the request: ${JSON.stringify(requestStepTypes)}
+  > Step Names expected: ${JSON.stringify(lazyStepNames)}
+    Step Types expected: ${JSON.stringify(lazyStepTypes)}`
+      );
+    }
+    throw error;
+  }
+};
+var sortSteps = (steps) => {
+  const getStepId = (step) => step.targetStep || step.stepId;
+  return [...steps].sort((step, stepOther) => getStepId(step) - getStepId(stepOther));
+};
+
+// src/client/utils.ts
+var makeNotifyRequest = async (requester, eventId, eventData) => {
+  const result = await requester.request({
+    path: ["v2", "notify", eventId],
+    method: "POST",
+    body: typeof eventData === "string" ? eventData : JSON.stringify(eventData)
+  });
+  return result;
+};
+
+// src/context/steps.ts
+var BaseLazyStep = class {
+  stepName;
+  // will be set in the subclasses
+  constructor(stepName) {
+    this.stepName = stepName;
+  }
+};
+var LazyFunctionStep = class extends BaseLazyStep {
+  stepFunction;
+  stepType = "Run";
+  constructor(stepName, stepFunction) {
+    super(stepName);
+    this.stepFunction = stepFunction;
+  }
+  getPlanStep(concurrent, targetStep) {
+    return {
+      stepId: 0,
+      stepName: this.stepName,
+      stepType: this.stepType,
+      concurrent,
+      targetStep
+    };
+  }
+  async getResultStep(concurrent, stepId) {
+    let result = this.stepFunction();
+    if (result instanceof Promise) {
+      result = await result;
+    }
+    return {
+      stepId,
+      stepName: this.stepName,
+      stepType: this.stepType,
+      out: result,
+      concurrent
+    };
+  }
+};
+var LazySleepStep = class extends BaseLazyStep {
+  sleep;
+  stepType = "SleepFor";
+  constructor(stepName, sleep) {
+    super(stepName);
+    this.sleep = sleep;
+  }
+  getPlanStep(concurrent, targetStep) {
+    return {
+      stepId: 0,
+      stepName: this.stepName,
+      stepType: this.stepType,
+      sleepFor: this.sleep,
+      concurrent,
+      targetStep
+    };
+  }
+  async getResultStep(concurrent, stepId) {
+    return await Promise.resolve({
+      stepId,
+      stepName: this.stepName,
+      stepType: this.stepType,
+      sleepFor: this.sleep,
+      concurrent
+    });
+  }
+};
+var LazySleepUntilStep = class extends BaseLazyStep {
+  sleepUntil;
+  stepType = "SleepUntil";
+  constructor(stepName, sleepUntil) {
+    super(stepName);
+    this.sleepUntil = sleepUntil;
+  }
+  getPlanStep(concurrent, targetStep) {
+    return {
+      stepId: 0,
+      stepName: this.stepName,
+      stepType: this.stepType,
+      sleepUntil: this.sleepUntil,
+      concurrent,
+      targetStep
+    };
+  }
+  async getResultStep(concurrent, stepId) {
+    return await Promise.resolve({
+      stepId,
+      stepName: this.stepName,
+      stepType: this.stepType,
+      sleepUntil: this.sleepUntil,
+      concurrent
+    });
+  }
+};
+var LazyCallStep = class extends BaseLazyStep {
+  url;
+  method;
+  body;
+  headers;
+  stepType = "Call";
+  constructor(stepName, url, method, body, headers) {
+    super(stepName);
+    this.url = url;
+    this.method = method;
+    this.body = body;
+    this.headers = headers;
+  }
+  getPlanStep(concurrent, targetStep) {
+    return {
+      stepId: 0,
+      stepName: this.stepName,
+      stepType: this.stepType,
+      concurrent,
+      targetStep
+    };
+  }
+  async getResultStep(concurrent, stepId) {
+    return await Promise.resolve({
+      stepId,
+      stepName: this.stepName,
+      stepType: this.stepType,
+      concurrent,
+      callUrl: this.url,
+      callMethod: this.method,
+      callBody: this.body,
+      callHeaders: this.headers
+    });
+  }
+};
+var LazyWaitForEventStep = class extends BaseLazyStep {
+  eventId;
+  timeout;
+  stepType = "Wait";
+  constructor(stepName, eventId, timeout) {
+    super(stepName);
+    this.eventId = eventId;
+    this.timeout = timeout;
+  }
+  getPlanStep(concurrent, targetStep) {
+    return {
+      stepId: 0,
+      stepName: this.stepName,
+      stepType: this.stepType,
+      waitEventId: this.eventId,
+      timeout: this.timeout,
+      concurrent,
+      targetStep
+    };
+  }
+  async getResultStep(concurrent, stepId) {
+    return await Promise.resolve({
+      stepId,
+      stepName: this.stepName,
+      stepType: this.stepType,
+      waitEventId: this.eventId,
+      timeout: this.timeout,
+      concurrent
+    });
+  }
+};
+var LazyNotifyStep = class extends LazyFunctionStep {
+  stepType = "Notify";
+  constructor(stepName, eventId, eventData, requester) {
+    super(stepName, async () => {
+      const notifyResponse = await makeNotifyRequest(requester, eventId, eventData);
+      return {
+        eventId,
+        eventData,
+        notifyResponse
+      };
+    });
+  }
+};
+
+// src/context/context.ts
+var WorkflowContext = class {
+  executor;
+  steps;
+  /**
+   * QStash client of the workflow
+   *
+   * Can be overwritten by passing `qstashClient` parameter in `serve`:
+   *
+   * ```ts
+   * import { Client } from "@upstash/qstash"
+   *
+   * export const POST = serve(
+   *   async (context) => {
+   *     ...
+   *   },
+   *   {
+   *     qstashClient: new Client({...})
+   *   }
+   * )
+   * ```
+   */
+  qstashClient;
+  /**
+   * Run id of the workflow
+   */
+  workflowRunId;
+  /**
+   * URL of the workflow
+   *
+   * Can be overwritten by passing a `url` parameter in `serve`:
+   *
+   * ```ts
+   * export const POST = serve(
+   *   async (context) => {
+   *     ...
+   *   },
+   *   {
+   *     url: "new-url-value"
+   *   }
+   * )
+   * ```
+   */
+  url;
+  /**
+   * URL to call in case of workflow failure with QStash failure callback
+   *
+   * https://upstash.com/docs/qstash/features/callbacks#what-is-a-failure-callback
+   *
+   * Can be overwritten by passing a `failureUrl` parameter in `serve`:
+   *
+   * ```ts
+   * export const POST = serve(
+   *   async (context) => {
+   *     ...
+   *   },
+   *   {
+   *     failureUrl: "new-url-value"
+   *   }
+   * )
+   * ```
+   */
+  failureUrl;
+  /**
+   * Payload of the request which started the workflow.
+   *
+   * To specify its type, you can define `serve` as follows:
+   *
+   * ```ts
+   * // set requestPayload type to MyPayload:
+   * export const POST = serve<MyPayload>(
+   *   async (context) => {
+   *     ...
+   *   }
+   * )
+   * ```
+   *
+   * By default, `serve` tries to apply `JSON.parse` to the request payload.
+   * If your payload is encoded in a format other than JSON, you can utilize
+   * the `initialPayloadParser` parameter:
+   *
+   * ```ts
+   * export const POST = serve<MyPayload>(
+   *   async (context) => {
+   *     ...
+   *   },
+   *   {
+   *     initialPayloadParser: (initialPayload) => {return doSomething(initialPayload)}
+   *   }
+   * )
+   * ```
+   */
+  requestPayload;
+  /**
+   * headers of the initial request
+   */
+  headers;
+  /**
+   * initial payload as a raw string
+   */
+  rawInitialPayload;
+  /**
+   * Map of environment variables and their values.
+   *
+   * Can be set using the `env` option of serve:
+   *
+   * ```ts
+   * export const POST = serve<MyPayload>(
+   *   async (context) => {
+   *     const key = context.env["API_KEY"];
+   *   },
+   *   {
+   *     env: {
+   *       "API_KEY": "*****";
+   *     }
+   *   }
+   * )
+   * ```
+   *
+   * Default value is set to `process.env`.
+   */
+  env;
+  /**
+   * Number of retries
+   */
+  retries;
+  constructor({
+    qstashClient,
+    workflowRunId,
+    headers,
+    steps,
+    url,
+    failureUrl,
+    debug,
+    initialPayload,
+    rawInitialPayload,
+    env,
+    retries
+  }) {
+    this.qstashClient = qstashClient;
+    this.workflowRunId = workflowRunId;
+    this.steps = steps;
+    this.url = url;
+    this.failureUrl = failureUrl;
+    this.headers = headers;
+    this.requestPayload = initialPayload;
+    this.rawInitialPayload = rawInitialPayload ?? JSON.stringify(this.requestPayload);
+    this.env = env ?? {};
+    this.retries = retries ?? DEFAULT_RETRIES;
+    this.executor = new AutoExecutor(this, this.steps, debug);
+  }
+  /**
+   * Executes a workflow step
+   *
+   * ```typescript
+   * const result = await context.run("step 1", () => {
+   *   return "result"
+   * })
+   * ```
+   *
+   * Can also be called in parallel and the steps will be executed
+   * simulatenously:
+   *
+   * ```typescript
+   * const [result1, result2] = await Promise.all([
+   *   context.run("step 1", () => {
+   *     return "result1"
+   *   })
+   *   context.run("step 2", async () => {
+   *     return await fetchResults()
+   *   })
+   * ])
+   * ```
+   *
+   * @param stepName name of the step
+   * @param stepFunction step function to be executed
+   * @returns result of the step function
+   */
+  async run(stepName, stepFunction) {
+    const wrappedStepFunction = () => this.executor.wrapStep(stepName, stepFunction);
+    return this.addStep(new LazyFunctionStep(stepName, wrappedStepFunction));
+  }
+  /**
+   * Stops the execution for the duration provided.
+   *
+   * @param stepName
+   * @param duration sleep duration in seconds
+   * @returns undefined
+   */
+  async sleep(stepName, duration) {
+    await this.addStep(new LazySleepStep(stepName, duration));
+  }
+  /**
+   * Stops the execution until the date time provided.
+   *
+   * @param stepName
+   * @param datetime time to sleep until. Can be provided as a number (in unix seconds),
+   *   as a Date object or a string (passed to `new Date(datetimeString)`)
+   * @returns undefined
+   */
+  async sleepUntil(stepName, datetime) {
+    let time;
+    if (typeof datetime === "number") {
+      time = datetime;
+    } else {
+      datetime = typeof datetime === "string" ? new Date(datetime) : datetime;
+      time = Math.round(datetime.getTime() / 1e3);
+    }
+    await this.addStep(new LazySleepUntilStep(stepName, time));
+  }
+  /**
+   * Makes a third party call through QStash in order to make a
+   * network call without consuming any runtime.
+   *
+   * ```ts
+   * const postResult = await context.call<string>(
+   *   "post call step",
+   *   `https://www.some-endpoint.com/api`,
+   *   "POST",
+   *   "my-payload"
+   * );
+   * ```
+   *
+   * tries to parse the result of the request as JSON. If it's
+   * not a JSON which can be parsed, simply returns the response
+   * body as it is.
+   *
+   * @param stepName
+   * @param url url to call
+   * @param method call method
+   * @param body call body
+   * @param headers call headers
+   * @returns call result as {
+   *     status: number;
+   *     body: unknown;
+   *     header: Record<string, string[]>
+   *   }
+   */
+  async call(stepName, settings) {
+    const { url, method = "GET", body, headers = {} } = settings;
+    const result = await this.addStep(
+      new LazyCallStep(stepName, url, method, body, headers ?? {})
+    );
+    if (typeof result === "string") {
+      try {
+        const body2 = JSON.parse(result);
+        return {
+          status: 200,
+          header: {},
+          body: body2
+        };
+      } catch {
+        return {
+          status: 200,
+          header: {},
+          body: result
+        };
+      }
+    }
+    try {
+      return {
+        ...result,
+        body: JSON.parse(result.body)
+      };
+    } catch {
+      return result;
+    }
+  }
+  /**
+   * Makes the workflow run wait until a notify request is sent or until the
+   * timeout ends
+   *
+   * ```ts
+   * const { eventData, timeout } = await context.waitForEvent(
+   *   "wait for event step",
+   *   "my-event-id",
+   *   100 // timeout after 100 seconds
+   * );
+   * ```
+   *
+   * To notify a waiting workflow run, you can use the notify method:
+   *
+   * ```ts
+   * import { Client } from "@upstash/workflow";
+   *
+   * const client = new Client({ token: });
+   *
+   * await client.notify({
+   *   eventId: "my-event-id",
+   *   eventData: "eventData"
+   * })
+   * ```
+   *
+   * @param stepName
+   * @param eventId event id to wake up the waiting workflow run
+   * @param timeout timeout duration in seconds
+   * @returns wait response as `{ timeout: boolean, eventData: unknown }`.
+   *   timeout is true if the wait times out, if notified it is false. eventData
+   *   is the value passed to `client.notify`.
+   */
+  async waitForEvent(stepName, eventId, timeout) {
+    const result = await this.addStep(
+      new LazyWaitForEventStep(
+        stepName,
+        eventId,
+        typeof timeout === "string" ? timeout : `${timeout}s`
+      )
+    );
+    try {
+      return {
+        ...result,
+        eventData: JSON.parse(result.eventData)
+      };
+    } catch {
+      return result;
+    }
+  }
+  async notify(stepName, eventId, eventData) {
+    const result = await this.addStep(
+      new LazyNotifyStep(stepName, eventId, eventData, this.qstashClient.http)
+    );
+    try {
+      return {
+        ...result,
+        eventData: JSON.parse(result.eventData)
+      };
+    } catch {
+      return result;
+    }
+  }
+  /**
+   * Adds steps to the executor. Needed so that it can be overwritten in
+   * DisabledWorkflowContext.
+   */
+  async addStep(step) {
+    return await this.executor.addStep(step);
+  }
+};
+
+// src/logger.ts
+var LOG_LEVELS = ["DEBUG", "INFO", "SUBMIT", "WARN", "ERROR"];
+var WorkflowLogger = class _WorkflowLogger {
+  logs = [];
+  options;
+  workflowRunId = void 0;
+  constructor(options) {
+    this.options = options;
+  }
+  async log(level, eventType, details) {
+    if (this.shouldLog(level)) {
+      const timestamp = Date.now();
+      const logEntry = {
+        timestamp,
+        workflowRunId: this.workflowRunId ?? "",
+        logLevel: level,
+        eventType,
+        details
+      };
+      this.logs.push(logEntry);
+      if (this.options.logOutput === "console") {
+        this.writeToConsole(logEntry);
+      }
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+  }
+  setWorkflowRunId(workflowRunId) {
+    this.workflowRunId = workflowRunId;
+  }
+  writeToConsole(logEntry) {
+    const JSON_SPACING = 2;
+    console.log(JSON.stringify(logEntry, void 0, JSON_SPACING));
+  }
+  shouldLog(level) {
+    return LOG_LEVELS.indexOf(level) >= LOG_LEVELS.indexOf(this.options.logLevel);
+  }
+  static getLogger(verbose) {
+    if (typeof verbose === "object") {
+      return verbose;
+    } else {
+      return verbose ? new _WorkflowLogger({
+        logLevel: "INFO",
+        logOutput: "console"
+      }) : void 0;
+    }
+  }
+};
+
+// src/utils.ts
+var import_crypto = __toESM(require("crypto"));
+var NANOID_CHARS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_";
+var NANOID_LENGTH = 21;
+function nanoid() {
+  return [...import_crypto.default.getRandomValues(new Uint8Array(NANOID_LENGTH))].map((x) => NANOID_CHARS[x % NANOID_CHARS.length]).join("");
+}
+function decodeBase64(base64) {
+  try {
+    const binString = atob(base64);
+    const intArray = Uint8Array.from(binString, (m) => m.codePointAt(0));
+    return new TextDecoder().decode(intArray);
+  } catch (error) {
+    console.warn(
+      `Upstash Qstash: Failed while decoding base64 "${base64}". Decoding with atob and returning it instead. ${error}`
+    );
+    return atob(base64);
+  }
+}
+
+// src/workflow-parser.ts
+var getPayload = async (request) => {
+  try {
+    return await request.text();
+  } catch {
+    return;
+  }
+};
+var parsePayload = async (rawPayload, debug) => {
+  const [encodedInitialPayload, ...encodedSteps] = JSON.parse(rawPayload);
+  const rawInitialPayload = decodeBase64(encodedInitialPayload.body);
+  const initialStep = {
+    stepId: 0,
+    stepName: "init",
+    stepType: "Initial",
+    out: rawInitialPayload,
+    concurrent: NO_CONCURRENCY
+  };
+  const stepsToDecode = encodedSteps.filter((step) => step.callType === "step");
+  const otherSteps = await Promise.all(
+    stepsToDecode.map(async (rawStep) => {
+      const step = JSON.parse(decodeBase64(rawStep.body));
+      try {
+        step.out = JSON.parse(step.out);
+      } catch {
+        await debug?.log("WARN", "ENDPOINT_START", {
+          message: "failed while parsing out field of step",
+          step
+        });
+      }
+      if (step.waitEventId) {
+        const newOut = {
+          eventData: step.out ? decodeBase64(step.out) : void 0,
+          timeout: step.waitTimeout ?? false
+        };
+        step.out = newOut;
+      }
+      return step;
+    })
+  );
+  const steps = [initialStep, ...otherSteps];
+  return {
+    rawInitialPayload,
+    steps
+  };
+};
+var deduplicateSteps = (steps) => {
+  const targetStepIds = [];
+  const stepIds = [];
+  const deduplicatedSteps = [];
+  for (const step of steps) {
+    if (step.stepId === 0) {
+      if (!targetStepIds.includes(step.targetStep ?? 0)) {
+        deduplicatedSteps.push(step);
+        targetStepIds.push(step.targetStep ?? 0);
+      }
+    } else {
+      if (!stepIds.includes(step.stepId)) {
+        deduplicatedSteps.push(step);
+        stepIds.push(step.stepId);
+      }
+    }
+  }
+  return deduplicatedSteps;
+};
+var checkIfLastOneIsDuplicate = async (steps, debug) => {
+  if (steps.length < 2) {
+    return false;
+  }
+  const lastStep = steps.at(-1);
+  const lastStepId = lastStep.stepId;
+  const lastTargetStepId = lastStep.targetStep;
+  for (let index = 0; index < steps.length - 1; index++) {
+    const step = steps[index];
+    if (step.stepId === lastStepId && step.targetStep === lastTargetStepId) {
+      const message = `Upstash Workflow: The step '${step.stepName}' with id '${step.stepId}'  has run twice during workflow execution. Rest of the workflow will continue running as usual.`;
+      await debug?.log("WARN", "RESPONSE_DEFAULT", message);
+      console.warn(message);
+      return true;
+    }
+  }
+  return false;
+};
+var validateRequest = (request) => {
+  const versionHeader = request.headers.get(WORKFLOW_PROTOCOL_VERSION_HEADER);
+  const isFirstInvocation = !versionHeader;
+  if (!isFirstInvocation && versionHeader !== WORKFLOW_PROTOCOL_VERSION) {
+    throw new QStashWorkflowError(
+      `Incompatible workflow sdk protocol version. Expected ${WORKFLOW_PROTOCOL_VERSION}, got ${versionHeader} from the request.`
+    );
+  }
+  const workflowRunId = isFirstInvocation ? `wfr_${nanoid()}` : request.headers.get(WORKFLOW_ID_HEADER) ?? "";
+  if (workflowRunId.length === 0) {
+    throw new QStashWorkflowError("Couldn't get workflow id from header");
+  }
+  return {
+    isFirstInvocation,
+    workflowRunId
+  };
+};
+var parseRequest = async (requestPayload, isFirstInvocation, debug) => {
+  if (isFirstInvocation) {
+    return {
+      rawInitialPayload: requestPayload ?? "",
+      steps: [],
+      isLastDuplicate: false
+    };
+  } else {
+    if (!requestPayload) {
+      throw new QStashWorkflowError("Only first call can have an empty body");
+    }
+    const { rawInitialPayload, steps } = await parsePayload(requestPayload, debug);
+    const isLastDuplicate = await checkIfLastOneIsDuplicate(steps, debug);
+    const deduplicatedSteps = deduplicateSteps(steps);
+    return {
+      rawInitialPayload,
+      steps: deduplicatedSteps,
+      isLastDuplicate
+    };
+  }
+};
+var handleFailure = async (request, requestPayload, qstashClient, initialPayloadParser, failureFunction, debug) => {
+  if (request.headers.get(WORKFLOW_FAILURE_HEADER) !== "true") {
+    return ok("not-failure-callback");
+  }
+  if (!failureFunction) {
+    return err(
+      new QStashWorkflowError(
+        "Workflow endpoint is called to handle a failure, but a failureFunction is not provided in serve options. Either provide a failureUrl or a failureFunction."
+      )
+    );
+  }
+  try {
+    const { status, header, body, url, sourceHeader, sourceBody, workflowRunId } = JSON.parse(
+      requestPayload
+    );
+    const decodedBody = body ? decodeBase64(body) : "{}";
+    const errorPayload = JSON.parse(decodedBody);
+    const {
+      rawInitialPayload,
+      steps,
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      isLastDuplicate: _isLastDuplicate
+    } = await parseRequest(decodeBase64(sourceBody), false, debug);
+    const workflowContext = new WorkflowContext({
+      qstashClient,
+      workflowRunId,
+      initialPayload: initialPayloadParser(rawInitialPayload),
+      rawInitialPayload,
+      headers: recreateUserHeaders(new Headers(sourceHeader)),
+      steps,
+      url,
+      failureUrl: url,
+      debug
+    });
+    await failureFunction(workflowContext, status, errorPayload.message, header);
+  } catch (error) {
+    return err(error);
+  }
+  return ok("is-failure-callback");
+};
+
+// src/serve/authorization.ts
+var import_qstash2 = require("@upstash/qstash");
+var DisabledWorkflowContext = class _DisabledWorkflowContext extends WorkflowContext {
+  static disabledMessage = "disabled-qstash-worklfow-run";
+  /**
+   * overwrite the WorkflowContext.addStep method to always raise QStashWorkflowAbort
+   * error in order to stop the execution whenever we encounter a step.
+   *
+   * @param _step
+   */
+  async addStep(_step) {
+    throw new QStashWorkflowAbort(_DisabledWorkflowContext.disabledMessage);
+  }
+  /**
+   * copies the passed context to create a DisabledWorkflowContext. Then, runs the
+   * route function with the new context.
+   *
+   * - returns "run-ended" if there are no steps found or
+   *      if the auth failed and user called `return`
+   * - returns "step-found" if DisabledWorkflowContext.addStep is called.
+   * - if there is another error, returns the error.
+   *
+   * @param routeFunction
+   */
+  static async tryAuthentication(routeFunction, context) {
+    const disabledContext = new _DisabledWorkflowContext({
+      qstashClient: new import_qstash2.Client({
+        baseUrl: "disabled-client",
+        token: "disabled-client"
+      }),
+      workflowRunId: context.workflowRunId,
+      headers: context.headers,
+      steps: [],
+      url: context.url,
+      failureUrl: context.failureUrl,
+      initialPayload: context.requestPayload,
+      rawInitialPayload: context.rawInitialPayload,
+      env: context.env,
+      retries: context.retries
+    });
+    try {
+      await routeFunction(disabledContext);
+    } catch (error) {
+      if (error instanceof QStashWorkflowAbort && error.stepName === this.disabledMessage) {
+        return ok("step-found");
+      }
+      return err(error);
+    }
+    return ok("run-ended");
+  }
+};
+
+// src/serve/options.ts
+var import_qstash3 = require("@upstash/qstash");
+var import_qstash4 = require("@upstash/qstash");
+var processOptions = (options) => {
+  const environment = options?.env ?? (typeof process === "undefined" ? {} : process.env);
+  const receiverEnvironmentVariablesSet = Boolean(
+    environment.QSTASH_CURRENT_SIGNING_KEY && environment.QSTASH_NEXT_SIGNING_KEY
+  );
+  return {
+    qstashClient: new import_qstash4.Client({
+      baseUrl: environment.QSTASH_URL,
+      token: environment.QSTASH_TOKEN
+    }),
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    onStepFinish: (workflowRunId, _finishCondition) => new Response(JSON.stringify({ workflowRunId }), {
+      status: 200
+    }),
+    initialPayloadParser: (initialRequest) => {
+      if (!initialRequest) {
+        return void 0;
+      }
+      try {
+        return JSON.parse(initialRequest);
+      } catch (error) {
+        if (error instanceof SyntaxError) {
+          return initialRequest;
+        }
+        throw error;
+      }
+    },
+    receiver: receiverEnvironmentVariablesSet ? new import_qstash3.Receiver({
+      currentSigningKey: environment.QSTASH_CURRENT_SIGNING_KEY,
+      nextSigningKey: environment.QSTASH_NEXT_SIGNING_KEY
+    }) : void 0,
+    baseUrl: environment.UPSTASH_WORKFLOW_URL,
+    env: environment,
+    retries: DEFAULT_RETRIES,
+    ...options
+  };
+};
+var determineUrls = async (request, url, baseUrl, failureFunction, failureUrl, debug) => {
+  const initialWorkflowUrl = url ?? request.url;
+  const workflowUrl = baseUrl ? initialWorkflowUrl.replace(/^(https?:\/\/[^/]+)(\/.*)?$/, (_, matchedBaseUrl, path) => {
+    return baseUrl + (path || "");
+  }) : initialWorkflowUrl;
+  if (workflowUrl !== initialWorkflowUrl) {
+    await debug?.log("WARN", "ENDPOINT_START", {
+      warning: `Upstash Workflow: replacing the base of the url with "${baseUrl}" and using it as workflow endpoint.`,
+      originalURL: initialWorkflowUrl,
+      updatedURL: workflowUrl
+    });
+  }
+  const workflowFailureUrl = failureFunction ? workflowUrl : failureUrl;
+  return {
+    workflowUrl,
+    workflowFailureUrl
+  };
+};
+
+// src/serve/index.ts
+var serve = (routeFunction, options) => {
+  const {
+    qstashClient,
+    onStepFinish,
+    initialPayloadParser,
+    url,
+    verbose,
+    receiver,
+    failureUrl,
+    failureFunction,
+    baseUrl,
+    env,
+    retries
+  } = processOptions(options);
+  const debug = WorkflowLogger.getLogger(verbose);
+  const handler = async (request) => {
+    await debug?.log("INFO", "ENDPOINT_START");
+    const { workflowUrl, workflowFailureUrl } = await determineUrls(
+      request,
+      url,
+      baseUrl,
+      failureFunction,
+      failureUrl,
+      debug
+    );
+    const requestPayload = await getPayload(request) ?? "";
+    await verifyRequest(requestPayload, request.headers.get("upstash-signature"), receiver);
+    const { isFirstInvocation, workflowRunId } = validateRequest(request);
+    debug?.setWorkflowRunId(workflowRunId);
+    const { rawInitialPayload, steps, isLastDuplicate } = await parseRequest(
+      requestPayload,
+      isFirstInvocation,
+      debug
+    );
+    if (isLastDuplicate) {
+      return onStepFinish("no-workflow-id", "duplicate-step");
+    }
+    const failureCheck = await handleFailure(
+      request,
+      requestPayload,
+      qstashClient,
+      initialPayloadParser,
+      failureFunction
+    );
+    if (failureCheck.isErr()) {
+      throw failureCheck.error;
+    } else if (failureCheck.value === "is-failure-callback") {
+      await debug?.log("WARN", "RESPONSE_DEFAULT", "failureFunction executed");
+      return onStepFinish("no-workflow-id", "failure-callback");
+    }
+    const workflowContext = new WorkflowContext({
+      qstashClient,
+      workflowRunId,
+      initialPayload: initialPayloadParser(rawInitialPayload),
+      rawInitialPayload,
+      headers: recreateUserHeaders(request.headers),
+      steps,
+      url: workflowUrl,
+      failureUrl: workflowFailureUrl,
+      debug,
+      env,
+      retries
+    });
+    const authCheck = await DisabledWorkflowContext.tryAuthentication(
+      routeFunction,
+      workflowContext
+    );
+    if (authCheck.isErr()) {
+      await debug?.log("ERROR", "ERROR", { error: authCheck.error.message });
+      throw authCheck.error;
+    } else if (authCheck.value === "run-ended") {
+      return onStepFinish("no-workflow-id", "auth-fail");
+    }
+    const callReturnCheck = await handleThirdPartyCallResult(
+      request,
+      rawInitialPayload,
+      qstashClient,
+      workflowUrl,
+      workflowFailureUrl,
+      retries,
+      debug
+    );
+    if (callReturnCheck.isErr()) {
+      await debug?.log("ERROR", "SUBMIT_THIRD_PARTY_RESULT", {
+        error: callReturnCheck.error.message
+      });
+      throw callReturnCheck.error;
+    } else if (callReturnCheck.value === "continue-workflow") {
+      const result = isFirstInvocation ? await triggerFirstInvocation(workflowContext, retries, debug) : await triggerRouteFunction({
+        onStep: async () => routeFunction(workflowContext),
+        onCleanup: async () => {
+          await triggerWorkflowDelete(workflowContext, debug);
+        }
+      });
+      if (result.isErr()) {
+        await debug?.log("ERROR", "ERROR", { error: result.error.message });
+        throw result.error;
+      }
+      await debug?.log("INFO", "RESPONSE_WORKFLOW");
+      return onStepFinish(workflowContext.workflowRunId, "success");
+    }
+    await debug?.log("INFO", "RESPONSE_DEFAULT");
+    return onStepFinish("no-workflow-id", "fromCallback");
+  };
+  const safeHandler = async (request) => {
+    try {
+      return await handler(request);
+    } catch (error) {
+      console.error(error);
+      return new Response(JSON.stringify(formatWorkflowError(error)), {
+        status: 500
+      });
+    }
+  };
+  return { handler: safeHandler };
+};
+
+// src/client/index.ts
+var import_qstash5 = require("@upstash/qstash");
+
+// platforms/astro.ts
+function serve2(routeFunction, options) {
+  const POST = (apiContext) => {
+    const { handler } = serve(
+      (workflowContext) => routeFunction(workflowContext, apiContext),
+      options
+    );
+    return handler(apiContext.request);
+  };
+  return { POST };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  serve
+});