@upstash/workflow 0.2.1 → 0.2.3

package/{chunk-ADOBNR4O.mjs → chunk-QBJ3LQIO.mjs}

@@ -71,7 +71,19 @@ var formatWorkflowError = (error) => {
   };
 };
 
+// src/types.ts
+var StepTypes = [
+  "Initial",
+  "Run",
+  "SleepFor",
+  "SleepUntil",
+  "Call",
+  "Wait",
+  "Notify"
+];
+
 // src/client/utils.ts
+import { QstashError as QstashError2 } from "@upstash/qstash";
 var makeNotifyRequest = async (requester, eventId, eventData) => {
   const result = await requester.request({
     path: ["v2", "notify", eventId],
@@ -105,24 +117,28 @@ var getSteps = async (requester, workflowRunId, messageId, debug) => {
       await debug?.log("INFO", "ENDPOINT_START", {
         message: `Pulled ${steps.length} steps from QStashand returned them without filtering with messageId.`
       });
-      return steps;
+      return { steps, workflowRunEnded: false };
     } else {
       const index = steps.findIndex((item) => item.messageId === messageId);
       if (index === -1) {
-        return [];
+        return { steps: [], workflowRunEnded: false };
       }
       const filteredSteps = steps.slice(0, index + 1);
       await debug?.log("INFO", "ENDPOINT_START", {
         message: `Pulled ${steps.length} steps from QStash and filtered them to ${filteredSteps.length} using messageId.`
       });
-      return filteredSteps;
+      return { steps: filteredSteps, workflowRunEnded: false };
     }
   } catch (error) {
-    await debug?.log("ERROR", "ERROR", {
-      message: "failed while fetching steps.",
-      error
-    });
-    throw new WorkflowError(`Failed while pulling steps. ${error}`);
+    if (error instanceof QstashError2 && error.status === 404) {
+      await debug?.log("WARN", "ENDPOINT_START", {
+        message: "Couldn't fetch workflow run steps. This can happen if the workflow run succesfully ends before some callback is executed.",
+        error
+      });
+      return { steps: void 0, workflowRunEnded: true };
+    } else {
+      throw error;
+    }
   }
 };
 
@@ -734,20 +750,9 @@ var DEFAULT_CONTENT_TYPE = "application/json";
 var NO_CONCURRENCY = 1;
 var DEFAULT_RETRIES = 3;
 
-// src/types.ts
-var StepTypes = [
-  "Initial",
-  "Run",
-  "SleepFor",
-  "SleepUntil",
-  "Call",
-  "Wait",
-  "Notify"
-];
-
 // src/workflow-requests.ts
-import { QstashError as QstashError2 } from "@upstash/qstash";
-var triggerFirstInvocation = async (workflowContext, retries, debug) => {
+import { QstashError as QstashError3 } from "@upstash/qstash";
+var triggerFirstInvocation = async (workflowContext, retries, useJSONContent, debug) => {
   const { headers } = getHeaders(
     "true",
     workflowContext.workflowRunId,
@@ -757,6 +762,9 @@ var triggerFirstInvocation = async (workflowContext, retries, debug) => {
     workflowContext.failureUrl,
     retries
   );
+  if (useJSONContent) {
+    headers["content-type"] = "application/json";
+  }
   try {
     const body = typeof workflowContext.requestPayload === "string" ? workflowContext.requestPayload : JSON.stringify(workflowContext.requestPayload);
     const result = await workflowContext.qstashClient.publish({
@@ -800,7 +808,7 @@ var triggerRouteFunction = async ({
     return ok("workflow-finished");
   } catch (error) {
     const error_ = error;
-    if (error instanceof QstashError2 && error.status === 400) {
+    if (error instanceof QstashError3 && error.status === 400) {
       await debug?.log("WARN", "RESPONSE_WORKFLOW", {
         message: `tried to append to a cancelled workflow. exiting without publishing.`,
         name: error.name,
@@ -834,7 +842,7 @@ var triggerWorkflowDelete = async (workflowContext, debug, cancel = false) => {
     );
     return { deleted: true };
   } catch (error) {
-    if (error instanceof QstashError2 && error.status === 404) {
+    if (error instanceof QstashError3 && error.status === 404) {
       await debug?.log("WARN", "SUBMIT_CLEANUP", {
         message: `Failed to remove workflow run ${workflowContext.workflowRunId} as it doesn't exist.`,
         name: error.name,
@@ -871,11 +879,19 @@ var handleThirdPartyCallResult = async (request, requestPayload, client, workflo
         if (!workflowRunId2)
           throw new WorkflowError("workflow run id missing in context.call lazy fetch.");
         if (!messageId) throw new WorkflowError("message id missing in context.call lazy fetch.");
-        const steps = await getSteps(client.http, workflowRunId2, messageId, debug);
+        const { steps, workflowRunEnded } = await getSteps(
+          client.http,
+          workflowRunId2,
+          messageId,
+          debug
+        );
+        if (workflowRunEnded) {
+          return ok("workflow-ended");
+        }
         const failingStep = steps.find((step) => step.messageId === messageId);
         if (!failingStep)
           throw new WorkflowError(
-            "Failed to submit the context.call." + (steps.length === 0 ? "No steps found." : `No step was found with matching messageId ${messageId} out of ${steps.length} steps.`)
+            "Failed to submit the context.call. " + (steps.length === 0 ? "No steps found." : `No step was found with matching messageId ${messageId} out of ${steps.length} steps.`)
           );
         callbackPayload = atob(failingStep.body);
       }
@@ -1458,6 +1474,127 @@ var sortSteps = (steps) => {
   return [...steps].sort((step, stepOther) => getStepId(step) - getStepId(stepOther));
 };
 
+// src/context/api/anthropic.ts
+import { anthropic } from "@upstash/qstash";
+
+// src/context/provider.ts
+var getProviderInfo = (api) => {
+  if (!api.provider) {
+    throw new WorkflowError("A Provider must be provided.");
+  }
+  if (api.provider.owner === "upstash") {
+    throw new WorkflowError("Upstash provider isn't supported.");
+  }
+  const { name, provider, ...parameters } = api;
+  if (!provider.baseUrl) throw new TypeError("baseUrl cannot be empty or undefined!");
+  if (!provider.token) throw new TypeError("token cannot be empty or undefined!");
+  if (provider.apiKind !== name) {
+    throw new TypeError(`Unexpected api name. Expected '${provider.apiKind}', received ${name}`);
+  }
+  const providerInfo = {
+    url: provider.getUrl(),
+    baseUrl: provider.baseUrl,
+    route: provider.getRoute(),
+    appendHeaders: provider.getHeaders(parameters),
+    owner: provider.owner,
+    method: provider.method
+  };
+  return provider.onFinish(providerInfo, parameters);
+};
+
+// src/context/api/base.ts
+var BaseWorkflowApi = class {
+  context;
+  constructor({ context }) {
+    this.context = context;
+  }
+  /**
+   * context.call which uses a QStash API
+   *
+   * @param stepName
+   * @param settings
+   * @returns
+   */
+  async callApi(stepName, settings) {
+    const { url, appendHeaders, method } = getProviderInfo(settings.api);
+    const { method: userMethod, body, headers = {}, retries = 0, timeout } = settings;
+    return await this.context.call(stepName, {
+      url,
+      method: userMethod ?? method,
+      body,
+      headers: {
+        ...appendHeaders,
+        ...headers
+      },
+      retries,
+      timeout
+    });
+  }
+};
+
+// src/context/api/anthropic.ts
+var AnthropicAPI = class extends BaseWorkflowApi {
+  async call(stepName, settings) {
+    const { token, operation, ...parameters } = settings;
+    return await this.callApi(stepName, {
+      api: {
+        name: "llm",
+        provider: anthropic({ token })
+      },
+      ...parameters
+    });
+  }
+};
+
+// src/context/api/openai.ts
+import { openai } from "@upstash/qstash";
+var OpenAIAPI = class extends BaseWorkflowApi {
+  async call(stepName, settings) {
+    const { token, organization, operation, ...parameters } = settings;
+    return await this.callApi(stepName, {
+      api: {
+        name: "llm",
+        provider: openai({ token, organization })
+      },
+      ...parameters
+    });
+  }
+};
+
+// src/context/api/resend.ts
+import { resend } from "@upstash/qstash";
+var ResendAPI = class extends BaseWorkflowApi {
+  async call(stepName, settings) {
+    const { token, batch = false, ...parameters } = settings;
+    return await this.callApi(stepName, {
+      api: {
+        name: "email",
+        provider: resend({ token, batch })
+      },
+      ...parameters
+    });
+  }
+};
+
+// src/context/api/index.ts
+var WorkflowApi = class extends BaseWorkflowApi {
+  get openai() {
+    return new OpenAIAPI({
+      context: this.context
+    });
+  }
+  get resend() {
+    return new ResendAPI({
+      context: this.context
+    });
+  }
+  get anthropic() {
+    return new AnthropicAPI({
+      context: this.context
+    });
+  }
+};
+
 // src/context/context.ts
 var WorkflowContext = class {
   executor;
@@ -1837,6 +1974,11 @@ var WorkflowContext = class {
   async addStep(step) {
     return await this.executor.addStep(step);
   }
+  get api() {
+    return new WorkflowApi({
+      context: this
+    });
+  }
 };
 
 // src/logger.ts
@@ -1914,7 +2056,7 @@ function decodeBase64(base64) {
 }
 
 // src/serve/authorization.ts
-import { Client } from "@upstash/qstash";
+import { Client as Client2 } from "@upstash/qstash";
 var DisabledWorkflowContext = class _DisabledWorkflowContext extends WorkflowContext {
   static disabledMessage = "disabled-qstash-worklfow-run";
   /**
@@ -1945,7 +2087,7 @@ var DisabledWorkflowContext = class _DisabledWorkflowContext extends WorkflowCon
    */
   static async tryAuthentication(routeFunction, context) {
     const disabledContext = new _DisabledWorkflowContext({
-      qstashClient: new Client({
+      qstashClient: new Client2({
         baseUrl: "disabled-client",
         token: "disabled-client"
       }),
@@ -2069,7 +2211,8 @@ var parseRequest = async (requestPayload, isFirstInvocation, workflowRunId, requ
     return {
       rawInitialPayload: requestPayload ?? "",
       steps: [],
-      isLastDuplicate: false
+      isLastDuplicate: false,
+      workflowRunEnded: false
     };
   } else {
     let rawSteps;
@@ -2079,7 +2222,21 @@ var parseRequest = async (requestPayload, isFirstInvocation, workflowRunId, requ
         "ENDPOINT_START",
         "request payload is empty, steps will be fetched from QStash."
       );
-      rawSteps = await getSteps(requester, workflowRunId, messageId, debug);
+      const { steps: fetchedSteps, workflowRunEnded } = await getSteps(
+        requester,
+        workflowRunId,
+        messageId,
+        debug
+      );
+      if (workflowRunEnded) {
+        return {
+          rawInitialPayload: void 0,
+          steps: void 0,
+          isLastDuplicate: void 0,
+          workflowRunEnded: true
+        };
+      }
+      rawSteps = fetchedSteps;
     } else {
       rawSteps = JSON.parse(requestPayload);
     }
@@ -2089,7 +2246,8 @@ var parseRequest = async (requestPayload, isFirstInvocation, workflowRunId, requ
     return {
       rawInitialPayload,
       steps: deduplicatedSteps,
-      isLastDuplicate
+      isLastDuplicate,
+      workflowRunEnded: false
     };
   }
 };
@@ -2144,14 +2302,14 @@ var handleFailure = async (request, requestPayload, qstashClient, initialPayload
 
 // src/serve/options.ts
 import { Receiver } from "@upstash/qstash";
-import { Client as Client2 } from "@upstash/qstash";
+import { Client as Client3 } from "@upstash/qstash";
 var processOptions = (options) => {
   const environment = options?.env ?? (typeof process === "undefined" ? {} : process.env);
   const receiverEnvironmentVariablesSet = Boolean(
     environment.QSTASH_CURRENT_SIGNING_KEY && environment.QSTASH_NEXT_SIGNING_KEY
   );
   return {
-    qstashClient: new Client2({
+    qstashClient: new Client3({
       baseUrl: environment.QSTASH_URL,
       token: environment.QSTASH_TOKEN
     }),
@@ -2192,6 +2350,7 @@ var processOptions = (options) => {
     baseUrl: environment.UPSTASH_WORKFLOW_URL,
     env: environment,
     retries: DEFAULT_RETRIES,
+    useJSONContent: false,
     ...options
   };
 };
@@ -2208,6 +2367,16 @@ var determineUrls = async (request, url, baseUrl, failureFunction, failureUrl, d
     });
   }
   const workflowFailureUrl = failureFunction ? workflowUrl : failureUrl;
+  if (workflowUrl.includes("localhost")) {
+    await debug?.log("WARN", "ENDPOINT_START", {
+      message: `Workflow URL contains localhost. This can happen in local development, but shouldn't happen in production unless you have a route which contains localhost. Received: ${workflowUrl}`
+    });
+  }
+  if (!(workflowUrl.startsWith("http://") || workflowUrl.startsWith("https://"))) {
+    throw new WorkflowError(
+      `Workflow URL should start with 'http://' or 'https://'. Recevied is '${workflowUrl}'`
+    );
+  }
   return {
     workflowUrl,
     workflowFailureUrl
@@ -2216,7 +2385,7 @@ var determineUrls = async (request, url, baseUrl, failureFunction, failureUrl, d
 var AUTH_FAIL_MESSAGE = `Failed to authenticate Workflow request. If this is unexpected, see the caveat https://upstash.com/docs/workflow/basics/caveats#avoid-non-deterministic-code-outside-context-run`;
 
 // src/serve/index.ts
-var serve = (routeFunction, options) => {
+var serveBase = (routeFunction, options) => {
   const {
     qstashClient,
     onStepFinish,
@@ -2228,7 +2397,8 @@ var serve = (routeFunction, options) => {
     failureFunction,
     baseUrl,
     env,
-    retries
+    retries,
+    useJSONContent
   } = processOptions(options);
   const debug = WorkflowLogger.getLogger(verbose);
   const handler = async (request) => {
@@ -2245,7 +2415,7 @@ var serve = (routeFunction, options) => {
     await verifyRequest(requestPayload, request.headers.get("upstash-signature"), receiver);
     const { isFirstInvocation, workflowRunId } = validateRequest(request);
     debug?.setWorkflowRunId(workflowRunId);
-    const { rawInitialPayload, steps, isLastDuplicate } = await parseRequest(
+    const { rawInitialPayload, steps, isLastDuplicate, workflowRunEnded } = await parseRequest(
       requestPayload,
       isFirstInvocation,
       workflowRunId,
@@ -2253,8 +2423,11 @@ var serve = (routeFunction, options) => {
       request.headers.get("upstash-message-id"),
       debug
     );
+    if (workflowRunEnded) {
+      return onStepFinish(workflowRunId, "workflow-already-ended");
+    }
     if (isLastDuplicate) {
-      return onStepFinish("no-workflow-id", "duplicate-step");
+      return onStepFinish(workflowRunId, "duplicate-step");
     }
     const failureCheck = await handleFailure(
       request,
@@ -2268,7 +2441,7 @@ var serve = (routeFunction, options) => {
       throw failureCheck.error;
     } else if (failureCheck.value === "is-failure-callback") {
       await debug?.log("WARN", "RESPONSE_DEFAULT", "failureFunction executed");
-      return onStepFinish("no-workflow-id", "failure-callback");
+      return onStepFinish(workflowRunId, "failure-callback");
     }
     const workflowContext = new WorkflowContext({
       qstashClient,
@@ -2311,7 +2484,7 @@ var serve = (routeFunction, options) => {
       });
       throw callReturnCheck.error;
     } else if (callReturnCheck.value === "continue-workflow") {
-      const result = isFirstInvocation ? await triggerFirstInvocation(workflowContext, retries, debug) : await triggerRouteFunction({
+      const result = isFirstInvocation ? await triggerFirstInvocation(workflowContext, retries, useJSONContent, debug) : await triggerRouteFunction({
         onStep: async () => routeFunction(workflowContext),
         onCleanup: async () => {
           await triggerWorkflowDelete(workflowContext, debug);
@@ -2327,6 +2500,8 @@ var serve = (routeFunction, options) => {
       }
       await debug?.log("INFO", "RESPONSE_WORKFLOW");
       return onStepFinish(workflowContext.workflowRunId, "success");
+    } else if (callReturnCheck.value === "workflow-ended") {
+      return onStepFinish(workflowContext.workflowRunId, "workflow-already-ended");
     }
     await debug?.log("INFO", "RESPONSE_DEFAULT");
     return onStepFinish("no-workflow-id", "fromCallback");
@@ -2343,198 +2518,24 @@ var serve = (routeFunction, options) => {
   };
   return { handler: safeHandler };
 };
-
-// src/client/index.ts
-import { Client as QStashClient } from "@upstash/qstash";
-var Client3 = class {
-  client;
-  constructor(clientConfig) {
-    if (!clientConfig.token) {
-      console.error(
-        "QStash token is required for Upstash Workflow!\n\nTo fix this:\n1. Get your token from the Upstash Console (https://console.upstash.com/qstash)\n2. Initialize the workflow client with:\n\n   const client = new Client({\n     token: '<YOUR_QSTASH_TOKEN>'\n   });"
-      );
-    }
-    this.client = new QStashClient(clientConfig);
-  }
-  /**
-   * Cancel an ongoing workflow
-   *
-   * Returns true if workflow is canceled succesfully. Otherwise, throws error.
-   *
-   * There are multiple ways you can cancel workflows:
-   * - pass one or more workflow run ids to cancel them
-   * - pass a workflow url to cancel all runs starting with this url
-   * - cancel all pending or active workflow runs
-   *
-   * ### Cancel a set of workflow runs
-   *
-   * ```ts
-   * // cancel a single workflow
-   * await client.cancel({ ids: "<WORKFLOW_RUN_ID>" })
-   *
-   * // cancel a set of workflow runs
-   * await client.cancel({ ids: [
-   *   "<WORKFLOW_RUN_ID_1>",
-   *   "<WORKFLOW_RUN_ID_2>",
-   * ]})
-   * ```
-   *
-   * ### Cancel workflows starting with a url
-   *
-   * If you have an endpoint called `https://your-endpoint.com` and you
-   * want to cancel all workflow runs on it, you can use `urlStartingWith`.
-   *
-   * Note that this will cancel workflows in all endpoints under
-   * `https://your-endpoint.com`.
-   *
-   * ```ts
-   * await client.cancel({ urlStartingWith: "https://your-endpoint.com" })
-   * ```
-   *
-   * ### Cancel *all* workflows
-   *
-   * To cancel all pending and currently running workflows, you can
-   * do it like this:
-   *
-   * ```ts
-   * await client.cancel({ all: true })
-   * ```
-   *
-   * @param ids run id of the workflow to delete
-   * @param urlStartingWith cancel workflows starting with this url. Will be ignored
-   *   if `ids` parameter is set.
-   * @param all set to true in order to cancel all workflows. Will be ignored
-   *   if `ids` or `urlStartingWith` parameters are set.
-   * @returns true if workflow is succesfully deleted. Otherwise throws QStashError
-   */
-  async cancel({
-    ids,
-    urlStartingWith,
-    all
-  }) {
-    let body;
-    if (ids) {
-      const runIdArray = typeof ids === "string" ? [ids] : ids;
-      body = JSON.stringify({ workflowRunIds: runIdArray });
-    } else if (urlStartingWith) {
-      body = JSON.stringify({ workflowUrl: urlStartingWith });
-    } else if (all) {
-      body = "{}";
-    } else {
-      throw new TypeError("The `cancel` method cannot be called without any options.");
-    }
-    const result = await this.client.http.request({
-      path: ["v2", "workflows", "runs"],
-      method: "DELETE",
-      body,
-      headers: {
-        "Content-Type": "application/json"
-      }
-    });
-    return result;
-  }
-  /**
-   * Notify a workflow run waiting for an event
-   *
-   * ```ts
-   * import { Client } from "@upstash/workflow";
-   *
-   * const client = new Client({ token: "<QSTASH_TOKEN>" })
-   * await client.notify({
-   *   eventId: "my-event-id",
-   *   eventData: "my-data" // data passed to the workflow run
-   * });
-   * ```
-   *
-   * @param eventId event id to notify
-   * @param eventData data to provide to the workflow
-   */
-  async notify({
-    eventId,
-    eventData
-  }) {
-    return await makeNotifyRequest(this.client.http, eventId, eventData);
-  }
-  /**
-   * Check waiters of an event
-   *
-   * ```ts
-   * import { Client } from "@upstash/workflow";
-   *
-   * const client = new Client({ token: "<QSTASH_TOKEN>" })
-   * const result = await client.getWaiters({
-   *   eventId: "my-event-id"
-   * })
-   * ```
-   *
-   * @param eventId event id to check
-   */
-  async getWaiters({ eventId }) {
-    return await makeGetWaitersRequest(this.client.http, eventId);
-  }
-  /**
-   * Trigger new workflow run and returns the workflow run id
-   *
-   * ```ts
-   * const { workflowRunId } = await client.trigger({
-   *   url: "https://workflow-endpoint.com",
-   *   body: "hello there!",         // Optional body
-   *   headers: { ... },             // Optional headers
-   *   workflowRunId: "my-workflow", // Optional workflow run ID
-   *   retries: 3                    // Optional retries for the initial request
-   * });
-   *
-   * console.log(workflowRunId)
-   * // wfr_my-workflow
-   * ```
-   *
-   * @param url URL of the workflow
-   * @param body body to start the workflow with
-   * @param headers headers to use in the request
-   * @param workflowRunId optional workflow run id to use. mind that
-   *   you should pass different workflow run ids for different runs.
-   *   The final workflowRunId will be `wfr_${workflowRunId}`, in
-   *   other words: the workflow run id you pass will be prefixed
-   *   with `wfr_`.
-   * @param retries retry to use in the initial request. in the rest of
-   *   the workflow, `retries` option of the `serve` will be used.
-   * @returns workflow run id
-   */
-  async trigger({
-    url,
-    body,
-    headers,
-    workflowRunId,
-    retries
-  }) {
-    const finalWorkflowRunId = getWorkflowRunId(workflowRunId);
-    const context = new WorkflowContext({
-      qstashClient: this.client,
-      // @ts-expect-error headers type mismatch
-      headers: new Headers(headers ?? {}),
-      initialPayload: body,
-      steps: [],
-      url,
-      workflowRunId: finalWorkflowRunId
-    });
-    const result = await triggerFirstInvocation(context, retries ?? DEFAULT_RETRIES);
-    if (result.isOk()) {
-      return { workflowRunId: finalWorkflowRunId };
-    } else {
-      throw result.error;
-    }
-  }
+var serve = (routeFunction, options) => {
+  return serveBase(routeFunction, options);
 };
 
 export {
   __require,
   __commonJS,
   __toESM,
+  makeNotifyRequest,
+  makeGetWaitersRequest,
   WorkflowError,
   WorkflowAbort,
+  DEFAULT_RETRIES,
   StepTypes,
+  triggerFirstInvocation,
   WorkflowContext,
   WorkflowLogger,
-  serve,
-  Client3 as Client
+  getWorkflowRunId,
+  serveBase,
+  serve
 };

package/cloudflare.d.mts

@@ -1,4 +1,4 @@
-import { R as RouteFunction, W as WorkflowServeOptions } from './types-Be4hC1mu.mjs';
+import { R as RouteFunction, j as PublicServeOptions } from './types-R9q4MUwl.mjs';
 import '@upstash/qstash';
 
 type WorkflowBindings = {
@@ -28,7 +28,7 @@ type WorkersHandlerArgs = [Request, Record<string, string | undefined>];
  * @param options workflow options
  * @returns
  */
-declare const serve: <TInitialPayload = unknown>(routeFunction: RouteFunction<TInitialPayload>, options?: Omit<WorkflowServeOptions<Response, TInitialPayload>, "onStepFinish">) => {
+declare const serve: <TInitialPayload = unknown>(routeFunction: RouteFunction<TInitialPayload>, options?: PublicServeOptions<TInitialPayload>) => {
     fetch: (...args: PagesHandlerArgs | WorkersHandlerArgs) => Promise<Response>;
 };
 

package/cloudflare.d.ts

@@ -1,4 +1,4 @@
-import { R as RouteFunction, W as WorkflowServeOptions } from './types-Be4hC1mu.js';
+import { R as RouteFunction, j as PublicServeOptions } from './types-R9q4MUwl.js';
 import '@upstash/qstash';
 
 type WorkflowBindings = {
@@ -28,7 +28,7 @@ type WorkersHandlerArgs = [Request, Record<string, string | undefined>];
  * @param options workflow options
  * @returns
  */
-declare const serve: <TInitialPayload = unknown>(routeFunction: RouteFunction<TInitialPayload>, options?: Omit<WorkflowServeOptions<Response, TInitialPayload>, "onStepFinish">) => {
+declare const serve: <TInitialPayload = unknown>(routeFunction: RouteFunction<TInitialPayload>, options?: PublicServeOptions<TInitialPayload>) => {
     fetch: (...args: PagesHandlerArgs | WorkersHandlerArgs) => Promise<Response>;
 };