@upstash/workflow 1.2.0-demo-rc.1 → 1.2.1

package/index.js

@@ -133,9 +133,10 @@ function isInstanceOf(v, ctor) {
 }
 
 // src/client/utils.ts
-var makeNotifyRequest = async (requester, eventId, eventData) => {
+var makeNotifyRequest = async (requester, eventId, eventData, workflowRunId) => {
+  const path = workflowRunId ? ["v2", "notify", workflowRunId, eventId] : ["v2", "notify", eventId];
   const result = await requester.request({
-    path: ["v2", "notify", eventId],
+    path,
     method: "POST",
     body: typeof eventData === "string" ? eventData : JSON.stringify(eventData)
   });
@@ -195,11 +196,72 @@ var getSteps = async (requester, workflowRunId, messageId, dispatchDebug) => {
     }
   }
 };
+function normalizeCursor(response) {
+  const cursor = response.cursor;
+  return { ...response, cursor: cursor || void 0 };
+}
+var DEFAULT_BULK_COUNT = 100;
+function buildBulkActionQueryParameters(request, options) {
+  const cursor = "cursor" in request ? request.cursor : void 0;
+  if ("all" in request) {
+    return { count: request.count ?? DEFAULT_BULK_COUNT, cursor };
+  }
+  if ("dlqIds" in request) {
+    const ids = request.dlqIds;
+    if (Array.isArray(ids) && ids.length === 0) {
+      throw new import_qstash2.QstashError(
+        "Empty dlqIds array provided. If you intend to target all DLQ messages, use { all: true } explicitly."
+      );
+    }
+    return { dlqIds: ids, cursor };
+  }
+  if ("workflowRunIds" in request && request.workflowRunIds) {
+    if (request.workflowRunIds.length === 0) {
+      throw new import_qstash2.QstashError(
+        "Empty workflowRunIds array provided. If you intend to target all workflow runs, use { all: true } explicitly."
+      );
+    }
+    return { workflowRunIds: request.workflowRunIds };
+  }
+  const filter = request.filter;
+  if (!filter) {
+    throw new import_qstash2.QstashError(
+      "No filter provided. Use { filter: { ... } } with at least one filter field, or { all: true }."
+    );
+  }
+  if (options?.translateWorkflowUrl) {
+    const { workflowUrlStartingWith, workflowUrl, ...rest } = filter;
+    if (workflowUrlStartingWith && workflowUrl) {
+      throw new import_qstash2.QstashError(
+        "workflowUrl and workflowUrlStartingWith are mutually exclusive. Use workflowUrl for exact match or workflowUrlStartingWith for prefix match."
+      );
+    }
+    const urlParams = {};
+    if (workflowUrlStartingWith) {
+      urlParams.workflowUrl = workflowUrlStartingWith;
+    } else if (workflowUrl) {
+      urlParams.workflowUrl = workflowUrl;
+      urlParams.workflowUrlExactMatch = true;
+    }
+    return {
+      ...rest,
+      ...urlParams,
+      count: request.count ?? DEFAULT_BULK_COUNT,
+      cursor
+    };
+  }
+  return {
+    ...filter,
+    count: request.count ?? DEFAULT_BULK_COUNT,
+    cursor
+  };
+}
 
 // src/constants.ts
 var WORKFLOW_ID_HEADER = "Upstash-Workflow-RunId";
 var WORKFLOW_INIT_HEADER = "Upstash-Workflow-Init";
 var WORKFLOW_URL_HEADER = "Upstash-Workflow-Url";
+var WORKFLOW_CREATED_AT_HEADER = "Upstash-Workflow-CreatedAt";
 var WORKFLOW_FAILURE_HEADER = "Upstash-Workflow-Is-Failure";
 var WORKFLOW_FAILURE_CALLBACK_HEADER = "Upstash-Workflow-Failure-Callback";
 var WORKFLOW_FEATURE_HEADER = "Upstash-Feature-Set";
@@ -735,6 +797,7 @@ var triggerFirstInvocation = async (params) => {
       retries,
       retryDelay,
       flowControl,
+      redact,
       unknownSdk
     }) => {
       const { headers } = getHeaders({
@@ -771,7 +834,8 @@ var triggerFirstInvocation = async (params) => {
         body,
         url: workflowContext.url,
         delay,
-        notBefore
+        notBefore,
+        redact
       };
     }
   );
@@ -930,7 +994,6 @@ ${atob(callbackMessage.body ?? "")}`
           })}`
         );
       }
