@upstash/qstash 2.7.10 → 2.7.11-canary

package/chunk-KZOQ64Z6.js

@@ -1,2963 +0,0 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } async function _asyncNullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return await rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3; var _class4; var _class5; var _class6; var _class7; var _class8; var _class9;// src/receiver.ts
-var _jose = require('jose'); var jose = _interopRequireWildcard(_jose);
-var _cryptojs = require('crypto-js'); var _cryptojs2 = _interopRequireDefault(_cryptojs);
-var SignatureError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "SignatureError";
-  }
-};
-var Receiver = class {
-  
-  
-  constructor(config) {
-    this.currentSigningKey = config.currentSigningKey;
-    this.nextSigningKey = config.nextSigningKey;
-  }
-  /**
-   * Verify the signature of a request.
-   *
-   * Tries to verify the signature with the current signing key.
-   * If that fails, maybe because you have rotated the keys recently, it will
-   * try to verify the signature with the next signing key.
-   *
-   * If that fails, the signature is invalid and a `SignatureError` is thrown.
-   */
-  async verify(request) {
-    const isValid = await this.verifyWithKey(this.currentSigningKey, request);
-    if (isValid) {
-      return true;
-    }
-    return this.verifyWithKey(this.nextSigningKey, request);
-  }
-  /**
-   * Verify signature with a specific signing key
-   */
-  async verifyWithKey(key, request) {
-    const jwt = await jose.jwtVerify(request.signature, new TextEncoder().encode(key), {
-      issuer: "Upstash",
-      clockTolerance: request.clockTolerance
-    }).catch((error) => {
-      throw new SignatureError(error.message);
-    });
-    const p = jwt.payload;
-    if (request.url !== void 0 && p.sub !== request.url) {
-      throw new SignatureError(`invalid subject: ${p.sub}, want: ${request.url}`);
-    }
-    const bodyHash = _cryptojs2.default.SHA256(request.body).toString(_cryptojs2.default.enc.Base64url);
-    const padding = new RegExp(/=+$/);
-    if (p.body.replace(padding, "") !== bodyHash.replace(padding, "")) {
-      throw new SignatureError(`body hash does not match, want: ${p.body}, got: ${bodyHash}`);
-    }
-    return true;
-  }
-};
-
-// src/client/dlq.ts
-var DLQ = class {
-  
-  constructor(http) {
-    this.http = http;
-  }
-  /**
-   * List messages in the dlq
-   */
-  async listMessages(options) {
-    const filterPayload = {
-      ..._optionalChain([options, 'optionalAccess', _2 => _2.filter]),
-      topicName: _optionalChain([options, 'optionalAccess', _3 => _3.filter, 'optionalAccess', _4 => _4.urlGroup])
-    };
-    const messagesPayload = await this.http.request({
-      method: "GET",
-      path: ["v2", "dlq"],
-      query: {
-        cursor: _optionalChain([options, 'optionalAccess', _5 => _5.cursor]),
-        count: _optionalChain([options, 'optionalAccess', _6 => _6.count]),
-        ...filterPayload
-      }
-    });
-    return {
-      messages: messagesPayload.messages.map((message) => {
-        return {
-          ...message,
-          urlGroup: message.topicName
-        };
-      }),
-      cursor: messagesPayload.cursor
-    };
-  }
-  /**
-   * Remove a message from the dlq using it's `dlqId`
-   */
-  async delete(dlqMessageId) {
-    return await this.http.request({
-      method: "DELETE",
-      path: ["v2", "dlq", dlqMessageId],
-      parseResponseAsJson: false
-      // there is no response
-    });
-  }
-  /**
-   * Remove multiple messages from the dlq using their `dlqId`s
-   */
-  async deleteMany(request) {
-    return await this.http.request({
-      method: "DELETE",
-      path: ["v2", "dlq"],
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ dlqIds: request.dlqIds })
-    });
-  }
-};
-
-// src/client/error.ts
-var QstashError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "QstashError";
-  }
-};
-var QstashRatelimitError = class extends QstashError {
-  
-  
-  
-  constructor(args) {
-    super(`Exceeded burst rate limit. ${JSON.stringify(args)} `);
-    this.name = "QstashRatelimitError";
-    this.limit = args.limit;
-    this.remaining = args.remaining;
-    this.reset = args.reset;
-  }
-};
-var QstashChatRatelimitError = class extends QstashError {
-  
-  
-  
-  
-  
-  
-  constructor(args) {
-    super(`Exceeded chat rate limit. ${JSON.stringify(args)} `);
-    this.limitRequests = args["limit-requests"];
-    this.limitTokens = args["limit-tokens"];
-    this.remainingRequests = args["remaining-requests"];
-    this.remainingTokens = args["remaining-tokens"];
-    this.resetRequests = args["reset-requests"];
-    this.resetTokens = args["reset-tokens"];
-  }
-};
-var QstashDailyRatelimitError = class extends QstashError {
-  
-  
-  
-  constructor(args) {
-    super(`Exceeded daily rate limit. ${JSON.stringify(args)} `);
-    this.limit = args.limit;
-    this.remaining = args.remaining;
-    this.reset = args.reset;
-    this.name = "QstashChatRatelimitError";
-  }
-};
-var QStashWorkflowError = class extends QstashError {
-  constructor(message) {
-    super(message);
-    this.name = "QStashWorkflowError";
-  }
-};
-var QStashWorkflowAbort = class extends Error {
-  
-  
-  constructor(stepName, stepInfo) {
-    super(
-      `This is an QStash 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."
-  };
-};
-
-// src/client/http.ts
-var HttpClient = (_class = class {
-  
-  
-  
-  
-  constructor(config) {;_class.prototype.__init.call(this);_class.prototype.__init2.call(this);
-    this.baseUrl = config.baseUrl.replace(/\/$/, "");
-    this.authorization = config.authorization;
-    this.retry = // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-    typeof config.retry === "boolean" && !config.retry ? {
-      attempts: 1,
-      backoff: () => 0
-    } : {
-      attempts: _optionalChain([config, 'access', _7 => _7.retry, 'optionalAccess', _8 => _8.retries]) ? config.retry.retries + 1 : 5,
-      backoff: _nullishCoalesce(_optionalChain([config, 'access', _9 => _9.retry, 'optionalAccess', _10 => _10.backoff]), () => ( ((retryCount) => Math.exp(retryCount) * 50)))
-    };
-  }
-  async request(request) {
-    const { response } = await this.requestWithBackoff(request);
-    if (request.parseResponseAsJson === false) {
-      return void 0;
-    }
-    return await response.json();
-  }
-  async *requestStream(request) {
-    const { response } = await this.requestWithBackoff(request);
-    if (!response.body) {
-      throw new Error("No response body");
-    }
-    const body = response.body;
-    const reader = body.getReader();
-    const decoder = new TextDecoder();
-    try {
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done) {
-          break;
-        }
-        const chunkText = decoder.decode(value, { stream: true });
-        const chunks = chunkText.split("\n").filter(Boolean);
-        for (const chunk of chunks) {
-          if (chunk.startsWith("data: ")) {
-            const data = chunk.slice(6);
-            if (data === "[DONE]") {
-              break;
-            }
-            yield JSON.parse(data);
-          }
-        }
-      }
-    } finally {
-      await reader.cancel();
-    }
-  }
-  __init() {this.requestWithBackoff = async (request) => {
-    const [url, requestOptions] = this.processRequest(request);
-    let response = void 0;
-    let error = void 0;
-    for (let index = 0; index < this.retry.attempts; index++) {
-      try {
-        response = await fetch(url.toString(), requestOptions);
-        break;
-      } catch (error_) {
-        error = error_;
-        await new Promise((r) => setTimeout(r, this.retry.backoff(index)));
-      }
-    }
-    if (!response) {
-      throw _nullishCoalesce(error, () => ( new Error("Exhausted all retries")));
-    }
-    await this.checkResponse(response);
-    return {
-      response,
-      error
-    };
-  }}
-  __init2() {this.processRequest = (request) => {
-    const headers = new Headers(request.headers);
-    if (!headers.has("Authorization")) {
-      headers.set("Authorization", this.authorization);
-    }
-    const requestOptions = {
-      method: request.method,
-      headers,
-      body: request.body,
-      keepalive: request.keepalive
-    };
-    const url = new URL([_nullishCoalesce(request.baseUrl, () => ( this.baseUrl)), ...request.path].join("/"));
-    if (request.query) {
-      for (const [key, value] of Object.entries(request.query)) {
-        if (value !== void 0) {
-          url.searchParams.set(key, value.toString());
-        }
-      }
-    }
-    return [url.toString(), requestOptions];
-  }}
-  async checkResponse(response) {
-    if (response.status === 429) {
-      if (response.headers.get("x-ratelimit-limit-requests")) {
-        throw new QstashChatRatelimitError({
-          "limit-requests": response.headers.get("x-ratelimit-limit-requests"),
-          "limit-tokens": response.headers.get("x-ratelimit-limit-tokens"),
-          "remaining-requests": response.headers.get("x-ratelimit-remaining-requests"),
-          "remaining-tokens": response.headers.get("x-ratelimit-remaining-tokens"),
-          "reset-requests": response.headers.get("x-ratelimit-reset-requests"),
-          "reset-tokens": response.headers.get("x-ratelimit-reset-tokens")
-        });
-      } else if (response.headers.get("RateLimit-Limit")) {
-        throw new QstashDailyRatelimitError({
-          limit: response.headers.get("RateLimit-Limit"),
-          remaining: response.headers.get("RateLimit-Remaining"),
-          reset: response.headers.get("RateLimit-Reset")
-        });
-      }
-      throw new QstashRatelimitError({
-        limit: response.headers.get("Burst-RateLimit-Limit"),
-        remaining: response.headers.get("Burst-RateLimit-Remaining"),
-        reset: response.headers.get("Burst-RateLimit-Reset")
-      });
-    }
-    if (response.status < 200 || response.status >= 300) {
-      const body = await response.text();
-      throw new QstashError(body.length > 0 ? body : `Error: status=${response.status}`);
-    }
-  }
-}, _class);
-
-// src/client/llm/providers.ts
-var setupAnalytics = (analytics, providerApiKey, providerBaseUrl, provider) => {
-  if (!analytics)
-    return {};
-  switch (analytics.name) {
-    case "helicone": {
-      switch (provider) {
-        case "upstash": {
-          return {
-            baseURL: "https://qstash.helicone.ai/llm/v1/chat/completions",
-            defaultHeaders: {
-              "Helicone-Auth": `Bearer ${analytics.token}`,
-              Authorization: `Bearer ${providerApiKey}`
-            }
-          };
-        }
-        default: {
-          return {
-            baseURL: "https://gateway.helicone.ai/v1/chat/completions",
-            defaultHeaders: {
-              "Helicone-Auth": `Bearer ${analytics.token}`,
-              "Helicone-Target-Url": providerBaseUrl,
-              Authorization: `Bearer ${providerApiKey}`
-            }
-          };
-        }
-      }
-    }
-    default: {
-      throw new Error("Unknown analytics provider");
-    }
-  }
-};
-var upstash = () => {
-  return {
-    owner: "upstash",
-    baseUrl: "https://qstash.upstash.io/llm",
-    token: "",
-    organization: void 0
-  };
-};
-var openai = ({
-  token,
-  organization
-}) => {
-  return {
-    token,
-    owner: "openai",
-    baseUrl: "https://api.openai.com",
-    organization
-  };
-};
-var custom = ({
-  baseUrl,
-  token
-}) => {
-  const trimmedBaseUrl = baseUrl.replace(/\/(v1\/)?chat\/completions$/, "");
-  return {
-    token,
-    owner: "custom",
-    baseUrl: trimmedBaseUrl,
-    organization: void 0
-  };
-};
-
-// src/client/llm/chat.ts
-var Chat = (_class2 = class _Chat {
-  
-  
-  constructor(http, token) {;_class2.prototype.__init3.call(this);_class2.prototype.__init4.call(this);_class2.prototype.__init5.call(this);
-    this.http = http;
-    this.token = token;
-  }
-  static toChatRequest(request) {
-    const messages = [];
-    messages.push(
-      { role: "system", content: request.system },
-      { role: "user", content: request.user }
-    );
-    const chatRequest = { ...request, messages };
-    return chatRequest;
-  }
-  /**
-   * Calls the Upstash completions api given a ChatRequest.
-   *
-   * Returns a ChatCompletion or a stream of ChatCompletionChunks
-   * if stream is enabled.
-   *
-   * @param request ChatRequest with messages
-   * @returns Chat completion or stream
-   */
-  __init3() {this.create = async (request) => {
-    if (request.provider.owner != "upstash")
-      return this.createThirdParty(request);
-    const body = JSON.stringify(request);
-    let baseUrl = void 0;
-    let headers = {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${this.token}`,
-      ..."stream" in request && request.stream ? {
-        Connection: "keep-alive",
-        Accept: "text/event-stream",
-        "Cache-Control": "no-cache"
-      } : {}
-    };
-    if (request.analytics) {
-      const { baseURL, defaultHeaders } = setupAnalytics(
-        { name: "helicone", token: request.analytics.token },
-        this.getAuthorizationToken(),
-        request.provider.baseUrl,
-        "upstash"
-      );
-      headers = { ...headers, ...defaultHeaders };
-      baseUrl = baseURL;
-    }
-    const path = request.analytics ? [] : ["llm", "v1", "chat", "completions"];
-    return "stream" in request && request.stream ? this.http.requestStream({
-      path,
-      method: "POST",
-      headers,
-      baseUrl,
-      body
-    }) : this.http.request({
-      path,
-      method: "POST",
-      headers,
-      baseUrl,
-      body
-    });
-  }}
-  /**
-   * Calls the Upstash completions api given a ChatRequest.
-   *
-   * Returns a ChatCompletion or a stream of ChatCompletionChunks
-   * if stream is enabled.
-   *
-   * @param request ChatRequest with messages
-   * @returns Chat completion or stream
-   */
-  // eslint-disable-next-line @typescript-eslint/require-await
-  __init4() {this.createThirdParty = async (request) => {
-    const { baseUrl, token, owner, organization } = request.provider;
-    if (owner === "upstash")
-      throw new Error("Upstash is not 3rd party provider!");
-    delete request.provider;
-    delete request.system;
-    const analytics = request.analytics;
-    delete request.analytics;
-    const body = JSON.stringify(request);
-    const isAnalyticsEnabled = _optionalChain([analytics, 'optionalAccess', _13 => _13.name]) && analytics.token;
-    const analyticsConfig = _optionalChain([analytics, 'optionalAccess', _14 => _14.name]) && analytics.token ? setupAnalytics({ name: analytics.name, token: analytics.token }, token, baseUrl, owner) : { defaultHeaders: void 0, baseURL: baseUrl };
-    const isStream = "stream" in request && request.stream;
-    const headers = {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${token}`,
-      ...organization ? {
-        "OpenAI-Organization": organization
-      } : {},
-      ...isStream ? {
-        Connection: "keep-alive",
-        Accept: "text/event-stream",
-        "Cache-Control": "no-cache"
-      } : {},
-      ...analyticsConfig.defaultHeaders
-    };
-    const response = await this.http[isStream ? "requestStream" : "request"]({
-      path: isAnalyticsEnabled ? [] : ["v1", "chat", "completions"],
-      method: "POST",
-      headers,
-      body,
-      baseUrl: analyticsConfig.baseURL
-    });
-    return response;
-  }}
-  // Helper method to get the authorization token
-  getAuthorizationToken() {
-    const authHeader = String(this.http.authorization);
-    const match = /Bearer (.+)/.exec(authHeader);
-    if (!match) {
-      throw new Error("Invalid authorization header format");
-    }
-    return match[1];
-  }
-  /**
-   * Calls the Upstash completions api given a PromptRequest.
-   *
-   * Returns a ChatCompletion or a stream of ChatCompletionChunks
-   * if stream is enabled.
-   *
-   * @param request PromptRequest with system and user messages.
-   *    Note that system parameter shouldn't be passed in the case of
-   *    mistralai/Mistral-7B-Instruct-v0.2 model.
-   * @returns Chat completion or stream
-   */
-  __init5() {this.prompt = async (request) => {
-    const chatRequest = _Chat.toChatRequest(request);
-    return this.create(chatRequest);
-  }}
-}, _class2);
-
-// src/client/llm/utils.ts
-function appendLLMOptionsIfNeeded(request, headers, http) {
-  if (!request.api)
-    return;
-  const provider = request.api.provider;
-  const analytics = request.api.analytics;
-  if (_optionalChain([provider, 'optionalAccess', _15 => _15.owner]) === "upstash") {
-    handleUpstashProvider(request, headers, http, analytics);
-    return;
-  }
-  if (!("provider" in request.api))
-    return;
-  const { baseUrl, token } = validateProviderConfig(provider);
-  const analyticsConfig = analytics ? setupAnalytics({ name: analytics.name, token: analytics.token }, token, baseUrl, "custom") : void 0;
-  if (analyticsConfig) {
-    setAnalyticsHeaders(headers, analyticsConfig);
-    request.url = analyticsConfig.baseURL;
-  } else {
-    request.url = `${baseUrl}/v1/chat/completions`;
-    headers.set("Authorization", `Bearer ${token}`);
-  }
-}
-function handleUpstashProvider(request, headers, http, analytics) {
-  if (analytics) {
-    const analyticsConfig = setupAnalytics(
-      { name: analytics.name, token: analytics.token },
-      //@ts-expect-error hacky way to get bearer token
-      String(http.authorization).split("Bearer ")[1],
-      _optionalChain([request, 'access', _16 => _16.api, 'optionalAccess', _17 => _17.provider, 'optionalAccess', _18 => _18.baseUrl]),
-      "upstash"
-    );
-    setAnalyticsHeaders(headers, analyticsConfig);
-    request.url = analyticsConfig.baseURL;
-  } else {
-    request.api = { name: "llm" };
-  }
-}
-function validateProviderConfig(provider) {
-  if (!_optionalChain([provider, 'optionalAccess', _19 => _19.baseUrl]))
-    throw new Error("baseUrl cannot be empty or undefined!");
-  if (!provider.token)
-    throw new Error("token cannot be empty or undefined!");
-  return { baseUrl: provider.baseUrl, token: provider.token };
-}
-function setAnalyticsHeaders(headers, analyticsConfig) {
-  headers.set("Helicone-Auth", _nullishCoalesce(_optionalChain([analyticsConfig, 'access', _20 => _20.defaultHeaders, 'optionalAccess', _21 => _21["Helicone-Auth"]]), () => ( "")));
-  headers.set("Authorization", _nullishCoalesce(_optionalChain([analyticsConfig, 'access', _22 => _22.defaultHeaders, 'optionalAccess', _23 => _23.Authorization]), () => ( "")));
-  if (_optionalChain([analyticsConfig, 'access', _24 => _24.defaultHeaders, 'optionalAccess', _25 => _25["Helicone-Target-Url"]])) {
-    headers.set("Helicone-Target-Url", analyticsConfig.defaultHeaders["Helicone-Target-Url"]);
-  }
-}
-function ensureCallbackPresent(request) {
-  if (_optionalChain([request, 'access', _26 => _26.api, 'optionalAccess', _27 => _27.name]) === "llm" && !request.callback) {
-    throw new TypeError("Callback cannot be undefined when using LLM");
-  }
-}
-
-// src/client/messages.ts
-var Messages = class {
-  
-  constructor(http) {
-    this.http = http;
-  }
-  /**
-   * Get a message
-   */
-  async get(messageId) {
-    const messagePayload = await this.http.request({
-      method: "GET",
-      path: ["v2", "messages", messageId]
-    });
-    const message = {
-      ...messagePayload,
-      urlGroup: messagePayload.topicName
-    };
-    return message;
-  }
-  /**
-   * Cancel a message
-   */
-  async delete(messageId) {
-    return await this.http.request({
-      method: "DELETE",
-      path: ["v2", "messages", messageId],
-      parseResponseAsJson: false
-    });
-  }
-  async deleteMany(messageIds) {
-    const result = await this.http.request({
-      method: "DELETE",
-      path: ["v2", "messages"],
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ messageIds })
-    });
-    return result.cancelled;
-  }
-  async deleteAll() {
-    const result = await this.http.request({
-      method: "DELETE",
-      path: ["v2", "messages"]
-    });
-    return result.cancelled;
-  }
-};
-
-// src/client/utils.ts
-var isIgnoredHeader = (header) => {
-  const lowerCaseHeader = header.toLowerCase();
-  return lowerCaseHeader.startsWith("content-type") || lowerCaseHeader.startsWith("upstash-");
-};
-function prefixHeaders(headers) {
-  const keysToBePrefixed = [...headers.keys()].filter((key) => !isIgnoredHeader(key));
-  for (const key of keysToBePrefixed) {
-    const value = headers.get(key);
-    if (value !== null) {
-      headers.set(`Upstash-Forward-${key}`, value);
-    }
-    headers.delete(key);
-  }
-  return headers;
-}
-function processHeaders(request) {
-  const headers = prefixHeaders(new Headers(request.headers));
-  headers.set("Upstash-Method", _nullishCoalesce(request.method, () => ( "POST")));
-  if (request.delay !== void 0) {
-    if (typeof request.delay === "string") {
-      headers.set("Upstash-Delay", request.delay);
-    } else {
-      headers.set("Upstash-Delay", `${request.delay.toFixed(0)}s`);
-    }
-  }
-  if (request.notBefore !== void 0) {
-    headers.set("Upstash-Not-Before", request.notBefore.toFixed(0));
-  }
-  if (request.deduplicationId !== void 0) {
-    headers.set("Upstash-Deduplication-Id", request.deduplicationId);
-  }
-  if (request.contentBasedDeduplication !== void 0) {
-    headers.set("Upstash-Content-Based-Deduplication", "true");
-  }
-  if (request.retries !== void 0) {
-    headers.set("Upstash-Retries", request.retries.toFixed(0));
-  }
-  if (request.callback !== void 0) {
-    headers.set("Upstash-Callback", request.callback);
-  }
-  if (request.failureCallback !== void 0) {
-    headers.set("Upstash-Failure-Callback", request.failureCallback);
-  }
-  if (request.timeout !== void 0) {
-    if (typeof request.timeout === "string") {
-      headers.set("Upstash-Timeout", request.timeout);
-    } else {
-      headers.set("Upstash-Timeout", `${request.timeout}s`);
-    }
-  }
-  return headers;
-}
-function getRequestPath(request) {
-  return _nullishCoalesce(_nullishCoalesce(_nullishCoalesce(request.url, () => ( request.urlGroup)), () => ( request.topic)), () => ( `api/${_optionalChain([request, 'access', _28 => _28.api, 'optionalAccess', _29 => _29.name])}`));
-}
-var NANOID_CHARS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_";
-var NANOID_LENGTH = 21;
-function nanoid() {
-  return [...crypto.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/client/queue.ts
-var Queue = class {
-  
-  
-  constructor(http, queueName) {
-    this.http = http;
-    this.queueName = queueName;
-  }
-  /**
-   * Create or update the queue
-   */
-  async upsert(request) {
-    if (!this.queueName) {
-      throw new Error("Please provide a queue name to the Queue constructor");
-    }
-    const body = {
-      queueName: this.queueName,
-      parallelism: _nullishCoalesce(request.parallelism, () => ( 1)),
-      paused: _nullishCoalesce(request.paused, () => ( false))
-    };
-    await this.http.request({
-      method: "POST",
-      path: ["v2", "queues"],
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify(body),
-      parseResponseAsJson: false
-    });
-  }
-  /**
-   * Get the queue details
-   */
-  async get() {
-    if (!this.queueName) {
-      throw new Error("Please provide a queue name to the Queue constructor");
-    }
-    return await this.http.request({
-      method: "GET",
-      path: ["v2", "queues", this.queueName]
-    });
-  }
-  /**
-   * List queues
-   */
-  async list() {
-    return await this.http.request({
-      method: "GET",
-      path: ["v2", "queues"]
-    });
-  }
-  /**
-   * Delete the queue
-   */
-  async delete() {
-    if (!this.queueName) {
-      throw new Error("Please provide a queue name to the Queue constructor");
-    }
-    await this.http.request({
-      method: "DELETE",
-      path: ["v2", "queues", this.queueName],
-      parseResponseAsJson: false
-    });
-  }
-  /**
-   * Enqueue a message to a queue.
-   */
-  async enqueue(request) {
-    if (!this.queueName) {
-      throw new Error("Please provide a queue name to the Queue constructor");
-    }
-    const headers = processHeaders(request);
-    const destination = getRequestPath(request);
-    const response = await this.http.request({
-      path: ["v2", "enqueue", this.queueName, destination],
-      body: request.body,
-      headers,
-      method: "POST"
-    });
-    return response;
-  }
-  /**
-   * Enqueue a message to a queue, serializing the body to JSON.
-   */
-  async enqueueJSON(request) {
-    const headers = prefixHeaders(new Headers(request.headers));
-    headers.set("Content-Type", "application/json");
-    ensureCallbackPresent(request);
-    appendLLMOptionsIfNeeded(request, headers, this.http);
-    const response = await this.enqueue({
-      ...request,
-      body: JSON.stringify(request.body),
-      headers
-    });
-    return response;
-  }
-  /**
-   * Pauses the queue.
-   *
-   * A paused queue will not deliver messages until
-   * it is resumed.
-   */
-  async pause() {
-    if (!this.queueName) {
-      throw new Error("Please provide a queue name to the Queue constructor");
-    }
-    await this.http.request({
-      method: "POST",
-      path: ["v2", "queues", this.queueName, "pause"],
-      parseResponseAsJson: false
-    });
-  }
-  /**
-   * Resumes the queue.
-   */
-  async resume() {
-    if (!this.queueName) {
-      throw new Error("Please provide a queue name to the Queue constructor");
-    }
-    await this.http.request({
-      method: "POST",
-      path: ["v2", "queues", this.queueName, "resume"],
-      parseResponseAsJson: false
-    });
-  }
-};
-
-// src/client/schedules.ts
-var Schedules = class {
-  
-  constructor(http) {
-    this.http = http;
-  }
-  /**
-   * Create a schedule
-   */
-  async create(request) {
-    const headers = prefixHeaders(new Headers(request.headers));
-    if (!headers.has("Content-Type")) {
-      headers.set("Content-Type", "application/json");
-    }
-    headers.set("Upstash-Cron", request.cron);
-    if (request.method !== void 0) {
-      headers.set("Upstash-Method", request.method);
-    }
-    if (request.delay !== void 0) {
-      if (typeof request.delay === "string") {
-        headers.set("Upstash-Delay", request.delay);
-      } else {
-        headers.set("Upstash-Delay", `${request.delay.toFixed(0)}s`);
-      }
-    }
-    if (request.retries !== void 0) {
-      headers.set("Upstash-Retries", request.retries.toFixed(0));
-    }
-    if (request.callback !== void 0) {
-      headers.set("Upstash-Callback", request.callback);
-    }
-    if (request.failureCallback !== void 0) {
-      headers.set("Upstash-Failure-Callback", request.failureCallback);
-    }
-    if (request.timeout !== void 0) {
-      if (typeof request.timeout === "string") {
-        headers.set("Upstash-Timeout", request.timeout);
-      } else {
-        headers.set("Upstash-Timeout", `${request.timeout}s`);
-      }
-    }
-    if (request.scheduleId !== void 0) {
-      headers.set("Upstash-Schedule-Id", request.scheduleId);
-    }
-    return await this.http.request({
-      method: "POST",
-      headers,
-      path: ["v2", "schedules", request.destination],
-      body: request.body
-    });
-  }
-  /**
-   * Get a schedule
-   */
-  async get(scheduleId) {
-    return await this.http.request({
-      method: "GET",
-      path: ["v2", "schedules", scheduleId]
-    });
-  }
-  /**
-   * List your schedules
-   */
-  async list() {
-    return await this.http.request({
-      method: "GET",
-      path: ["v2", "schedules"]
-    });
-  }
-  /**
-   * Delete a schedule
-   */
-  async delete(scheduleId) {
-    return await this.http.request({
-      method: "DELETE",
-      path: ["v2", "schedules", scheduleId],
-      parseResponseAsJson: false
-    });
-  }
-  /**
-   * Pauses the schedule.
-   *
-   * A paused schedule will not deliver messages until
-   * it is resumed.
-   */
-  async pause({ schedule }) {
-    await this.http.request({
-      method: "PATCH",
-      path: ["v2", "schedules", schedule, "pause"],
-      parseResponseAsJson: false
-    });
-  }
-  /**
-   * Resumes the schedule.
-   */
-  async resume({ schedule }) {
-    await this.http.request({
-      method: "PATCH",
-      path: ["v2", "schedules", schedule, "resume"],
-      parseResponseAsJson: false
-    });
-  }
-};
-
-// src/client/url-groups.ts
-var UrlGroups = class {
-  
-  constructor(http) {
-    this.http = http;
-  }
-  /**
-   * Create a new url group with the given name and endpoints
-   */
-  async addEndpoints(request) {
-    await this.http.request({
-      method: "POST",
-      path: ["v2", "topics", request.name, "endpoints"],
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ endpoints: request.endpoints }),
-      parseResponseAsJson: false
-    });
-  }
-  /**
-   * Remove endpoints from a url group.
-   */
-  async removeEndpoints(request) {
-    await this.http.request({
-      method: "DELETE",
-      path: ["v2", "topics", request.name, "endpoints"],
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ endpoints: request.endpoints }),
-      parseResponseAsJson: false
-    });
-  }
-  /**
-   * Get a list of all url groups.
-   */
-  async list() {
-    return await this.http.request({
-      method: "GET",
-      path: ["v2", "topics"]
-    });
-  }
-  /**
-   * Get a single url group
-   */
-  async get(name) {
-    return await this.http.request({
-      method: "GET",
-      path: ["v2", "topics", name]
-    });
-  }
-  /**
-   * Delete a url group
-   */
-  async delete(name) {
-    return await this.http.request({
-      method: "DELETE",
-      path: ["v2", "topics", name],
-      parseResponseAsJson: false
-    });
-  }
-};
-
-// src/client/client.ts
-var Client = class {
-  
-  
-  constructor(config) {
-    this.http = new HttpClient({
-      retry: config.retry,
-      baseUrl: config.baseUrl ? config.baseUrl.replace(/\/$/, "") : "https://qstash.upstash.io",
-      authorization: `Bearer ${config.token}`
-    });
-    this.token = config.token;
-  }
-  /**
-   * Access the urlGroup API.
-   *
-   * Create, read, update or delete urlGroups.
-   */
-  get urlGroups() {
-    return new UrlGroups(this.http);
-  }
-  /**
-   * Deprecated. Use urlGroups instead.
-   *
-   * Access the topic API.
-   *
-   * Create, read, update or delete topics.
-   */
-  get topics() {
-    return this.urlGroups;
-  }
-  /**
-   * Access the dlq API.
-   *
-   * List or remove messages from the DLQ.
-   */
-  get dlq() {
-    return new DLQ(this.http);
-  }
-  /**
-   * Access the message API.
-   *
-   * Read or cancel messages.
-   */
-  get messages() {
-    return new Messages(this.http);
-  }
-  /**
-   * Access the schedule API.
-   *
-   * Create, read or delete schedules.
-   */
-  get schedules() {
-    return new Schedules(this.http);
-  }
-  /**
-   * Access the workflow API.
-   *
-   * cancel workflows.
-   */
-  get workflow() {
-    return new Workflow(this.http);
-  }
-  /**
-   * Access the queue API.
-   *
-   * Create, read, update or delete queues.
-   */
-  queue(request) {
-    return new Queue(this.http, _optionalChain([request, 'optionalAccess', _30 => _30.queueName]));
-  }
-  /**
-   * Access the Chat API
-   *
-   * Call the create or prompt methods
-   */
-  chat() {
-    return new Chat(this.http, this.token);
-  }
-  async publish(request) {
-    const headers = processHeaders(request);
-    const response = await this.http.request({
-      path: ["v2", "publish", getRequestPath(request)],
-      body: request.body,
-      headers,
-      method: "POST"
-    });
-    return response;
-  }
-  /**
-   * publishJSON is a utility wrapper around `publish` that automatically serializes the body
-   * and sets the `Content-Type` header to `application/json`.
-   */
-  async publishJSON(request) {
-    const headers = prefixHeaders(new Headers(request.headers));
-    headers.set("Content-Type", "application/json");
-    ensureCallbackPresent(request);
-    appendLLMOptionsIfNeeded(request, headers, this.http);
-    const response = await this.publish({
-      ...request,
-      headers,
-      body: JSON.stringify(request.body)
-    });
-    return response;
-  }
-  /**
-   * Batch publish messages to QStash.
-   */
-  async batch(request) {
-    const messages = [];
-    for (const message of request) {
-      const headers = processHeaders(message);
-      const headerEntries = Object.fromEntries(headers.entries());
-      messages.push({
-        destination: getRequestPath(message),
-        headers: headerEntries,
-        body: message.body,
-        ...message.queueName && { queue: message.queueName }
-      });
-    }
-    const response = await this.http.request({
-      path: ["v2", "batch"],
-      body: JSON.stringify(messages),
-      headers: {
-        "Content-Type": "application/json"
-      },
-      method: "POST"
-    });
-    const arrayResposne = Array.isArray(response) ? response : [response];
-    return arrayResposne;
-  }
-  /**
-   * Batch publish messages to QStash, serializing each body to JSON.
-   */
-  async batchJSON(request) {
-    for (const message of request) {
-      if ("body" in message) {
-        message.body = JSON.stringify(message.body);
-      }
-      message.headers = new Headers(message.headers);
-      ensureCallbackPresent(message);
-      appendLLMOptionsIfNeeded(message, message.headers, this.http);
-      message.headers.set("Content-Type", "application/json");
-    }
-    const response = await this.batch(request);
-    return response;
-  }
-  /**
-   * Retrieve your logs.
-   *
-   * The logs endpoint is paginated and returns only 100 logs at a time.
-   * If you want to receive more logs, you can use the cursor to paginate.
-   *
-   * The cursor is a unix timestamp with millisecond precision
-   *
-   * @example
-   * ```ts
-   * let cursor = Date.now()
-   * const logs: Log[] = []
-   * while (cursor > 0) {
-   *   const res = await qstash.logs({ cursor })
-   *   logs.push(...res.logs)
-   *   cursor = res.cursor ?? 0
-   * }
-   * ```
-   */
-  async events(request) {
-    const query = {};
-    if (typeof _optionalChain([request, 'optionalAccess', _31 => _31.cursor]) === "number" && request.cursor > 0) {
-      query.cursor = request.cursor.toString();
-    } else if (typeof _optionalChain([request, 'optionalAccess', _32 => _32.cursor]) === "string" && request.cursor !== "") {
-      query.cursor = request.cursor;
-    }
-    for (const [key, value] of Object.entries(_nullishCoalesce(_optionalChain([request, 'optionalAccess', _33 => _33.filter]), () => ( {})))) {
-      if (typeof value === "number" && value < 0) {
-        continue;
-      }
-      if (key === "urlGroup") {
-        query.topicName = value.toString();
-      } else if (typeof value !== "undefined") {
-        query[key] = value.toString();
-      }
-    }
-    const responsePayload = await this.http.request({
-      path: ["v2", "events"],
-      method: "GET",
-      query
-    });
-    return {
-      cursor: responsePayload.cursor,
-      events: responsePayload.events.map((event) => {
-        return {
-          ...event,
-          urlGroup: event.topicName
-        };
-      })
-    };
-  }
-};
-
-// src/client/workflow/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_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;
-
-// 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));
-    })));
-  }
-  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);
-var err = (err2) => 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
-  orElse(_f) {
-    return ok(this.value);
-  }
-  asyncAndThen(f) {
-    return f(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));
-  }
-  // 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);
-  }
-  // 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/client/workflow/types.ts
-var StepTypes = ["Initial", "Run", "SleepFor", "SleepUntil", "Call"];
-
-// src/client/workflow/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 _optionalChain([debug, 'optionalAccess', _34 => _34.log, 'call', _35 => _35("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 _optionalChain([debug, 'optionalAccess', _36 => _36.log, 'call', _37 => _37("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 _optionalChain([debug, 'optionalAccess', _38 => _38.log, 'call', _39 => _39("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)) {
-        await _optionalChain([debug, 'optionalAccess', _40 => _40.log, 'call', _41 => _41("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 (if there are retries remaining). 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 requestHeaders = getHeaders(
-        "false",
-        workflowRunId,
-        workflowUrl,
-        userHeaders,
-        void 0,
-        failureUrl,
-        retries
-      );
-      const callResultStep = {
-        stepId: Number(stepIdString),
-        stepName,
-        stepType,
-        out: atob(callbackMessage.body),
-        concurrent: Number(concurrentString)
-      };
-      await _optionalChain([debug, 'optionalAccess', _42 => _42.log, 'call', _43 => _43("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 _optionalChain([debug, 'optionalAccess', _44 => _44.log, 'call', _45 => _45("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,
-    [`Upstash-Forward-${WORKFLOW_PROTOCOL_VERSION_HEADER}`]: WORKFLOW_PROTOCOL_VERSION,
-    ...failureUrl ? {
-      [`Upstash-Failure-Callback-Forward-${WORKFLOW_FAILURE_HEADER}`]: "true",
-      "Upstash-Failure-Callback": failureUrl
-    } : {},
-    ...retries === void 0 ? {} : {
-      "Upstash-Retries": retries.toString()
-    }
-  };
-  if (userHeaders) {
-    for (const header of userHeaders.keys()) {
-      if (_optionalChain([step, 'optionalAccess', _46 => _46.callHeaders])) {
-        baseHeaders[`Upstash-Callback-Forward-${header}`] = userHeaders.get(header);
-      } else {
-        baseHeaders[`Upstash-Forward-${header}`] = userHeaders.get(header);
-      }
-    }
-  }
-  if (_optionalChain([step, 'optionalAccess', _47 => _47.callHeaders])) {
-    const forwardedHeaders = Object.fromEntries(
-      Object.entries(step.callHeaders).map(([header, value]) => [
-        `Upstash-Forward-${header}`,
-        value
-      ])
-    );
-    const contentType = step.callHeaders["Content-Type"];
-    return {
-      ...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": _nullishCoalesce(contentType, () => ( DEFAULT_CONTENT_TYPE)),
-      "Upstash-Workflow-CallType": "toCallback"
-    };
-  }
-  return 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/client/workflow/auto-executor.ts
-var AutoExecutor = (_class3 = class _AutoExecutor {
-  
-  __init6() {this.promises = /* @__PURE__ */ new WeakMap()}
-  
-  
-  
-  
-  __init7() {this.indexInCurrentList = 0}
-  __init8() {this.stepCount = 0}
-  __init9() {this.planStepCount = 0}
-  __init10() {this.executingStep = false}
-  constructor(context, steps, debug) {;_class3.prototype.__init6.call(this);_class3.prototype.__init7.call(this);_class3.prototype.__init8.call(this);_class3.prototype.__init9.call(this);_class3.prototype.__init10.call(this);
-    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 = _nullishCoalesce(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 _optionalChain([this, 'access', _48 => _48.debug, 'optionalAccess', _49 => _49.log, 'call', _50 => _50("INFO", "RUN_SINGLE", {
-        fromRequest: true,
-        step,
-        stepCount: this.stepCount
-      })]);
-      return step.out;
-    }
-    const resultStep = await lazyStep.getResultStep(NO_CONCURRENCY, this.stepCount);
-    await _optionalChain([this, 'access', _51 => _51.debug, 'optionalAccess', _52 => _52.log, 'call', _53 => _53("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 = _optionalChain([sortedSteps, 'access', _54 => _54[initialStepCount + this.planStepCount], 'optionalAccess', _55 => _55.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 _optionalChain([this, 'access', _56 => _56.debug, 'optionalAccess', _57 => _57.log, 'call', _58 => _58("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) => (_nullishCoalesce(step.targetStep, () => ( step.stepId))) >= initialStepCount
-    );
-    if (remainingSteps.length === 0) {
-      return "first";
-    } else if (remainingSteps.length >= 2 * parallelStepCount) {
-      return "last";
-    } else if (_optionalChain([remainingSteps, 'access', _59 => _59.at, 'call', _60 => _60(-1), 'optionalAccess', _61 => _61.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 _optionalChain([this, 'access', _62 => _62.debug, 'optionalAccess', _63 => _63.log, 'call', _64 => _64("SUBMIT", "SUBMIT_STEP", { length: steps.length, steps })]);
-    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;
-        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 _optionalChain([this, 'access', _65 => _65.debug, 'optionalAccess', _66 => _66.log, 'call', _67 => _67("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
-   */
-  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();
-  }
-}, _class3);
-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) => _nullishCoalesce(step.targetStep, () => ( step.stepId));
-  return steps.toSorted((step, stepOther) => getStepId(step) - getStepId(stepOther));
-};
-
-// src/client/workflow/steps.ts
-var BaseLazyStep = class {
-  
-  // will be set in the subclasses
-  constructor(stepName) {
-    this.stepName = stepName;
-  }
-};
-var LazyFunctionStep = (_class4 = class extends BaseLazyStep {
-  
-  __init11() {this.stepType = "Run"}
-  constructor(stepName, stepFunction) {
-    super(stepName);_class4.prototype.__init11.call(this);;
-    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
-    };
-  }
-}, _class4);
-var LazySleepStep = (_class5 = class extends BaseLazyStep {
-  
-  __init12() {this.stepType = "SleepFor"}
-  constructor(stepName, sleep) {
-    super(stepName);_class5.prototype.__init12.call(this);;
-    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
-    });
-  }
-}, _class5);
-var LazySleepUntilStep = (_class6 = class extends BaseLazyStep {
-  
-  __init13() {this.stepType = "SleepUntil"}
-  constructor(stepName, sleepUntil) {
-    super(stepName);_class6.prototype.__init13.call(this);;
-    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
-    });
-  }
-}, _class6);
-var LazyCallStep = (_class7 = class extends BaseLazyStep {
-  
-  
-  
-  
-  __init14() {this.stepType = "Call"}
-  constructor(stepName, url, method, body, headers) {
-    super(stepName);_class7.prototype.__init14.call(this);;
-    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
-    });
-  }
-}, _class7);
-
-// src/client/workflow/context.ts
-var WorkflowContext = class {
-  
-  
-  /**
-   * 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({...})
-   *   }
-   * )
-   * ```
-   */
-  
-  /**
-   * Run id of the workflow
-   */
-  
-  /**
-   * 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 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"
-   *   }
-   * )
-   * ```
-   */
-  
-  /**
-   * 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)}
-   *   }
-   * )
-   * ```
-   */
-  
-  /**
-   * headers of the initial request
-   */
-  
-  /**
-   * initial payload as a raw string
-   */
-  
-  /**
-   * 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`.
-   */
-  
-  /**
-   * Number of 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 = _nullishCoalesce(rawInitialPayload, () => ( JSON.stringify(this.requestPayload)));
-    this.env = _nullishCoalesce(env, () => ( {}));
-    this.retries = _nullishCoalesce(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 (parsed as JSON if possible)
-   */
-  async call(stepName, url, method, body, headers) {
-    const result = await this.addStep(
-      new LazyCallStep(stepName, url, method, body, _nullishCoalesce(headers, () => ( {})))
-    );
-    try {
-      return JSON.parse(result);
-    } catch (e2) {
-      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);
-  }
-};
-var DisabledWorkflowContext = (_class8 = class _DisabledWorkflowContext extends WorkflowContext {
-  static __initStatic() {this.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
-   */
-  // eslint-disable-next-line @typescript-eslint/require-await
-  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 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");
-  }
-}, _class8.__initStatic(), _class8);
-
-// src/client/workflow/logger.ts
-var LOG_LEVELS = ["DEBUG", "INFO", "SUBMIT", "WARN", "ERROR"];
-var WorkflowLogger = (_class9 = class _WorkflowLogger {
-  __init15() {this.logs = []}
-  
-  __init16() {this.workflowRunId = void 0}
-  constructor(options) {;_class9.prototype.__init15.call(this);_class9.prototype.__init16.call(this);
-    this.options = options;
-  }
-  async log(level, eventType, details) {
-    if (this.shouldLog(level)) {
-      const timestamp = Date.now();
-      const logEntry = {
-        timestamp,
-        workflowRunId: _nullishCoalesce(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;
-    }
-  }
-}, _class9);
-
-// src/client/workflow/workflow-parser.ts
-var getPayload = async (request) => {
-  try {
-    return await request.text();
-  } catch (e3) {
-    return;
-  }
-};
-var parsePayload = (rawPayload) => {
-  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 = stepsToDecode.map((rawStep) => {
-    return JSON.parse(decodeBase64(rawStep.body));
-  });
-  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(_nullishCoalesce(step.targetStep, () => ( 0)))) {
-        deduplicatedSteps.push(step);
-        targetStepIds.push(_nullishCoalesce(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 = `QStash 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 _optionalChain([debug, 'optionalAccess', _68 => _68.log, 'call', _69 => _69("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()}` : _nullishCoalesce(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: _nullishCoalesce(requestPayload, () => ( "")),
-      steps: [],
-      isLastDuplicate: false
-    };
-  } else {
-    if (!requestPayload) {
-      throw new QStashWorkflowError("Only first call can have an empty body");
-    }
-    const { rawInitialPayload, steps } = parsePayload(requestPayload);
-    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,
-      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/client/workflow/serve.ts
-var processOptions = (options) => {
-  const environment = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _70 => _70.env]), () => ( (typeof process === "undefined" ? {} : process.env)));
-  const receiverEnvironmentVariablesSet = Boolean(
-    environment.QSTASH_CURRENT_SIGNING_KEY && environment.QSTASH_NEXT_SIGNING_KEY
-  );
-  return {
-    qstashClient: new Client({
-      baseUrl: environment.QSTASH_URL,
-      token: environment.QSTASH_TOKEN
-    }),
-    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 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 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) => {
-    const initialWorkflowUrl = _nullishCoalesce(url, () => ( request.url));
-    const workflowUrl = baseUrl ? initialWorkflowUrl.replace(/^(https?:\/\/[^/]+)(\/.*)?$/, (_, matchedBaseUrl, path) => {
-      return baseUrl + (path || "");
-    }) : initialWorkflowUrl;
-    if (workflowUrl !== initialWorkflowUrl) {
-      await _optionalChain([debug, 'optionalAccess', _71 => _71.log, 'call', _72 => _72("WARN", "ENDPOINT_START", {
-        warning: `QStash Workflow: replacing the base of the url with "${baseUrl}" and using it as workflow endpoint.`,
-        originalURL: initialWorkflowUrl,
-        updatedURL: workflowUrl
-      })]);
-    }
-    const workflowFailureUrl = failureFunction ? workflowUrl : failureUrl;
-    const requestPayload = await _asyncNullishCoalesce(await getPayload(request), async () => ( ""));
-    await verifyRequest(requestPayload, request.headers.get("upstash-signature"), receiver);
-    await _optionalChain([debug, 'optionalAccess', _73 => _73.log, 'call', _74 => _74("INFO", "ENDPOINT_START")]);
-    const failureCheck = await handleFailure(
-      request,
-      requestPayload,
-      qstashClient,
-      initialPayloadParser,
-      failureFunction
-    );
-    if (failureCheck.isErr()) {
-      throw failureCheck.error;
-    } else if (failureCheck.value === "is-failure-callback") {
-      await _optionalChain([debug, 'optionalAccess', _75 => _75.log, 'call', _76 => _76("WARN", "RESPONSE_DEFAULT", "failureFunction executed")]);
-      return onStepFinish("no-workflow-id", "failure-callback");
-    }
-    const { isFirstInvocation, workflowRunId } = validateRequest(request);
-    _optionalChain([debug, 'optionalAccess', _77 => _77.setWorkflowRunId, 'call', _78 => _78(workflowRunId)]);
-    const { rawInitialPayload, steps, isLastDuplicate } = await parseRequest(
-      requestPayload,
-      isFirstInvocation,
-      debug
-    );
-    if (isLastDuplicate) {
-      return onStepFinish("no-workflow-id", "duplicate-step");
-    }
-    const workflowContext = new WorkflowContext({
-      qstashClient,
-      workflowRunId,
-      initialPayload: initialPayloadParser(rawInitialPayload),
-      rawInitialPayload,
-      headers: recreateUserHeaders(request.headers),
-      steps,
-      url: workflowUrl,
-      failureUrl: workflowFailureUrl,
-      debug,
-      env
-    });
-    const authCheck = await DisabledWorkflowContext.tryAuthentication(
-      routeFunction,
-      workflowContext
-    );
-    if (authCheck.isErr()) {
-      await _optionalChain([debug, 'optionalAccess', _79 => _79.log, 'call', _80 => _80("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 _optionalChain([debug, 'optionalAccess', _81 => _81.log, 'call', _82 => _82("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 _optionalChain([debug, 'optionalAccess', _83 => _83.log, 'call', _84 => _84("ERROR", "ERROR", { error: result.error.message })]);
-        throw result.error;
-      }
-      await _optionalChain([debug, 'optionalAccess', _85 => _85.log, 'call', _86 => _86("INFO", "RESPONSE_WORKFLOW")]);
-      return onStepFinish(workflowContext.workflowRunId, "success");
-    }
-    await _optionalChain([debug, 'optionalAccess', _87 => _87.log, 'call', _88 => _88("INFO", "RESPONSE_DEFAULT")]);
-    return onStepFinish("no-workflow-id", "fromCallback");
-  };
-  return async (request) => {
-    try {
-      return await handler(request);
-    } catch (error) {
-      console.error(error);
-      return new Response(JSON.stringify(formatWorkflowError(error)), { status: 500 });
-    }
-  };
-};
-
-// src/client/workflow/index.ts
-var Workflow = class {
-  
-  constructor(http) {
-    this.http = http;
-  }
-  /**
-   * Cancel an ongoing workflow
-   *
-   * @param workflowRunId run id of the workflow to delete
-   * @returns true if workflow is succesfully deleted. Otherwise throws QStashError
-   */
-  async cancel(workflowRunId) {
-    const result = await this.http.request({
-      path: ["v2", "workflows", "runs", `${workflowRunId}?cancel=true`],
-      method: "DELETE",
-      parseResponseAsJson: false
-    });
-    return _nullishCoalesce(result, () => ( true));
-  }
-};
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-exports.SignatureError = SignatureError; exports.Receiver = Receiver; exports.QstashError = QstashError; exports.QstashRatelimitError = QstashRatelimitError; exports.QstashChatRatelimitError = QstashChatRatelimitError; exports.QstashDailyRatelimitError = QstashDailyRatelimitError; exports.QStashWorkflowError = QStashWorkflowError; exports.QStashWorkflowAbort = QStashWorkflowAbort; exports.formatWorkflowError = formatWorkflowError; exports.setupAnalytics = setupAnalytics; exports.upstash = upstash; exports.openai = openai; exports.custom = custom; exports.Chat = Chat; exports.Messages = Messages; exports.decodeBase64 = decodeBase64; exports.Schedules = Schedules; exports.UrlGroups = UrlGroups; exports.StepTypes = StepTypes; exports.WorkflowContext = WorkflowContext; exports.DisabledWorkflowContext = DisabledWorkflowContext; exports.WorkflowLogger = WorkflowLogger; exports.processOptions = processOptions; exports.serve = serve; exports.Workflow = Workflow; exports.Client = Client;