@vercel/queue 0.0.0-alpha.33 → 0.0.0-alpha.35

package/dist/index.mjs

@@ -19,6 +19,12 @@ var JsonTransport = class {
   contentType = "application/json";
   replacer;
   reviver;
+  /**
+   * Create a new JsonTransport.
+   * @param options - Optional JSON serialization options
+   * @param options.replacer - Custom replacer for JSON.stringify
+   * @param options.reviver - Custom reviver for JSON.parse
+   */
   constructor(options = {}) {
     this.replacer = options.replacer;
     this.reviver = options.reviver;
@@ -48,6 +54,10 @@ var StreamTransport = class {
   async deserialize(stream) {
     return stream;
   }
+  /**
+   * Consume any remaining stream data to prevent resource leaks.
+   * Called automatically by ConsumerGroup; manual call required for direct client usage.
+   */
   async finalize(payload) {
     const reader = payload.getReader();
     try {
@@ -64,8 +74,9 @@ var StreamTransport = class {
 // src/client.ts
 import { parseMultipartStream } from "mixpart";
 
-// src/oidc.ts
-import { getVercelOidcToken } from "@vercel/oidc";
+// src/dev.ts
+import * as fs from "fs";
+import * as path from "path";
 
 // src/types.ts
 var MessageNotFoundError = class extends Error {
@@ -97,6 +108,7 @@ var QueueEmptyError = class extends Error {
   }
 };
 var MessageLockedError = class extends Error {
+  /** Suggested retry delay in seconds, if provided by the server. */
   retryAfter;
   constructor(messageId, retryAfter) {
     const retryMessage = retryAfter ? ` Retry after ${retryAfter} seconds.` : " Try again later.";
@@ -135,6 +147,265 @@ var InvalidLimitError = class extends Error {
     this.name = "InvalidLimitError";
   }
 };
+var MessageAlreadyProcessedError = class extends Error {
+  constructor(messageId) {
+    super(`Message ${messageId} has already been processed`);
+    this.name = "MessageAlreadyProcessedError";
+  }
+};
+var ConcurrencyLimitError = class extends Error {
+  /** Current number of in-flight messages for this consumer group. */
+  currentInflight;
+  /** Maximum allowed concurrent messages (as configured). */
+  maxConcurrency;
+  constructor(message = "Concurrency limit exceeded", currentInflight, maxConcurrency) {
+    super(message);
+    this.name = "ConcurrencyLimitError";
+    this.currentInflight = currentInflight;
+    this.maxConcurrency = maxConcurrency;
+  }
+};
+var DuplicateMessageError = class extends Error {
+  idempotencyKey;
+  constructor(message, idempotencyKey) {
+    super(message);
+    this.name = "DuplicateMessageError";
+    this.idempotencyKey = idempotencyKey;
+  }
+};
+var ConsumerDiscoveryError = class extends Error {
+  deploymentId;
+  constructor(message, deploymentId) {
+    super(message);
+    this.name = "ConsumerDiscoveryError";
+    this.deploymentId = deploymentId;
+  }
+};
+var ConsumerRegistryNotConfiguredError = class extends Error {
+  constructor(message = "Consumer registry not configured") {
+    super(message);
+    this.name = "ConsumerRegistryNotConfiguredError";
+  }
+};
+
+// src/dev.ts
+var ROUTE_MAPPINGS_KEY = Symbol.for("@vercel/queue.devRouteMappings");
+function filePathToUrlPath(filePath) {
+  let urlPath = filePath.replace(/^app\//, "/").replace(/^pages\//, "/").replace(/\/route\.(ts|js|tsx|jsx)$/, "").replace(/\.(ts|js|tsx|jsx)$/, "");
+  if (!urlPath.startsWith("/")) {
+    urlPath = "/" + urlPath;
+  }
+  return urlPath;
+}
+function getDevRouteMappings() {
+  const g = globalThis;
+  if (ROUTE_MAPPINGS_KEY in g) {
+    return g[ROUTE_MAPPINGS_KEY] ?? null;
+  }
+  try {
+    const vercelJsonPath = path.join(process.cwd(), "vercel.json");
+    if (!fs.existsSync(vercelJsonPath)) {
+      g[ROUTE_MAPPINGS_KEY] = null;
+      return null;
+    }
+    const vercelJson = JSON.parse(fs.readFileSync(vercelJsonPath, "utf-8"));
+    if (!vercelJson.functions) {
+      g[ROUTE_MAPPINGS_KEY] = null;
+      return null;
+    }
+    const mappings = [];
+    for (const [filePath, config] of Object.entries(vercelJson.functions)) {
+      if (!config.experimentalTriggers) continue;
+      for (const trigger of config.experimentalTriggers) {
+        if (trigger.type?.startsWith("queue/") && trigger.topic && trigger.consumer) {
+          mappings.push({
+            urlPath: filePathToUrlPath(filePath),
+            topic: trigger.topic,
+            consumer: trigger.consumer
+          });
+        }
+      }
+    }
+    g[ROUTE_MAPPINGS_KEY] = mappings.length > 0 ? mappings : null;
+    return g[ROUTE_MAPPINGS_KEY];
+  } catch (error) {
+    console.warn("[Dev Mode] Failed to read vercel.json:", error);
+    g[ROUTE_MAPPINGS_KEY] = null;
+    return null;
+  }
+}
+function findMatchingRoutes(topicName) {
+  const mappings = getDevRouteMappings();
+  if (!mappings) {
+    return [];
+  }
+  return mappings.filter((mapping) => {
+    if (mapping.topic.includes("*")) {
+      return matchesWildcardPattern(topicName, mapping.topic);
+    }
+    return mapping.topic === topicName;
+  });
+}
+function isDevMode() {
+  return process.env.NODE_ENV === "development";
+}
+var DEV_VISIBILITY_POLL_INTERVAL = 50;
+var DEV_VISIBILITY_MAX_WAIT = 5e3;
+var DEV_VISIBILITY_BACKOFF_MULTIPLIER = 2;
+async function waitForMessageVisibility(topicName, consumerGroup, messageId) {
+  const client = new QueueClient();
+  const transport = new JsonTransport();
+  let elapsed = 0;
+  let interval = DEV_VISIBILITY_POLL_INTERVAL;
+  while (elapsed < DEV_VISIBILITY_MAX_WAIT) {
+    try {
+      await client.receiveMessageById(
+        {
+          queueName: topicName,
+          consumerGroup,
+          messageId,
+          visibilityTimeoutSeconds: 0
+        },
+        transport
+      );
+      return true;
+    } catch (error) {
+      if (error instanceof MessageNotFoundError) {
+        await new Promise((resolve) => setTimeout(resolve, interval));
+        elapsed += interval;
+        interval = Math.min(
+          interval * DEV_VISIBILITY_BACKOFF_MULTIPLIER,
+          DEV_VISIBILITY_MAX_WAIT - elapsed
+        );
+        continue;
+      }
+      if (error instanceof MessageAlreadyProcessedError) {
+        console.log(
+          `[Dev Mode] Message already processed: topic="${topicName}" messageId="${messageId}"`
+        );
+        return false;
+      }
+      console.error(
+        `[Dev Mode] Error polling for message visibility: topic="${topicName}" messageId="${messageId}"`,
+        error
+      );
+      return false;
+    }
+  }
+  console.warn(
+    `[Dev Mode] Message visibility timeout after ${DEV_VISIBILITY_MAX_WAIT}ms: topic="${topicName}" messageId="${messageId}"`
+  );
+  return false;
+}
+function triggerDevCallbacks(topicName, messageId, delaySeconds) {
+  if (delaySeconds && delaySeconds > 0) {
+    console.log(
+      `[Dev Mode] Message sent with delay: topic="${topicName}" messageId="${messageId}" delay=${delaySeconds}s`
+    );
+    setTimeout(() => {
+      triggerDevCallbacks(topicName, messageId);
+    }, delaySeconds * 1e3);
+    return;
+  }
+  console.log(
+    `[Dev Mode] Message sent: topic="${topicName}" messageId="${messageId}"`
+  );
+  const matchingRoutes = findMatchingRoutes(topicName);
+  if (matchingRoutes.length === 0) {
+    console.log(
+      `[Dev Mode] No matching routes in vercel.json for topic "${topicName}"`
+    );
+    return;
+  }
+  const consumerGroups = matchingRoutes.map((r) => r.consumer);
+  console.log(
+    `[Dev Mode] Scheduling callbacks for topic="${topicName}" messageId="${messageId}" \u2192 consumers: [${consumerGroups.join(", ")}]`
+  );
+  (async () => {
+    const firstRoute = matchingRoutes[0];
+    const isVisible = await waitForMessageVisibility(
+      topicName,
+      firstRoute.consumer,
+      messageId
+    );
+    if (!isVisible) {
+      console.warn(
+        `[Dev Mode] Skipping callbacks - message not visible: topic="${topicName}" messageId="${messageId}"`
+      );
+      return;
+    }
+    const port = process.env.PORT || 3e3;
+    const baseUrl = `http://localhost:${port}`;
+    for (const route of matchingRoutes) {
+      const url = `${baseUrl}${route.urlPath}`;
+      console.log(
+        `[Dev Mode] Invoking handler: topic="${topicName}" consumer="${route.consumer}" messageId="${messageId}" url="${url}"`
+      );
+      const cloudEvent = {
+        type: "com.vercel.queue.v1beta",
+        source: `/topic/${topicName}/consumer/${route.consumer}`,
+        id: messageId,
+        datacontenttype: "application/json",
+        data: {
+          messageId,
+          queueName: topicName,
+          consumerGroup: route.consumer
+        },
+        time: (/* @__PURE__ */ new Date()).toISOString(),
+        specversion: "1.0"
+      };
+      try {
+        const response = await fetch(url, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/cloudevents+json"
+          },
+          body: JSON.stringify(cloudEvent)
+        });
+        if (response.ok) {
+          try {
+            const responseData = await response.json();
+            if (responseData.status === "success") {
+              console.log(
+                `[Dev Mode] \u2713 Message processed successfully: topic="${topicName}" consumer="${route.consumer}" messageId="${messageId}"`
+              );
+            }
+          } catch {
+            console.warn(
+              `[Dev Mode] Handler returned OK but response was not JSON: topic="${topicName}" consumer="${route.consumer}"`
+            );
+          }
+        } else {
+          try {
+            const errorData = await response.json();
+            console.error(
+              `[Dev Mode] \u2717 Handler failed: topic="${topicName}" consumer="${route.consumer}" messageId="${messageId}" error="${errorData.error || response.statusText}"`
+            );
+          } catch {
+            console.error(
+              `[Dev Mode] \u2717 Handler failed: topic="${topicName}" consumer="${route.consumer}" messageId="${messageId}" status=${response.status}`
+            );
+          }
+        }
+      } catch (error) {
+        console.error(
+          `[Dev Mode] \u2717 HTTP request failed: topic="${topicName}" consumer="${route.consumer}" messageId="${messageId}" url="${url}"`,
+          error
+        );
+      }
+    }
+  })();
+}
+function clearDevRouteMappings() {
+  const g = globalThis;
+  delete g[ROUTE_MAPPINGS_KEY];
+}
+if (process.env.NODE_ENV === "test" || process.env.VITEST) {
+  globalThis.__clearDevRouteMappings = clearDevRouteMappings;
+}
+
+// src/oidc.ts
+import { getVercelOidcToken } from "@vercel/oidc";
 
 // src/client.ts
 function isDebugEnabled() {
@@ -151,14 +422,6 @@ async function consumeStream(stream) {
     reader.releaseLock();
   }
 }
-function parseRetryAfter(headers) {
-  const retryAfterHeader = headers.get("Retry-After");
-  if (retryAfterHeader) {
-    const parsed = parseInt(retryAfterHeader, 10);
-    return Number.isNaN(parsed) ? void 0 : parsed;
-  }
-  return void 0;
-}
 function throwCommonHttpError(status, statusText, errorText, operation, badRequestDefault = "Invalid parameters") {
   if (status === 400) {
     throw new BadRequestError(errorText || badRequestDefault);
@@ -181,8 +444,8 @@ function parseQueueHeaders(headers) {
   const deliveryCountStr = headers.get("Vqs-Delivery-Count") || "0";
   const timestamp = headers.get("Vqs-Timestamp");
   const contentType = headers.get("Content-Type") || "application/octet-stream";
-  const ticket = headers.get("Vqs-Ticket");
-  if (!messageId || !timestamp || !ticket) {
+  const receiptHandle = headers.get("Vqs-Receipt-Handle");
+  if (!messageId || !timestamp || !receiptHandle) {
     return null;
   }
   const deliveryCount = parseInt(deliveryCountStr, 10);
@@ -194,7 +457,7 @@ function parseQueueHeaders(headers) {
     deliveryCount,
     createdAt: new Date(timestamp),
     contentType,
-    ticket
+    receiptHandle
   };
 }
 var QueueClient = class {
@@ -202,15 +465,30 @@ var QueueClient = class {
   basePath;
   customHeaders;
   providedToken;
-  /**
-   * Create a new Vercel Queue Service client
-   * @param options QueueClient configuration options
-   */
+  defaultDeploymentId;
+  pinToDeployment;
   constructor(options = {}) {
     this.baseUrl = options.baseUrl || process.env.VERCEL_QUEUE_BASE_URL || "https://vercel-queue.com";
-    this.basePath = options.basePath || process.env.VERCEL_QUEUE_BASE_PATH || "/api/v2/messages";
+    this.basePath = options.basePath || process.env.VERCEL_QUEUE_BASE_PATH || "/api/v3/topic";
     this.customHeaders = options.headers || {};
     this.providedToken = options.token;
+    this.defaultDeploymentId = options.deploymentId || process.env.VERCEL_DEPLOYMENT_ID;
+    this.pinToDeployment = options.pinToDeployment ?? true;
+  }
+  getSendDeploymentId() {
+    if (isDevMode()) {
+      return void 0;
+    }
+    if (this.pinToDeployment) {
+      return this.defaultDeploymentId;
+    }
+    return void 0;
+  }
+  getConsumeDeploymentId() {
+    if (isDevMode()) {
+      return void 0;
+    }
+    return this.defaultDeploymentId;
   }
   async getToken() {
     if (this.providedToken) {
@@ -224,10 +502,12 @@ var QueueClient = class {
     }
     return token;
   }
-  /**
-   * Internal fetch wrapper that automatically handles debug logging
-   * when VERCEL_QUEUE_DEBUG is enabled
-   */
+  buildUrl(queueName, ...pathSegments) {
+    const encodedQueue = encodeURIComponent(queueName);
+    const segments = pathSegments.map((s) => encodeURIComponent(s));
+    const path2 = segments.length > 0 ? "/" + segments.join("/") : "";
+    return `${this.baseUrl}${this.basePath}/${encodedQueue}${path2}`;
+  }
   async fetch(url, init) {
     const method = init.method || "GET";
     if (isDebugEnabled()) {
@@ -264,24 +544,38 @@ var QueueClient = class {
     return response;
   }
   /**
-   * Send a message to a queue
-   * @param options Send message options
-   * @param transport Serializer/deserializer for the payload
-   * @returns Promise with the message ID
-   * @throws {BadRequestError} When request parameters are invalid
+   * Send a message to a topic.
+   *
+   * @param options - Message options including queue name, payload, and optional settings
+   * @param options.queueName - Topic name (pattern: `[A-Za-z0-9_-]+`)
+   * @param options.payload - Message payload
+   * @param options.idempotencyKey - Optional deduplication key (dedup window: min(retention, 24h))
+   * @param options.retentionSeconds - Message TTL (default: 86400, min: 60, max: 86400)
+   * @param options.delaySeconds - Delivery delay (default: 0, max: retentionSeconds)
+   * @param transport - Serializer for the payload
+   * @returns Promise with the generated messageId
+   * @throws {DuplicateMessageError} When idempotency key was already used
+   * @throws {ConsumerDiscoveryError} When consumer discovery fails
+   * @throws {ConsumerRegistryNotConfiguredError} When registry not configured
+   * @throws {BadRequestError} When parameters are invalid
    * @throws {UnauthorizedError} When authentication fails
-   * @throws {ForbiddenError} When access is denied (environment mismatch)
+   * @throws {ForbiddenError} When access is denied
    * @throws {InternalServerError} When server encounters an error
    */
   async sendMessage(options, transport) {
-    const { queueName, payload, idempotencyKey, retentionSeconds } = options;
+    const {
+      queueName,
+      payload,
+      idempotencyKey,
+      retentionSeconds,
+      delaySeconds
+    } = options;
     const headers = new Headers({
       Authorization: `Bearer ${await this.getToken()}`,
-      "Vqs-Queue-Name": queueName,
       "Content-Type": transport.contentType,
       ...this.customHeaders
     });
-    const deploymentId = options.deploymentId || process.env.VERCEL_DEPLOYMENT_ID;
+    const deploymentId = this.getSendDeploymentId();
     if (deploymentId) {
       headers.set("Vqs-Deployment-Id", deploymentId);
     }
@@ -291,8 +585,12 @@ var QueueClient = class {
     if (retentionSeconds !== void 0) {
       headers.set("Vqs-Retention-Seconds", retentionSeconds.toString());
     }
-    const body = transport.serialize(payload);
-    const response = await this.fetch(`${this.baseUrl}${this.basePath}`, {
+    if (delaySeconds !== void 0) {
+      headers.set("Vqs-Delay-Seconds", delaySeconds.toString());
+    }
+    const serialized = transport.serialize(payload);
+    const body = Buffer.isBuffer(serialized) ? new Uint8Array(serialized) : serialized;
+    const response = await this.fetch(this.buildUrl(queueName), {
       method: "POST",
       body,
       headers
@@ -300,7 +598,21 @@ var QueueClient = class {
     if (!response.ok) {
       const errorText = await response.text();
       if (response.status === 409) {
-        throw new Error("Duplicate idempotency key detected");
+        throw new DuplicateMessageError(
+          errorText || "Duplicate idempotency key detected",
+          idempotencyKey
+        );
+      }
+      if (response.status === 502) {
+        throw new ConsumerDiscoveryError(
+          errorText || "Consumer discovery failed",
+          deploymentId
+        );
+      }
+      if (response.status === 503) {
+        throw new ConsumerRegistryNotConfiguredError(
+          errorText || "Consumer registry not configured"
+        );
       }
       throwCommonHttpError(
         response.status,
@@ -313,52 +625,78 @@ var QueueClient = class {
     return responseData;
   }
   /**
-   * Receive messages from a queue
-   * @param options Receive messages options
-   * @param transport Serializer/deserializer for the payload
-   * @returns AsyncGenerator that yields messages as they arrive
-   * @throws {InvalidLimitError} When limit parameter is not between 1 and 10
-   * @throws {QueueEmptyError} When no messages are available (204)
-   * @throws {MessageLockedError} When messages are temporarily locked (423)
-   * @throws {BadRequestError} When request parameters are invalid
+   * Receive messages from a topic as an async generator.
+   *
+   * @param options - Receive options
+   * @param options.queueName - Topic name (pattern: `[A-Za-z0-9_-]+`)
+   * @param options.consumerGroup - Consumer group name (pattern: `[A-Za-z0-9_-]+`)
+   * @param options.visibilityTimeoutSeconds - Lock duration (default: 30, min: 0, max: 3600)
+   * @param options.limit - Max messages to retrieve (default: 1, min: 1, max: 10)
+   * @param options.maxConcurrency - Max in-flight messages (default: unlimited, min: 1)
+   * @param transport - Deserializer for message payloads
+   * @yields Message objects with payload, messageId, receiptHandle, etc.
+   * @throws {QueueEmptyError} When no messages available
+   * @throws {InvalidLimitError} When limit is outside 1-10 range
+   * @throws {ConcurrencyLimitError} When maxConcurrency exceeded
+   * @throws {BadRequestError} When parameters are invalid
    * @throws {UnauthorizedError} When authentication fails
-   * @throws {ForbiddenError} When access is denied (environment mismatch)
+   * @throws {ForbiddenError} When access is denied
    * @throws {InternalServerError} When server encounters an error
    */
   async *receiveMessages(options, transport) {
-    const { queueName, consumerGroup, visibilityTimeoutSeconds, limit } = options;
+    const {
+      queueName,
+      consumerGroup,
+      visibilityTimeoutSeconds,
+      limit,
+      maxConcurrency
+    } = options;
     if (limit !== void 0 && (limit < 1 || limit > 10)) {
       throw new InvalidLimitError(limit);
     }
     const headers = new Headers({
       Authorization: `Bearer ${await this.getToken()}`,
-      "Vqs-Queue-Name": queueName,
-      "Vqs-Consumer-Group": consumerGroup,
       Accept: "multipart/mixed",
       ...this.customHeaders
     });
     if (visibilityTimeoutSeconds !== void 0) {
       headers.set(
-        "Vqs-Visibility-Timeout",
+        "Vqs-Visibility-Timeout-Seconds",
         visibilityTimeoutSeconds.toString()
       );
     }
     if (limit !== void 0) {
-      headers.set("Vqs-Limit", limit.toString());
+      headers.set("Vqs-Max-Messages", limit.toString());
     }
-    const response = await this.fetch(`${this.baseUrl}${this.basePath}`, {
-      method: "GET",
-      headers
-    });
+    if (maxConcurrency !== void 0) {
+      headers.set("Vqs-Max-Concurrency", maxConcurrency.toString());
+    }
+    const effectiveDeploymentId = this.getConsumeDeploymentId();
+    if (effectiveDeploymentId) {
+      headers.set("Vqs-Deployment-Id", effectiveDeploymentId);
+    }
+    const response = await this.fetch(
+      this.buildUrl(queueName, "consumer", consumerGroup),
+      {
+        method: "POST",
+        headers
+      }
+    );
     if (response.status === 204) {
       throw new QueueEmptyError(queueName, consumerGroup);
     }
     if (!response.ok) {
       const errorText = await response.text();
-      if (response.status === 423) {
-        throw new MessageLockedError(
-          "next message",
-          parseRetryAfter(response.headers)
+      if (response.status === 429) {
+        let errorData = {};
+        try {
+          errorData = JSON.parse(errorText);
+        } catch {
+        }
+        throw new ConcurrencyLimitError(
+          errorData.error || "Concurrency limit exceeded or throttled",
+          errorData.currentInflight,
+          errorData.maxConcurrency
         );
       }
       throwCommonHttpError(
@@ -390,34 +728,56 @@ var QueueClient = class {
       }
     }
   }
+  /**
+   * Receive a specific message by its ID.
+   *
+   * @param options - Receive options
+   * @param options.queueName - Topic name (pattern: `[A-Za-z0-9_-]+`)
+   * @param options.consumerGroup - Consumer group name (pattern: `[A-Za-z0-9_-]+`)
+   * @param options.messageId - Message ID to retrieve
+   * @param options.visibilityTimeoutSeconds - Lock duration (default: 30, min: 0, max: 3600)
+   * @param options.maxConcurrency - Max in-flight messages (default: unlimited, min: 1)
+   * @param transport - Deserializer for the message payload
+   * @returns Promise with the message
+   * @throws {MessageNotFoundError} When message doesn't exist
+   * @throws {MessageNotAvailableError} When message is in wrong state or was a duplicate
+   * @throws {MessageAlreadyProcessedError} When message was already processed
+   * @throws {ConcurrencyLimitError} When maxConcurrency exceeded
+   * @throws {BadRequestError} When parameters are invalid
+   * @throws {UnauthorizedError} When authentication fails
+   * @throws {ForbiddenError} When access is denied
+   * @throws {InternalServerError} When server encounters an error
+   */
   async receiveMessageById(options, transport) {
     const {
       queueName,
       consumerGroup,
       messageId,
       visibilityTimeoutSeconds,
-      skipPayload
+      maxConcurrency
     } = options;
     const headers = new Headers({
       Authorization: `Bearer ${await this.getToken()}`,
-      "Vqs-Queue-Name": queueName,
-      "Vqs-Consumer-Group": consumerGroup,
       Accept: "multipart/mixed",
       ...this.customHeaders
     });
     if (visibilityTimeoutSeconds !== void 0) {
       headers.set(
-        "Vqs-Visibility-Timeout",
+        "Vqs-Visibility-Timeout-Seconds",
         visibilityTimeoutSeconds.toString()
       );
     }
-    if (skipPayload) {
-      headers.set("Vqs-Skip-Payload", "1");
+    if (maxConcurrency !== void 0) {
+      headers.set("Vqs-Max-Concurrency", maxConcurrency.toString());
+    }
+    const effectiveDeploymentId = this.getConsumeDeploymentId();
+    if (effectiveDeploymentId) {
+      headers.set("Vqs-Deployment-Id", effectiveDeploymentId);
     }
     const response = await this.fetch(
-      `${this.baseUrl}${this.basePath}/${encodeURIComponent(messageId)}`,
+      this.buildUrl(queueName, "consumer", consumerGroup, "id", messageId),
       {
-        method: "GET",
+        method: "POST",
         headers
       }
     );
@@ -427,12 +787,32 @@ var QueueClient = class {
         throw new MessageNotFoundError(messageId);
       }
       if (response.status === 409) {
+        let errorData = {};
+        try {
+          errorData = JSON.parse(errorText);
+        } catch {
+        }
+        if (errorData.originalMessageId) {
+          throw new MessageNotAvailableError(
+            messageId,
+            `This message was a duplicate - use originalMessageId: ${errorData.originalMessageId}`
+          );
+        }
         throw new MessageNotAvailableError(messageId);
       }
-      if (response.status === 423) {
-        throw new MessageLockedError(
-          messageId,
-          parseRetryAfter(response.headers)
+      if (response.status === 410) {
+        throw new MessageAlreadyProcessedError(messageId);
+      }
+      if (response.status === 429) {
+        let errorData = {};
+        try {
+          errorData = JSON.parse(errorText);
+        } catch {
+        }
+        throw new ConcurrencyLimitError(
+          errorData.error || "Concurrency limit exceeded or throttled",
+          errorData.currentInflight,
+          errorData.maxConcurrency
         );
       }
       throwCommonHttpError(
@@ -442,95 +822,73 @@ var QueueClient = class {
         "receive message by ID"
       );
     }
-    if (skipPayload && response.status === 204) {
-      const parsedHeaders = parseQueueHeaders(response.headers);
+    for await (const multipartMessage of parseMultipartStream(response)) {
+      const parsedHeaders = parseQueueHeaders(multipartMessage.headers);
       if (!parsedHeaders) {
+        await consumeStream(multipartMessage.payload);
         throw new MessageCorruptedError(
           messageId,
-          "Missing required queue headers in 204 response"
+          "Missing required queue headers in response"
         );
       }
+      const deserializedPayload = await transport.deserialize(
+        multipartMessage.payload
+      );
       const message = {
         ...parsedHeaders,
-        payload: void 0
+        payload: deserializedPayload
       };
       return { message };
     }
-    if (!transport) {
-      throw new Error("Transport is required when skipPayload is not true");
-    }
-    try {
-      for await (const multipartMessage of parseMultipartStream(response)) {
-        try {
-          const parsedHeaders = parseQueueHeaders(multipartMessage.headers);
-          if (!parsedHeaders) {
-            console.warn("Missing required queue headers in multipart part");
-            await consumeStream(multipartMessage.payload);
-            continue;
-          }
-          const deserializedPayload = await transport.deserialize(
-            multipartMessage.payload
-          );
-          const message = {
-            ...parsedHeaders,
-            payload: deserializedPayload
-          };
-          return { message };
-        } catch (error) {
-          console.warn("Failed to deserialize message by ID:", error);
-          await consumeStream(multipartMessage.payload);
-          throw new MessageCorruptedError(
-            messageId,
-            `Failed to deserialize payload: ${error}`
-          );
-        }
-      }
-    } catch (error) {
-      if (error instanceof MessageCorruptedError) {
-        throw error;
-      }
-      throw new MessageCorruptedError(
-        messageId,
-        `Failed to parse multipart response: ${error}`
-      );
-    }
     throw new MessageNotFoundError(messageId);
   }
   /**
-   * Delete a message (acknowledge processing)
-   * @param options Delete message options
-   * @returns Promise with delete status
-   * @throws {MessageNotFoundError} When the message doesn't exist (404)
-   * @throws {MessageNotAvailableError} When message can't be deleted (409)
-   * @throws {BadRequestError} When ticket is missing or invalid (400)
+   * Delete (acknowledge) a message after successful processing.
+   *
+   * @param options - Delete options
+   * @param options.queueName - Topic name
+   * @param options.consumerGroup - Consumer group name
+   * @param options.receiptHandle - Receipt handle from the received message (must use same deployment ID as receive)
+   * @returns Promise indicating deletion success
+   * @throws {MessageNotFoundError} When receipt handle not found
+   * @throws {MessageNotAvailableError} When receipt handle invalid or message already processed
+   * @throws {BadRequestError} When parameters are invalid
    * @throws {UnauthorizedError} When authentication fails
-   * @throws {ForbiddenError} When access is denied (environment mismatch)
+   * @throws {ForbiddenError} When access is denied
    * @throws {InternalServerError} When server encounters an error
    */
   async deleteMessage(options) {
-    const { queueName, consumerGroup, messageId, ticket } = options;
+    const { queueName, consumerGroup, receiptHandle } = options;
+    const headers = new Headers({
+      Authorization: `Bearer ${await this.getToken()}`,
+      ...this.customHeaders
+    });
+    const effectiveDeploymentId = this.getConsumeDeploymentId();
+    if (effectiveDeploymentId) {
+      headers.set("Vqs-Deployment-Id", effectiveDeploymentId);
+    }
     const response = await this.fetch(
-      `${this.baseUrl}${this.basePath}/${encodeURIComponent(messageId)}`,
+      this.buildUrl(
+        queueName,
+        "consumer",
+        consumerGroup,
+        "lease",
+        receiptHandle
+      ),
       {
         method: "DELETE",
-        headers: new Headers({
-          Authorization: `Bearer ${await this.getToken()}`,
-          "Vqs-Queue-Name": queueName,
-          "Vqs-Consumer-Group": consumerGroup,
-          "Vqs-Ticket": ticket,
-          ...this.customHeaders
-        })
+        headers
       }
     );
     if (!response.ok) {
       const errorText = await response.text();
       if (response.status === 404) {
-        throw new MessageNotFoundError(messageId);
+        throw new MessageNotFoundError(receiptHandle);
       }
       if (response.status === 409) {
         throw new MessageNotAvailableError(
-          messageId,
-          errorText || "Invalid ticket, message not in correct state, or already processed"
+          receiptHandle,
+          errorText || "Invalid receipt handle, message not in correct state, or already processed"
         );
       }
       throwCommonHttpError(
@@ -538,53 +896,67 @@ var QueueClient = class {
         response.statusText,
         errorText,
         "delete message",
-        "Missing or invalid ticket"
+        "Missing or invalid receipt handle"
       );
     }
     return { deleted: true };
   }
   /**
-   * Change the visibility timeout of a message
-   * @param options Change visibility options
-   * @returns Promise with update status
-   * @throws {MessageNotFoundError} When the message doesn't exist (404)
-   * @throws {MessageNotAvailableError} When message can't be updated (409)
-   * @throws {BadRequestError} When ticket is missing or visibility timeout invalid (400)
+   * Extend or change the visibility timeout of a message.
+   * Used to prevent message redelivery while still processing.
+   *
+   * @param options - Visibility options
+   * @param options.queueName - Topic name
+   * @param options.consumerGroup - Consumer group name
+   * @param options.receiptHandle - Receipt handle from the received message (must use same deployment ID as receive)
+   * @param options.visibilityTimeoutSeconds - New timeout (min: 0, max: 3600, cannot exceed message expiration)
+   * @returns Promise indicating success
+   * @throws {MessageNotFoundError} When receipt handle not found
+   * @throws {MessageNotAvailableError} When receipt handle invalid or message already processed
+   * @throws {BadRequestError} When parameters are invalid
    * @throws {UnauthorizedError} When authentication fails
-   * @throws {ForbiddenError} When access is denied (environment mismatch)
+   * @throws {ForbiddenError} When access is denied
    * @throws {InternalServerError} When server encounters an error
    */
   async changeVisibility(options) {
     const {
       queueName,
       consumerGroup,
-      messageId,
-      ticket,
+      receiptHandle,
       visibilityTimeoutSeconds
     } = options;
+    const headers = new Headers({
+      Authorization: `Bearer ${await this.getToken()}`,
+      "Content-Type": "application/json",
+      ...this.customHeaders
+    });
+    const effectiveDeploymentId = this.getConsumeDeploymentId();
+    if (effectiveDeploymentId) {
+      headers.set("Vqs-Deployment-Id", effectiveDeploymentId);
+    }
     const response = await this.fetch(
-      `${this.baseUrl}${this.basePath}/${encodeURIComponent(messageId)}`,
+      this.buildUrl(
+        queueName,
+        "consumer",
+        consumerGroup,
+        "lease",
+        receiptHandle
+      ),
       {
         method: "PATCH",
-        headers: new Headers({
-          Authorization: `Bearer ${await this.getToken()}`,
-          "Vqs-Queue-Name": queueName,
-          "Vqs-Consumer-Group": consumerGroup,
-          "Vqs-Ticket": ticket,
-          "Vqs-Visibility-Timeout": visibilityTimeoutSeconds.toString(),
-          ...this.customHeaders
-        })
+        headers,
+        body: JSON.stringify({ visibilityTimeoutSeconds })
       }
     );
     if (!response.ok) {
       const errorText = await response.text();
       if (response.status === 404) {
-        throw new MessageNotFoundError(messageId);
+        throw new MessageNotFoundError(receiptHandle);
       }
       if (response.status === 409) {
         throw new MessageNotAvailableError(
-          messageId,
-          errorText || "Invalid ticket, message not in correct state, or already processed"
+          receiptHandle,
+          errorText || "Invalid receipt handle, message not in correct state, or already processed"
         );
       }
       throwCommonHttpError(
@@ -592,194 +964,72 @@ var QueueClient = class {
         response.statusText,
         errorText,
         "change visibility",
-        "Missing ticket or invalid visibility timeout"
+        "Missing receipt handle or invalid visibility timeout"
       );
     }
-    return { updated: true };
-  }
-};
-
-// src/dev.ts
-var GLOBAL_KEY = Symbol.for("@vercel/queue.devHandlers");
-function getDevHandlerState() {
-  const g = globalThis;
-  if (!g[GLOBAL_KEY]) {
-    g[GLOBAL_KEY] = {
-      devRouteHandlers: /* @__PURE__ */ new Map(),
-      wildcardRouteHandlers: /* @__PURE__ */ new Map()
-    };
-  }
-  return g[GLOBAL_KEY];
-}
-var { devRouteHandlers, wildcardRouteHandlers } = getDevHandlerState();
-function cleanupDeadRefs(key, refs) {
-  const aliveRefs = refs.filter((ref) => ref.deref() !== void 0);
-  if (aliveRefs.length === 0) {
-    wildcardRouteHandlers.delete(key);
-  } else if (aliveRefs.length < refs.length) {
-    wildcardRouteHandlers.set(key, aliveRefs);
+    return { success: true };
   }
-}
-function isDevMode() {
-  return process.env.NODE_ENV === "development";
-}
-function registerDevRouteHandler(routeHandler, handlers) {
-  for (const topicName in handlers) {
-    for (const consumerGroup in handlers[topicName]) {
-      const key = `${topicName}:${consumerGroup}`;
-      if (topicName.includes("*")) {
-        const existing = wildcardRouteHandlers.get(key) || [];
-        cleanupDeadRefs(key, existing);
-        const cleanedRefs = wildcardRouteHandlers.get(key) || [];
-        const weakRef = new WeakRef(routeHandler);
-        cleanedRefs.push(weakRef);
-        wildcardRouteHandlers.set(key, cleanedRefs);
-      } else {
-        devRouteHandlers.set(key, {
-          routeHandler,
-          topicPattern: topicName
-        });
-      }
+  /**
+   * Alternative endpoint for changing message visibility timeout.
+   * Uses the /visibility path suffix and expects visibilityTimeoutSeconds in the body.
+   * Functionally equivalent to changeVisibility but follows an alternative API pattern.
+   *
+   * @param options - Options for changing visibility
+   * @returns Promise resolving to change visibility response
+   */
+  async changeVisibilityAlt(options) {
+    const {
+      queueName,
+      consumerGroup,
+      receiptHandle,
+      visibilityTimeoutSeconds
+    } = options;
+    const headers = new Headers({
+      Authorization: `Bearer ${await this.getToken()}`,
+      "Content-Type": "application/json",
+      ...this.customHeaders
+    });
+    const effectiveDeploymentId = this.getConsumeDeploymentId();
+    if (effectiveDeploymentId) {
+      headers.set("Vqs-Deployment-Id", effectiveDeploymentId);
     }
-  }
-}
-function findRouteHandlersForTopic(topicName) {
-  const handlersMap = /* @__PURE__ */ new Map();
-  for (const [
-    key,
-    { routeHandler, topicPattern }
-  ] of devRouteHandlers.entries()) {
-    const [_, consumerGroup] = key.split(":");
-    if (topicPattern === topicName) {
-      if (!handlersMap.has(routeHandler)) {
-        handlersMap.set(routeHandler, /* @__PURE__ */ new Set());
+    const response = await this.fetch(
+      this.buildUrl(
+        queueName,
+        "consumer",
+        consumerGroup,
+        "lease",
+        receiptHandle,
+        "visibility"
+      ),
+      {
+        method: "PATCH",
+        headers,
+        body: JSON.stringify({ visibilityTimeoutSeconds })
       }
-      handlersMap.get(routeHandler).add(consumerGroup);
-    }
-  }
-  for (const [key, refs] of wildcardRouteHandlers.entries()) {
-    const [pattern, consumerGroup] = key.split(":");
-    if (matchesWildcardPattern(topicName, pattern)) {
-      cleanupDeadRefs(key, refs);
-      const cleanedRefs = wildcardRouteHandlers.get(key) || [];
-      for (const ref of cleanedRefs) {
-        const routeHandler = ref.deref();
-        if (routeHandler) {
-          if (!handlersMap.has(routeHandler)) {
-            handlersMap.set(routeHandler, /* @__PURE__ */ new Set());
-          }
-          handlersMap.get(routeHandler).add(consumerGroup);
-        }
+    );
+    if (!response.ok) {
+      const errorText = await response.text();
+      if (response.status === 404) {
+        throw new MessageNotFoundError(receiptHandle);
       }
-    }
-  }
-  return handlersMap;
-}
-function createMockCloudEventRequest(topicName, consumerGroup, messageId) {
-  const cloudEvent = {
-    type: "com.vercel.queue.v1beta",
-    source: `/topic/${topicName}/consumer/${consumerGroup}`,
-    id: messageId,
-    datacontenttype: "application/json",
-    data: {
-      messageId,
-      queueName: topicName,
-      consumerGroup
-    },
-    time: (/* @__PURE__ */ new Date()).toISOString(),
-    specversion: "1.0"
-  };
-  return new Request("https://localhost/api/queue/callback", {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/cloudevents+json"
-    },
-    body: JSON.stringify(cloudEvent)
-  });
-}
-var DEV_CALLBACK_DELAY = 1e3;
-function scheduleDevTimeout(topicName, messageId, timeoutSeconds) {
-  console.log(
-    `[Dev Mode] Message ${messageId} timed out for ${timeoutSeconds}s, will re-trigger`
-  );
-  setTimeout(
-    () => {
-      console.log(
-        `[Dev Mode] Re-triggering callback for timed-out message ${messageId}`
-      );
-      triggerDevCallbacks(topicName, messageId);
-    },
-    timeoutSeconds * 1e3 + DEV_CALLBACK_DELAY
-  );
-}
-function triggerDevCallbacks(topicName, messageId) {
-  const handlersMap = findRouteHandlersForTopic(topicName);
-  if (handlersMap.size === 0) {
-    return;
-  }
-  const consumerGroups = Array.from(
-    new Set(
-      Array.from(handlersMap.values()).flatMap((groups) => Array.from(groups))
-    )
-  );
-  console.log(
-    `[Dev Mode] Triggering local callbacks for topic "${topicName}" \u2192 consumers: ${consumerGroups.join(", ")}`
-  );
-  setTimeout(async () => {
-    for (const [routeHandler, consumerGroups2] of handlersMap.entries()) {
-      for (const consumerGroup of consumerGroups2) {
-        try {
-          const request = createMockCloudEventRequest(
-            topicName,
-            consumerGroup,
-            messageId
-          );
-          const response = await routeHandler(request);
-          if (response.ok) {
-            try {
-              const responseData = await response.json();
-              if (responseData.status === "success") {
-                console.log(
-                  `[Dev Mode] Message processed for ${topicName}/${consumerGroup}`
-                );
-              }
-            } catch (jsonError) {
-              console.error(
-                `[Dev Mode] Failed to parse success response for ${topicName}/${consumerGroup}:`,
-                jsonError
-              );
-            }
-          } else {
-            try {
-              const errorData = await response.json();
-              console.error(
-                `[Dev Mode] Failed to process message for ${topicName}/${consumerGroup}:`,
-                errorData.error || response.statusText
-              );
-            } catch (jsonError) {
-              console.error(
-                `[Dev Mode] Failed to process message for ${topicName}/${consumerGroup}:`,
-                response.statusText
-              );
-            }
-          }
-        } catch (error) {
-          console.error(
-            `[Dev Mode] Error triggering callback for ${topicName}/${consumerGroup}:`,
-            error
-          );
-        }
+      if (response.status === 409) {
+        throw new MessageNotAvailableError(
+          receiptHandle,
+          errorText || "Invalid receipt handle, message not in correct state, or already processed"
+        );
       }
+      throwCommonHttpError(
+        response.status,
+        response.statusText,
+        errorText,
+        "change visibility (alt)",
+        "Missing receipt handle or invalid visibility timeout"
+      );
     }
-  }, DEV_CALLBACK_DELAY);
-}
-function clearDevHandlers() {
-  devRouteHandlers.clear();
-  wildcardRouteHandlers.clear();
-}
-if (process.env.NODE_ENV === "test" || process.env.VITEST) {
-  globalThis.__clearDevHandlers = clearDevHandlers;
-}
+    return { success: true };
+  }
+};
 
 // src/consumer-group.ts
 var ConsumerGroup = class {
@@ -790,69 +1040,64 @@ var ConsumerGroup = class {
   refreshInterval;
   transport;
   /**
-   * Create a new ConsumerGroup instance
-   * @param client QueueClient instance to use for API calls
-   * @param topicName Name of the topic to consume from
-   * @param consumerGroupName Name of the consumer group
-   * @param options Optional configuration
+   * Create a new ConsumerGroup instance.
+   *
+   * @param client - QueueClient instance to use for API calls
+   * @param topicName - Name of the topic to consume from (pattern: `[A-Za-z0-9_-]+`)
+   * @param consumerGroupName - Name of the consumer group (pattern: `[A-Za-z0-9_-]+`)
+   * @param options - Optional configuration
+   * @param options.transport - Payload serializer (default: JsonTransport)
+   * @param options.visibilityTimeoutSeconds - Message lock duration (default: 30, max: 3600)
+   * @param options.visibilityRefreshInterval - Lock refresh interval in seconds (default: visibilityTimeout / 3)
    */
   constructor(client, topicName, consumerGroupName, options = {}) {
     this.client = client;
     this.topicName = topicName;
     this.consumerGroupName = consumerGroupName;
-    this.visibilityTimeout = options.visibilityTimeoutSeconds || 30;
-    this.refreshInterval = options.refreshInterval || 10;
+    this.visibilityTimeout = options.visibilityTimeoutSeconds ?? 30;
+    this.refreshInterval = options.visibilityRefreshInterval ?? Math.floor(this.visibilityTimeout / 3);
     this.transport = options.transport || new JsonTransport();
   }
   /**
    * Starts a background loop that periodically extends the visibility timeout for a message.
-   * This prevents the message from becoming visible to other consumers while it's being processed.
-   *
-   * The extension loop runs every `refreshInterval` seconds and updates the message's
-   * visibility timeout to `visibilityTimeout` seconds from the current time.
-   *
-   * @param messageId - The unique identifier of the message to extend visibility for
-   * @param ticket - The receipt ticket that proves ownership of the message
-   * @returns A function that when called will stop the extension loop
-   *
-   * @remarks
-   * - The first extension attempt occurs after `refreshInterval` seconds, not immediately
-   * - If an extension fails, the loop terminates with an error logged to console
-   * - The returned stop function is idempotent - calling it multiple times is safe
-   * - By default, the stop function returns immediately without waiting for in-flight
-   * - Pass `true` to the stop function to wait for any in-flight extension to complete
    */
-  startVisibilityExtension(messageId, ticket) {
+  startVisibilityExtension(receiptHandle) {
     let isRunning = true;
+    let isResolved = false;
     let resolveLifecycle;
     let timeoutId = null;
     const lifecyclePromise = new Promise((resolve) => {
       resolveLifecycle = resolve;
     });
+    const safeResolve = () => {
+      if (!isResolved) {
+        isResolved = true;
+        resolveLifecycle();
+      }
+    };
     const extend = async () => {
       if (!isRunning) {
-        resolveLifecycle();
+        safeResolve();
         return;
       }
       try {
         await this.client.changeVisibility({
           queueName: this.topicName,
           consumerGroup: this.consumerGroupName,
-          messageId,
-          ticket,
+          receiptHandle,
           visibilityTimeoutSeconds: this.visibilityTimeout
         });
         if (isRunning) {
           timeoutId = setTimeout(() => extend(), this.refreshInterval * 1e3);
         } else {
-          resolveLifecycle();
+          safeResolve();
         }
       } catch (error) {
         console.error(
-          `Failed to extend visibility for message ${messageId}:`,
+          `Failed to extend visibility for receipt handle ${receiptHandle}:`,
           error
         );
-        resolveLifecycle();
+        safeResolve();
       }
     };
     timeoutId = setTimeout(() => extend(), this.refreshInterval * 1e3);
@@ -865,22 +1110,14 @@ var ConsumerGroup = class {
       if (waitForCompletion) {
         await lifecyclePromise;
       } else {
-        resolveLifecycle();
+        safeResolve();
       }
     };
   }
-  /**
-   * Process a single message with the given handler
-   * @param message The message to process
-   * @param handler Function to process the message
-   */
   async processMessage(message, handler) {
-    const stopExtension = this.startVisibilityExtension(
-      message.messageId,
-      message.ticket
-    );
+    const stopExtension = this.startVisibilityExtension(message.receiptHandle);
     try {
-      const result = await handler(message.payload, {
+      await handler(message.payload, {
         messageId: message.messageId,
         deliveryCount: message.deliveryCount,
         createdAt: message.createdAt,
@@ -888,29 +1125,11 @@ var ConsumerGroup = class {
         consumerGroup: this.consumerGroupName
       });
       await stopExtension();
-      if (result && "timeoutSeconds" in result) {
-        await this.client.changeVisibility({
-          queueName: this.topicName,
-          consumerGroup: this.consumerGroupName,
-          messageId: message.messageId,
-          ticket: message.ticket,
-          visibilityTimeoutSeconds: result.timeoutSeconds
-        });
-        if (isDevMode()) {
-          scheduleDevTimeout(
-            this.topicName,
-            message.messageId,
-            result.timeoutSeconds
-          );
-        }
-      } else {
-        await this.client.deleteMessage({
-          queueName: this.topicName,
-          consumerGroup: this.consumerGroupName,
-          messageId: message.messageId,
-          ticket: message.ticket
-        });
-      }
+      await this.client.deleteMessage({
+        queueName: this.topicName,
+        consumerGroup: this.consumerGroupName,
+        receiptHandle: message.receiptHandle
+      });
     } catch (error) {
       await stopExtension();
       if (this.transport.finalize && message.payload !== void 0 && message.payload !== null) {
@@ -925,36 +1144,16 @@ var ConsumerGroup = class {
   }
   async consume(handler, options) {
     if (options?.messageId) {
-      if (options.skipPayload) {
-        const response = await this.client.receiveMessageById(
-          {
-            queueName: this.topicName,
-            consumerGroup: this.consumerGroupName,
-            messageId: options.messageId,
-            visibilityTimeoutSeconds: this.visibilityTimeout,
-            skipPayload: true
-          },
-          this.transport
-        );
-        await this.processMessage(
-          response.message,
-          handler
-        );
-      } else {
-        const response = await this.client.receiveMessageById(
-          {
-            queueName: this.topicName,
-            consumerGroup: this.consumerGroupName,
-            messageId: options.messageId,
-            visibilityTimeoutSeconds: this.visibilityTimeout
-          },
-          this.transport
-        );
-        await this.processMessage(
-          response.message,
-          handler
-        );
-      }
+      const response = await this.client.receiveMessageById(
+        {
+          queueName: this.topicName,
+          consumerGroup: this.consumerGroupName,
+          messageId: options.messageId,
+          visibilityTimeoutSeconds: this.visibilityTimeout
+        },
+        this.transport
+      );
+      await this.processMessage(response.message, handler);
     } else {
       let messageFound = false;
       for await (const message of this.client.receiveMessages(
@@ -1022,7 +1221,7 @@ var Topic = class {
         payload,
         idempotencyKey: options?.idempotencyKey,
         retentionSeconds: options?.retentionSeconds,
-        deploymentId: options?.deploymentId
+        delaySeconds: options?.delaySeconds
       },
       this.transport
     );
@@ -1132,7 +1331,7 @@ async function parseCallback(request) {
     messageId
   };
 }
-function createCallbackHandler(handlers, client) {
+function createCallbackHandler(handlers, client, visibilityTimeoutSeconds) {
   for (const topicPattern in handlers) {
     if (topicPattern.includes("*")) {
       if (!validateWildcardPattern(topicPattern)) {
@@ -1168,7 +1367,10 @@ function createCallbackHandler(handlers, client) {
         );
       }
       const topic = new Topic(client, queueName);
-      const cg = topic.consumerGroup(consumerGroup);
+      const cg = topic.consumerGroup(
+        consumerGroup,
+        visibilityTimeoutSeconds !== void 0 ? { visibilityTimeoutSeconds } : void 0
+      );
       await cg.consume(consumerGroupHandler, { messageId });
       return Response.json({ status: "success" });
     } catch (error) {
@@ -1182,13 +1384,14 @@ function createCallbackHandler(handlers, client) {
       );
     }
   };
-  if (isDevMode()) {
-    registerDevRouteHandler(routeHandler, handlers);
-  }
   return routeHandler;
 }
-function handleCallback(handlers, client) {
-  return createCallbackHandler(handlers, client || new QueueClient());
+function handleCallback(handlers, options) {
+  return createCallbackHandler(
+    handlers,
+    options?.client || new QueueClient(),
+    options?.visibilityTimeoutSeconds
+  );
 }
 
 // src/factory.ts
@@ -1201,12 +1404,12 @@ async function send(topicName, payload, options) {
       payload,
       idempotencyKey: options?.idempotencyKey,
       retentionSeconds: options?.retentionSeconds,
-      deploymentId: options?.deploymentId
+      delaySeconds: options?.delaySeconds
     },
     transport
   );
   if (isDevMode()) {
-    triggerDevCallbacks(topicName, result.messageId);
+    triggerDevCallbacks(topicName, result.messageId, options?.delaySeconds);
   }
   return { messageId: result.messageId };
 }
@@ -1214,22 +1417,10 @@ async function receive(topicName, consumerGroup, handler, options) {
   const transport = options?.transport || new JsonTransport();
   const client = options?.client || new QueueClient();
   const topic = new Topic(client, topicName, transport);
-  const {
-    messageId,
-    skipPayload,
-    client: _,
-    ...consumerGroupOptions
-  } = options || {};
+  const { messageId, client: _, ...consumerGroupOptions } = options || {};
   const consumer = topic.consumerGroup(consumerGroup, consumerGroupOptions);
   if (messageId) {
-    if (skipPayload) {
-      return consumer.consume(handler, {
-        messageId,
-        skipPayload: true
-      });
-    } else {
-      return consumer.consume(handler, { messageId });
-    }
+    return consumer.consume(handler, { messageId });
   } else {
     return consumer.consume(handler);
   }
@@ -1263,33 +1454,54 @@ var Client = class {
     });
   }
   /**
-   * Create a callback handler for processing queue messages
-   * Returns a Next.js route handler function that routes messages to appropriate handlers
-   * @param handlers Object with topic-specific handlers organized by consumer groups
+   * Create a callback handler for processing queue messages.
+   * Returns a Next.js route handler function that routes messages to appropriate handlers.
+   *
+   * @param handlers - Object with topic-specific handlers organized by consumer groups
+   * @param options - Optional configuration
+   * @param options.visibilityTimeoutSeconds - Message lock duration (default: 30, max: 3600)
    * @returns A Next.js route handler function
    *
    * @example
    * ```typescript
+   * // Basic usage
    * export const POST = client.handleCallback({
    *   "user-events": {
    *     "welcome": (user, metadata) => console.log("Welcoming user", user),
    *     "analytics": (user, metadata) => console.log("Tracking user", user),
    *   },
    * });
+   *
+   * // With custom visibility timeout
+   * export const POST = client.handleCallback({
+   *   "video-processing": {
+   *     "transcode": async (video) => await transcodeVideo(video),
+   *   },
+   * }, {
+   *   visibilityTimeoutSeconds: 300,  // 5 minutes for long operations
+   * });
    * ```
    */
-  handleCallback(handlers) {
-    return handleCallback(handlers, this.client);
+  handleCallback(handlers, options) {
+    return handleCallback(handlers, {
+      ...options,
+      client: this.client
+    });
   }
 };
 export {
   BadRequestError,
   BufferTransport,
   Client,
+  ConcurrencyLimitError,
+  ConsumerDiscoveryError,
+  ConsumerRegistryNotConfiguredError,
+  DuplicateMessageError,
   ForbiddenError,
   InternalServerError,
   InvalidLimitError,
   JsonTransport,
+  MessageAlreadyProcessedError,
   MessageCorruptedError,
   MessageLockedError,
   MessageNotAvailableError,