-      const userHeaders = recreateUserHeaders(request.headers);
       const { headers: requestHeaders } = getHeaders({
         initHeaderValue: "false",
         workflowConfig: {
@@ -938,7 +1001,6 @@ ${atob(callbackMessage.body ?? "")}`
           workflowUrl,
           telemetry
         },
-        userHeaders,
         invokeCount: Number(invokeCount)
       });
       const callResponse = {
@@ -1087,7 +1149,6 @@ var BaseLazyStep = class _BaseLazyStep {
         useJSONContent: false,
         telemetry
       },
-      userHeaders: context.headers,
       invokeCount,
       stepInfo: {
         step,
@@ -1445,9 +1506,9 @@ var LazyWaitEventStep = class extends BaseLazyStep {
 };
 var LazyNotifyStep = class extends LazyFunctionStep {
   stepType = "Notify";
-  constructor(context, stepName, eventId, eventData, requester) {
+  constructor(context, stepName, eventId, eventData, requester, workflowRunId) {
     super(context, stepName, async () => {
-      const notifyResponse = await makeNotifyRequest(requester, eventId, eventData);
+      const notifyResponse = await makeNotifyRequest(requester, eventId, eventData, workflowRunId);
       return {
         eventId,
         eventData,
@@ -1517,7 +1578,6 @@ var LazyInvokeStep = class extends BaseLazyStep {
         telemetry,
         useJSONContent: false
       },
-      userHeaders: context.headers,
       invokeCount
     });
     context.qstashClient.http.headers?.forEach((value, key) => {
@@ -1530,6 +1590,7 @@ var LazyInvokeStep = class extends BaseLazyStep {
         Object.entries(invokerHeaders).map((pairs) => [pairs[0], [pairs[1]]])
       ),
       workflowRunId: context.workflowRunId,
+      workflowRunCreatedAt: context.workflowRunCreatedAt,
       workflowUrl: context.url,
       step
     };
@@ -1625,12 +1686,14 @@ var LazyWaitForWebhookStep = class extends LazyWaitEventStep {
     const parsedEventData = BaseLazyStep.tryParsing(eventData);
     const body = parsedEventData.body;
     const parsedBody = typeof body === "string" ? decodeBase64(body) : void 0;
+    const methodUpper = parsedEventData.method.toUpperCase();
+    const canHaveBody = methodUpper !== "GET" && methodUpper !== "HEAD";
     const request = new Request(
       `${parsedEventData.proto}://${parsedEventData.host}${parsedEventData.url}`,
       {
         method: parsedEventData.method,
         headers: parsedEventData.header,
-        body: parsedBody
+        body: canHaveBody ? parsedBody : void 0
       }
     );
     return {
@@ -1764,6 +1827,9 @@ var WorkflowHeaders = class {
     }
   }
   addUserHeaders() {
+    if (!this.userHeaders) {
+      return;
+    }
     for (const [key, value] of this.userHeaders.entries()) {
       const forwardKey = `Forward-${key}`;
       this.headers.workflowHeaders[forwardKey] = value;
@@ -1870,7 +1936,6 @@ var submitParallelSteps = async ({
           workflowUrl: context.url,
           telemetry
         },
-        userHeaders: context.headers,
         invokeCount
       });
       return {
@@ -2123,7 +2188,7 @@ var AutoExecutor = class _AutoExecutor {
           });
           throw new WorkflowAbort(parallelStep.stepName, resultStep);
         } catch (error) {
-          if (isInstanceOf(error, WorkflowAbort) || isInstanceOf(error, import_qstash5.QstashError) && error.status === 400) {
+          if (isInstanceOf(error, WorkflowAbort) || isInstanceOf(error, import_qstash5.QstashError) && error.status === 400 || isInstanceOf(error, import_qstash5.QstashError) && error.status === 412) {
             throw error;
           }
           throw new WorkflowError(
@@ -2530,6 +2595,7 @@ var MiddlewareManager = class {
 };
 
 // src/context/context.ts
+var import_qstash9 = require("@upstash/qstash");
 var WorkflowContext = class {
   executor;
   steps;
@@ -2556,6 +2622,10 @@ var WorkflowContext = class {
    * Run id of the workflow
    */
   workflowRunId;
+  /**
+   * Creation time of the workflow run
+   */
+  workflowRunCreatedAt;
   /**
    * URL of the workflow
    *
@@ -2647,6 +2717,7 @@ var WorkflowContext = class {
   constructor({
     qstashClient,
     workflowRunId,
+    workflowRunCreatedAt,
     headers,
     steps,
     url,
@@ -2659,6 +2730,7 @@ var WorkflowContext = class {
   }) {
     this.qstashClient = qstashClient;
     this.workflowRunId = workflowRunId;
+    this.workflowRunCreatedAt = workflowRunCreatedAt;
     this.steps = steps;
     this.url = url;
     this.headers = headers;
@@ -2833,14 +2905,23 @@ var WorkflowContext = class {
    * a notifyResponse field which contains a list of `Waiter` objects, each corresponding
    * to a notified workflow run.
    *
+   * Optionally, you can pass a workflowRunId to enable lookback functionality:
+   *
+   * ```ts
+   * const { eventId, eventData, notifyResponse } = await context.notify(
+   *   "notify step", "event-id", "event-data", "wfr_123"
+   * );
+   * ```
+   *
    * @param stepName
    * @param eventId event id to notify
    * @param eventData event data to notify with
+   * @param workflowRunId optional workflow run id for lookback support
    * @returns notify response which has event id, event data and list of waiters which were notified
    */
-  async notify(stepName, eventId, eventData) {
+  async notify(stepName, eventId, eventData, workflowRunId) {
     return await this.addStep(
-      new LazyNotifyStep(this, stepName, eventId, eventData, this.qstashClient.http)
+      new LazyNotifyStep(this, stepName, eventId, eventData, this.qstashClient.http, workflowRunId)
     );
   }
   async invoke(stepName, settings) {
@@ -2868,7 +2949,14 @@ var WorkflowContext = class {
    * DisabledWorkflowContext.
    */
   async addStep(step) {
-    return await this.executor.addStep(step);
+    try {
+      return await this.executor.addStep(step);
+    } catch (error) {
+      if (isInstanceOf(error, import_qstash9.QstashError) && error.status === 412) {
+        throw new WorkflowNonRetryableError(error.message);
+      }
+      throw error;
+    }
   }
   get api() {
     return new WorkflowApi({
@@ -2877,214 +2965,8 @@ var WorkflowContext = class {
   }
 };
 
-// src/dev-server.ts
-var import_child_process = require("child_process");
-var import_fs = require("fs");
-var import_https = require("https");
-var import_http = require("http");
-var import_path = require("path");
-var import_os = require("os");
-var DEV_QSTASH_TOKEN = "eyJVc2VySUQiOiJkZWZhdWx0VXNlciIsIlBhc3N3b3JkIjoiZGVmYXVsdFBhc3N3b3JkIn0=";
-var DEV_QSTASH_CURRENT_SIGNING_KEY = "sig_7kYjw48mhY7kAjqNGcy6cr29RJ6r";
-var DEV_QSTASH_NEXT_SIGNING_KEY = "sig_5ZB6DVzB1wjE8S6rZ7eenA8Pdnhs";
-function getDevCredentials(port) {
-  return {
-    QSTASH_URL: `http://localhost:${port}`,
-    QSTASH_TOKEN: DEV_QSTASH_TOKEN,
-    QSTASH_CURRENT_SIGNING_KEY: DEV_QSTASH_CURRENT_SIGNING_KEY,
-    QSTASH_NEXT_SIGNING_KEY: DEV_QSTASH_NEXT_SIGNING_KEY
-  };
-}
-var CACHE_DIR = (0, import_path.join)("node_modules", ".cache", "upstash");
-function getPlatformArch() {
-  const platform = process.platform === "darwin" ? "darwin" : "linux";
-  const arch = process.arch === "arm64" ? "arm64" : "amd64";
-  return { platform, arch };
-}
-function httpsGet(url) {
-  return new Promise((resolve, reject) => {
-    const request = (currentUrl) => {
-      (0, import_https.get)(currentUrl, { headers: { "User-Agent": "upstash-workflow" } }, (res) => {
-        if (res.statusCode && res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
-          request(res.headers.location);
-          return;
-        }
-        if (res.statusCode && res.statusCode >= 400) {
-          reject(new Error(`HTTP ${res.statusCode} fetching ${currentUrl}`));
-          return;
-        }
-        const chunks = [];
-        res.on("data", (chunk) => chunks.push(chunk));
-        res.on("end", () => resolve(Buffer.concat(chunks)));
-        res.on("error", reject);
-      }).on("error", reject);
-    };
-    request(url);
-  });
-}
-function downloadToFile(url, dest) {
-  return new Promise((resolve, reject) => {
-    const request = (currentUrl) => {
-      (0, import_https.get)(currentUrl, { headers: { "User-Agent": "upstash-workflow" } }, (res) => {
-        if (res.statusCode && res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
-          request(res.headers.location);
-          return;
-        }
-        if (res.statusCode && res.statusCode >= 400) {
-          reject(new Error(`HTTP ${res.statusCode} downloading ${currentUrl}`));
-          return;
-        }
-        const file = (0, import_fs.createWriteStream)(dest);
-        res.pipe(file);
-        file.on("finish", () => {
-          file.close(() => resolve());
-        });
-        file.on("error", reject);
-      }).on("error", reject);
-    };
-    request(url);
-  });
-}
-async function resolveLatestVersion() {
-  const data = await httpsGet("https://api.github.com/repos/upstash/qstash-cli/releases/latest");
-  const json = JSON.parse(data.toString());
-  return json.tag_name;
-}
-async function ensureBinary() {
-  const version = await resolveLatestVersion();
-  const cacheDir = (0, import_path.join)(CACHE_DIR, `qstash-server-${version}`);
-  const binaryPath = (0, import_path.join)(cacheDir, "qstash");
-  if ((0, import_fs.existsSync)(binaryPath)) {
-    return binaryPath;
-  }
-  const { platform, arch } = getPlatformArch();
-  const downloadUrl = `https://artifacts.upstash.com/qstash/versions/${version}/qstash-server_${version}_${platform}_${arch}.tar.gz`;
-  console.log(`[workflow-dev] Downloading QStash server...`);
-  (0, import_fs.mkdirSync)(cacheDir, { recursive: true });
-  const tempFile = (0, import_path.join)((0, import_os.tmpdir)(), `qstash-server-${version}-${Date.now()}.tar.gz`);
-  await downloadToFile(downloadUrl, tempFile);
-  (0, import_child_process.execSync)(`tar -xzf "${tempFile}" -C "${cacheDir}"`);
-  (0, import_fs.chmodSync)(binaryPath, 493);
-  return binaryPath;
-}
-function startServer(binaryPath, port) {
-  return new Promise((resolve, reject) => {
-    const child = (0, import_child_process.spawn)(binaryPath, ["dev", "-port", String(port)], {
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-    let resolved = false;
-    const cleanup = () => {
-      if (!child.killed) {
-        child.kill("SIGTERM");
-      }
-    };
-    process.on("exit", cleanup);
-    process.on("SIGINT", () => {
-      cleanup();
-      process.exit(0);
-    });
-    process.on("SIGTERM", () => {
-      cleanup();
-      process.exit(0);
-    });
-    let stdoutBuffer = "";
-    child.stdout.on("data", (data) => {
-      const text = data.toString();
-      stdoutBuffer += text;
-      const lines = stdoutBuffer.split("\n");
-      stdoutBuffer = lines.pop() ?? "";
-      for (const line of lines) {
-        if (line.match(/runn+ing at/) && !resolved) {
-          resolved = true;
-          const creds = getDevCredentials(port);
-          console.log(`[workflow-dev] QStash server running at ${creds.QSTASH_URL}`);
-          console.log(
-            `[workflow-dev] View logs at \x1B[1;32mhttps://console.upstash.com/workflow/local-mode-user/logs\x1B[0m`
-          );
-          resolve(cleanup);
-        }
-      }
-    });
-    child.stderr.on("data", (data) => {
-      const text = data.toString();
-      if (!resolved) {
-        process.stderr.write(`[workflow-dev] ${text}`);
-      }
-    });
-    child.on("error", (err2) => {
-      if (!resolved) {
-        reject(new Error(`[workflow-dev] Failed to start QStash server: ${err2.message}`));
-      }
-    });
-    child.on("exit", (code) => {
-      if (!resolved) {
-        reject(
-          new Error(`[workflow-dev] QStash server exited with code ${code} before becoming ready`)
-        );
-      }
-    });
-    setTimeout(() => {
-      if (!resolved) {
-        cleanup();
-        reject(new Error("[workflow-dev] QStash server did not become ready within 30 seconds"));
-      }
-    }, 3e4);
-  });
-}
-function isDevServerRunning(port) {
-  return new Promise((resolve) => {
-    const req = (0, import_http.get)(
-      `http://127.0.0.1:${port}/v2/keys`,
-      {
-        headers: { Authorization: `Bearer ${DEV_QSTASH_TOKEN}` },
-        timeout: 2e3
-      },
-      (res) => {
-        if (res.statusCode !== 200) {
-          resolve(false);
-          return;
-        }
-        const chunks = [];
-        res.on("data", (chunk) => chunks.push(chunk));
-        res.on("end", () => {
-          try {
-            const body = JSON.parse(Buffer.concat(chunks).toString());
-            resolve(
-              body.current === DEV_QSTASH_CURRENT_SIGNING_KEY && body.next === DEV_QSTASH_NEXT_SIGNING_KEY
-            );
-          } catch {
-            resolve(false);
-          }
-        });
-        res.on("error", () => resolve(false));
-      }
-    );
-    req.on("error", () => resolve(false));
-    req.on("timeout", () => {
-      req.destroy();
-      resolve(false);
-    });
-  });
-}
-var serverPromise = null;
-var serverCleanup = null;
-function ensureDevServer(environment) {
-  if (!serverPromise) {
-    const port = Number(environment.WORKFLOW_DEV_PORT) || 8080;
-    serverPromise = isDevServerRunning(port).then((alreadyRunning) => {
-      if (alreadyRunning) {
-        return;
-      }
-      return ensureBinary().then((binaryPath) => startServer(binaryPath, port)).then((cleanup) => {
-        serverCleanup = cleanup;
-      });
-    });
-  }
-  return serverPromise;
-}
-
 // src/serve/authorization.ts
-var import_qstash9 = require("@upstash/qstash");
+var import_qstash10 = require("@upstash/qstash");
 var DisabledWorkflowContext = class _DisabledWorkflowContext extends WorkflowContext {
   static disabledMessage = "disabled-qstash-worklfow-run";
   disabled = true;
@@ -3116,11 +2998,12 @@ var DisabledWorkflowContext = class _DisabledWorkflowContext extends WorkflowCon
    */
   static async tryAuthentication(routeFunction, context) {
     const disabledContext = new _DisabledWorkflowContext({
-      qstashClient: new import_qstash9.Client({
+      qstashClient: new import_qstash10.Client({
         baseUrl: "disabled-client",
         token: "disabled-client"
       }),
       workflowRunId: context.workflowRunId,
+      workflowRunCreatedAt: context.workflowRunCreatedAt,
       headers: context.headers,
       steps: [],
       url: context.url,
@@ -3322,7 +3205,9 @@ var handleFailure = async ({
     return ok({ result: "failure-function-undefined" });
   }
   try {
-    const { status, header, body, url, sourceBody, workflowRunId } = JSON.parse(requestPayload);
+    const { status, header, body, url, sourceBody, workflowRunId, workflowCreatedAt } = JSON.parse(
+      requestPayload
+    );
     const decodedBody = body ? decodeBase64(body) : "{}";
     let errorMessage = "";
     let failStack = "";
@@ -3351,6 +3236,7 @@ var handleFailure = async ({
       telemetry: void 0,
       // not going to make requests in authentication check
       label: userHeaders.get(WORKFLOW_LABEL_HEADER) ?? void 0,
+      workflowRunCreatedAt: workflowCreatedAt,
       middlewareManager: void 0
     });
     const authCheck = await DisabledWorkflowContext.tryAuthentication(
@@ -3379,7 +3265,7 @@ var handleFailure = async ({
 };
 
 // src/serve/multi-region/handlers.ts
-var import_qstash10 = require("@upstash/qstash");
+var import_qstash11 = require("@upstash/qstash");
 
 // src/serve/multi-region/utils.ts
 var VALID_REGIONS = ["EU_CENTRAL_1", "US_EAST_1"];
@@ -3444,7 +3330,7 @@ var getHandlersForRequest = (qstashHandlers, regionHeader, isFirstInvocation) =>
 };
 var createRegionalHandler = (environment, receiverConfig, region, clientOptions) => {
   const clientEnv = readClientEnvironmentVariables(environment, region);
-  const client = new import_qstash10.Client({
+  const client = new import_qstash11.Client({
     ...clientOptions,
     baseUrl: clientEnv.QSTASH_URL,
     token: clientEnv.QSTASH_TOKEN
@@ -3494,7 +3380,7 @@ var getQStashHandlers = ({
     return {
       mode: "single-region",
       handlers: {
-        client: qstashClientOption && "http" in qstashClientOption ? qstashClientOption : new import_qstash10.Client({
+        client: qstashClientOption && "http" in qstashClientOption ? qstashClientOption : new import_qstash11.Client({
           ...qstashClientOption,
           baseUrl: environment.QSTASH_URL,
           token: environment.QSTASH_TOKEN
@@ -3510,7 +3396,7 @@ var getReceiver = (environment, receiverConfig, region) => {
       return void 0;
     }
     const receiverEnv = readReceiverEnvironmentVariables(environment, region);
-    return receiverEnv.QSTASH_CURRENT_SIGNING_KEY && receiverEnv.QSTASH_NEXT_SIGNING_KEY ? new import_qstash10.Receiver({
+    return receiverEnv.QSTASH_CURRENT_SIGNING_KEY && receiverEnv.QSTASH_NEXT_SIGNING_KEY ? new import_qstash11.Receiver({
       currentSigningKey: receiverEnv.QSTASH_CURRENT_SIGNING_KEY,
       nextSigningKey: receiverEnv.QSTASH_NEXT_SIGNING_KEY
     }) : void 0;
@@ -3736,33 +3622,19 @@ var AUTH_FAIL_MESSAGE = `Failed to authenticate Workflow request. If this is une
 
 // src/serve/index.ts
 var serveBase = (routeFunction, telemetry, options, internalOptions) => {
-  const environment = options?.env ?? (typeof process === "undefined" ? {} : process.env);
-  const devMode = environment.WORKFLOW_DEV === "true";
-  if (devMode) {
-    const port = Number(environment.WORKFLOW_DEV_PORT) || 8080;
-    const creds = getDevCredentials(port);
-    for (const [k, v] of Object.entries(creds)) {
-      if (!environment[k]) {
-        environment[k] = v;
-      }
-    }
-  }
-  const resolvedOptions = processOptions(
-    options,
-    internalOptions
-  );
+  const {
+    initialPayloadParser,
+    url,
+    failureFunction,
+    baseUrl,
+    env,
+    disableTelemetry,
+    middlewares,
+    internal
+  } = processOptions(options, internalOptions);
+  telemetry = disableTelemetry ? void 0 : telemetry;
+  const { generateResponse: responseGenerator, useJSONContent } = internal;
   const handler = async (request, middlewareManager) => {
-    const {
-      initialPayloadParser,
-      url,
-      failureFunction,
-      baseUrl,
-      env,
-      disableTelemetry: optDisableTelemetry,
-      internal
-    } = resolvedOptions;
-    const currentTelemetry = optDisableTelemetry ? void 0 : telemetry;
-    const { generateResponse: responseGenerator, useJSONContent } = internal;
     await middlewareManager.dispatchDebug("onInfo", {
       info: `Received request for workflow execution.`
     });
@@ -3842,6 +3714,7 @@ var serveBase = (routeFunction, telemetry, options, internalOptions) => {
     }
     const invokeCount = Number(request.headers.get(WORKFLOW_INVOKE_COUNT_HEADER) ?? "0");
     const label = request.headers.get(WORKFLOW_LABEL_HEADER) ?? void 0;
+    const workflowRunCreatedAt = request.headers.get(WORKFLOW_CREATED_AT_HEADER);
     const workflowContext = new WorkflowContext({
       qstashClient: regionalClient,
       workflowRunId,
@@ -3850,9 +3723,10 @@ var serveBase = (routeFunction, telemetry, options, internalOptions) => {
       steps,
       url: workflowUrl,
       env,
-      telemetry: currentTelemetry,
+      telemetry,
       invokeCount,
       label,
+      workflowRunCreatedAt: Number(workflowRunCreatedAt),
       middlewareManager
     });
     const authCheck = await DisabledWorkflowContext.tryAuthentication(
@@ -3876,7 +3750,7 @@ var serveBase = (routeFunction, telemetry, options, internalOptions) => {
       requestPayload: rawInitialPayload,
       client: regionalClient,
       workflowUrl,
-      telemetry: currentTelemetry,
+      telemetry,
       middlewareManager
     });
     if (callReturnCheck.isErr()) {
@@ -3885,7 +3759,7 @@ var serveBase = (routeFunction, telemetry, options, internalOptions) => {
       const result = isFirstInvocation ? await triggerFirstInvocation({
         workflowContext,
         useJSONContent,
-        telemetry: currentTelemetry,
+        telemetry,
         invokeCount,
         middlewareManager,
         unknownSdk
@@ -3953,9 +3827,7 @@ var serveBase = (routeFunction, telemetry, options, internalOptions) => {
     );
   };
   const safeHandler = async (request) => {
-    const middlewareManager = new MiddlewareManager(
-      resolvedOptions.middlewares
-    );
+    const middlewareManager = new MiddlewareManager(middlewares);
     try {
       return await handler(request, middlewareManager);
     } catch (error) {
@@ -3985,10 +3857,22 @@ var serve = (routeFunction, options) => {
 };
 
 // src/client/index.ts
-var import_qstash11 = require("@upstash/qstash");
+var import_qstash12 = require("@upstash/qstash");
 
 // src/client/dlq.ts
-var DLQ = class _DLQ {
+function buildResumeRestartHeaders(options) {
+  const headers = {};
+  if (options?.flowControl) {
+    const { flowControlKey, flowControlValue } = prepareFlowControl(options.flowControl);
+    headers["Upstash-Flow-Control-Key"] = flowControlKey;
+    headers["Upstash-Flow-Control-Value"] = flowControlValue;
+  }
+  if (options?.retries !== void 0) {
+    headers["Upstash-Retries"] = options.retries.toString();
+  }
+  return headers;
+}
+var DLQ = class {
   constructor(client) {
     this.client = client;
   }
@@ -4011,40 +3895,66 @@ var DLQ = class _DLQ {
    */
   async list(parameters) {
     const { cursor, count, filter } = parameters || {};
-    return await this.client.http.request({
-      path: ["v2", "dlq"],
-      method: "GET",
-      query: {
-        cursor,
-        count,
-        ...filter,
-        source: "workflow"
-      }
-    });
+    return normalizeCursor(
+      await this.client.http.request({
+        path: ["v2", "dlq"],
+        method: "GET",
+        query: {
+          cursor,
+          count,
+          ...filter,
+          source: "workflow"
+        }
+      })
+    );
   }
-  async resume(parameters) {
-    const { headers, queryParams } = _DLQ.handleDLQOptions(parameters);
-    const { workflowRuns } = await this.client.http.request({
-      path: ["v2", "workflows", "dlq", `resume?${queryParams}`],
-      headers,
-      method: "POST"
-    });
-    if (Array.isArray(parameters.dlqId)) {
-      return workflowRuns;
+  async resume(request, options) {
+    if (typeof request === "object" && !Array.isArray(request) && "dlqId" in request) {
+      const { dlqId, flowControl, retries } = request;
+      const dlqIds = Array.isArray(dlqId) ? dlqId : [dlqId];
+      const { workflowRuns } = await this.client.http.request({
+        path: ["v2", "workflows", "dlq", "resume"],
+        query: { dlqIds },
+        method: "POST",
+        headers: buildResumeRestartHeaders({ flowControl, retries })
+      });
+      return Array.isArray(dlqId) ? workflowRuns : workflowRuns[0];
     }
-    return workflowRuns[0];
+    if (typeof request === "string") request = [request];
+    if (Array.isArray(request) && request.length === 0) return { workflowRuns: [] };
+    const filters = Array.isArray(request) ? { dlqIds: request } : request;
+    return normalizeCursor(
+      await this.client.http.request({
+        path: ["v2", "workflows", "dlq", "resume"],
+        query: buildBulkActionQueryParameters(filters),
+        method: "POST",
+        headers: buildResumeRestartHeaders(options)
+      })
+    );
   }
-  async restart(parameters) {
-    const { headers, queryParams } = _DLQ.handleDLQOptions(parameters);
-    const { workflowRuns } = await this.client.http.request({
-      path: ["v2", "workflows", "dlq", `restart?${queryParams}`],
-      headers,
-      method: "POST"
-    });
-    if (Array.isArray(parameters.dlqId)) {
-      return workflowRuns;
+  async restart(request, options) {
+    if (typeof request === "object" && !Array.isArray(request) && "dlqId" in request) {
+      const { dlqId, flowControl, retries } = request;
+      const dlqIds = Array.isArray(dlqId) ? dlqId : [dlqId];
+      const { workflowRuns } = await this.client.http.request({
+        path: ["v2", "workflows", "dlq", "restart"],
+        query: { dlqIds },
+        method: "POST",
+        headers: buildResumeRestartHeaders({ flowControl, retries })
+      });
+      return Array.isArray(dlqId) ? workflowRuns : workflowRuns[0];
     }
-    return workflowRuns[0];
+    if (typeof request === "string") request = [request];
+    if (Array.isArray(request) && request.length === 0) return { workflowRuns: [] };
+    const filters = Array.isArray(request) ? { dlqIds: request } : request;
+    return normalizeCursor(
+      await this.client.http.request({
+        path: ["v2", "workflows", "dlq", "restart"],
+        query: buildBulkActionQueryParameters(filters),
+        method: "POST",
+        headers: buildResumeRestartHeaders(options)
+      })
+    );
   }
   /**
    * Retry the failure callback of a workflow run whose failureUrl/failureFunction
@@ -4061,148 +3971,64 @@ var DLQ = class _DLQ {
     return response;
   }
   /**
-   * Handles DLQ options and prepares headers and query parameters.
+   * Delete DLQ messages.
    *
-   * @param options - DLQ resume/restart options
-   */
-  static handleDLQOptions(options) {
-    const { dlqId, flowControl, retries } = options;
-    const headers = {};
-    if (flowControl) {
-      const { flowControlKey, flowControlValue } = prepareFlowControl(flowControl);
-      headers["Upstash-Flow-Control-Key"] = flowControlKey;
-      headers["Upstash-Flow-Control-Value"] = flowControlValue;
-    }
-    if (retries !== void 0) {
-      headers["Upstash-Retries"] = retries.toString();
-    }
-    return {
-      queryParams: _DLQ.getDlqIdQueryParameter(dlqId),
-      headers
-    };
-  }
-  /**
-   * Converts DLQ ID(s) to query parameter string.
+   * Can be called with:
+   * - A single dlqId: `delete("id")`
+   * - An array of dlqIds: `delete(["id1", "id2"])`
+   * - A filter object: `delete({ filter: { label: "my-label", fromDate: 1640995200000 } })`
+   * - To target all entries: `delete({ all: true })`
    *
-   * @param dlqId - Single DLQ ID or array of DLQ IDs
+   * Processes up to `count` messages per call (defaults to 100).
+   * Call in a loop until cursor is undefined to process all:
+   *
+   * ```ts
+   * let cursor: string | undefined;
+   * do {
+   *   const result = await client.dlq.delete({ all: true, count: 100, cursor });
+   *   cursor = result.cursor;
+   * } while (cursor);
+   * ```
    */
-  static getDlqIdQueryParameter(dlqId) {
-    const dlqIds = Array.isArray(dlqId) ? dlqId : [dlqId];
-    const paramsArray = dlqIds.map((id) => ["dlqIds", id]);
-    return new URLSearchParams(paramsArray).toString();
+  async delete(request) {
+    if (typeof request === "string") request = [request];
+    if (Array.isArray(request) && request.length === 0) return { deleted: 0 };
+    const filters = Array.isArray(request) ? { dlqIds: request } : request;
+    return normalizeCursor(
+      await this.client.http.request({
+        path: ["v2", "workflows", "dlq"],
+        method: "DELETE",
+        query: buildBulkActionQueryParameters(filters)
+      })
+    );
   }
 };
 
 // src/client/index.ts
 var Client4 = class {
   client;
-  devMode;
   constructor(clientConfig) {
-    const env = typeof process === "undefined" ? {} : process.env;
-    this.devMode = env.WORKFLOW_DEV === "true";
-    if (this.devMode) {
-      const port = Number(env.WORKFLOW_DEV_PORT) || 8080;
-      const creds = getDevCredentials(port);
-      this.client = new import_qstash11.Client({
-        ...clientConfig,
-        token: DEV_QSTASH_TOKEN,
-        baseUrl: creds.QSTASH_URL
-      });
-    } else if (!clientConfig) {
-      throw new Error(
-        "[Upstash Workflow] Client requires a token. Either pass { token: '...' } or set WORKFLOW_DEV=true."
-      );
-    } else {
-      this.client = new import_qstash11.Client(clientConfig);
-    }
-  }
-  /**
-   * In dev mode, ensures the dev server is running before making requests.
-   * If a server is already listening on the port (started by another process
-   * or by a platform's serve()), this is a no-op.
-   */
-  async ensureReady() {
-    if (this.devMode) {
-      await ensureDevServer(process.env);
-    }
-  }
-  /**
-   * 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
-  }) {
-    await this.ensureReady();
-    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.");
+    this.client = new import_qstash12.Client(clientConfig);
+  }
+  async cancel(request) {
+    if (typeof request === "object" && !Array.isArray(request) && ("ids" in request || "urlStartingWith" in request)) {
+      const legacy = request;
+      if (legacy.ids) {
+        const ids = typeof legacy.ids === "string" ? [legacy.ids] : legacy.ids;
+        return this.cancel(ids);
+      }
+      if (legacy.urlStartingWith) {
+        return this.cancel({ filter: { workflowUrlStartingWith: legacy.urlStartingWith } });
+      }
     }
-    const result = await this.client.http.request({
+    if (typeof request === "string") request = [request];
+    if (Array.isArray(request) && request.length === 0) return { cancelled: 0 };
+    const filters = Array.isArray(request) ? { workflowRunIds: request } : request;
+    return await this.client.http.request({
       path: ["v2", "workflows", "runs"],
       method: "DELETE",
-      body,
-      headers: {
-        "Content-Type": "application/json"
-      }
+      query: buildBulkActionQueryParameters(filters, { translateWorkflowUrl: true })
     });
-    return result;
   }
   /**
    * Notify a workflow run waiting for an event
@@ -4217,15 +4043,26 @@ var Client4 = class {
    * });
    * ```
    *
+   * Optionally, you can pass a workflowRunId to enable lookback functionality:
+   *
+   * ```ts
+   * await client.notify({
+   *   eventId: "my-event-id",
+   *   eventData: "my-data",
+   *   workflowRunId: "wfr_123" // enables lookback
+   * });
+   * ```
+   *
    * @param eventId event id to notify
    * @param eventData data to provide to the workflow
+   * @param workflowRunId optional workflow run id for lookback support
    */
   async notify({
     eventId,
-    eventData
+    eventData,
+    workflowRunId
   }) {
-    await this.ensureReady();
-    return await makeNotifyRequest(this.client.http, eventId, eventData);
+    return await makeNotifyRequest(this.client.http, eventId, eventData, workflowRunId);
   }
   /**
    * Check waiters of an event
@@ -4242,11 +4079,9 @@ var Client4 = class {
    * @param eventId event id to check
    */
   async getWaiters({ eventId }) {
-    await this.ensureReady();
     return await makeGetWaitersRequest(this.client.http, eventId);
   }
   async trigger(params) {
-    await this.ensureReady();
     const isBatchInput = Array.isArray(params);
     const options = isBatchInput ? params : [params];
     const invocations = options.map((option) => {
@@ -4263,7 +4098,9 @@ var Client4 = class {
         url: option.url,
         workflowRunId: finalWorkflowRunId,
         telemetry: option.disableTelemetry ? void 0 : { sdk: SDK_TELEMETRY },
-        label: option.label
+        label: option.label,
+        workflowRunCreatedAt: Date.now()
+        // pass a timestamp (server will override it)
       });
       return {
         workflowContext: context,
@@ -4273,7 +4110,8 @@ var Client4 = class {
         failureUrl,
         retries: option.retries,
         retryDelay: option.retryDelay,
-        flowControl: option.flowControl
+        flowControl: option.flowControl,
+        redact: option.redact
       };
     });
     const result = await triggerFirstInvocation(invocations);
@@ -4314,34 +4152,17 @@ var Client4 = class {
    * ```
    */
   async logs(params) {
-    await this.ensureReady();
-    const { workflowRunId, cursor, count, state, workflowUrl, workflowCreatedAt } = params ?? {};
-    const urlParams = new URLSearchParams({ groupBy: "workflowRunId" });
-    if (workflowRunId) {
-      urlParams.append("workflowRunId", workflowRunId);
-    }
-    if (cursor) {
-      urlParams.append("cursor", cursor);
-    }
-    if (count) {
-      urlParams.append("count", count.toString());
-    }
-    if (state) {
-      urlParams.append("state", state);
-    }
-    if (workflowUrl) {
-      urlParams.append("workflowUrl", workflowUrl);
-    }
-    if (workflowCreatedAt) {
-      urlParams.append("workflowCreatedAt", workflowCreatedAt.toString());
-    }
-    if (params?.label) {
-      urlParams.append("label", params.label);
-    }
-    const result = await this.client.http.request({
-      path: ["v2", "workflows", `events?${urlParams.toString()}`]
+    const { cursor, count, filter, ...legacyFilter } = params ?? {};
+    return await this.client.http.request({
+      path: ["v2", "workflows", "events"],
+      query: {
+        groupBy: "workflowRunId",
+        ...legacyFilter,
+        cursor,
+        count,
+        ...filter
+      }
     });
-    return result;
   }
   get dlq() {
     return new DLQ(this.client);