@vercel/queue 0.0.0-alpha.37 → 0.0.0-alpha.38

package/dist/nextjs-pages.js

@@ -41,46 +41,6 @@ var import_mixpart = require("mixpart");
 var fs = __toESM(require("fs"));
 var path = __toESM(require("path"));
 
-// src/transports.ts
-async function streamToBuffer(stream) {
-  let totalLength = 0;
-  const reader = stream.getReader();
-  const chunks = [];
-  try {
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      chunks.push(value);
-      totalLength += value.length;
-    }
-  } finally {
-    reader.releaseLock();
-  }
-  return Buffer.concat(chunks, totalLength);
-}
-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;
-  }
-  serialize(value) {
-    return Buffer.from(JSON.stringify(value, this.replacer), "utf8");
-  }
-  async deserialize(stream) {
-    const buffer = await streamToBuffer(stream);
-    return JSON.parse(buffer.toString("utf8"), this.reviver);
-  }
-};
-
 // src/types.ts
 var MessageNotFoundError = class extends Error {
   constructor(messageId) {
@@ -102,14 +62,6 @@ var MessageCorruptedError = class extends Error {
     this.name = "MessageCorruptedError";
   }
 };
-var QueueEmptyError = class extends Error {
-  constructor(queueName, consumerGroup) {
-    super(
-      `No messages available in queue "${queueName}" for consumer group "${consumerGroup}"`
-    );
-    this.name = "QueueEmptyError";
-  }
-};
 var UnauthorizedError = class extends Error {
   constructor(message = "Missing or invalid authentication token") {
     super(message);
@@ -172,12 +124,15 @@ var ConsumerRegistryNotConfiguredError = class extends Error {
 // 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)$/, "");
+  let urlPath = filePath.replace(/^app\//, "/").replace(/^pages\//, "/").replace(/\/route\.(ts|mts|js|mjs|tsx|jsx)$/, "").replace(/\.(ts|mts|js|mjs|tsx|jsx)$/, "");
   if (!urlPath.startsWith("/")) {
     urlPath = "/" + urlPath;
   }
   return urlPath;
 }
+function filePathToConsumerGroup(filePath) {
+  return filePath.replace(/_/g, "__").replace(/\//g, "_S").replace(/\./g, "_D");
+}
 function getDevRouteMappings() {
   const g = globalThis;
   if (ROUTE_MAPPINGS_KEY in g) {
@@ -198,11 +153,11 @@ function getDevRouteMappings() {
     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) {
+        if (trigger.type?.startsWith("queue/") && trigger.topic) {
           mappings.push({
             urlPath: filePathToUrlPath(filePath),
             topic: trigger.topic,
-            consumer: trigger.consumer
+            consumer: filePathToConsumerGroup(filePath)
           });
         }
       }
@@ -235,20 +190,16 @@ 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
-      );
+      await client.receiveMessageById({
+        queueName: topicName,
+        consumerGroup,
+        messageId,
+        visibilityTimeoutSeconds: 0
+      });
       return true;
     } catch (error) {
       if (error instanceof MessageNotFoundError) {
@@ -322,26 +273,15 @@ function triggerDevCallbacks(topicName, messageId, delaySeconds) {
       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)
+            "ce-type": CLOUD_EVENT_TYPE_V2BETA,
+            "ce-vqsqueuename": topicName,
+            "ce-vqsconsumergroup": route.consumer,
+            "ce-vqsmessageid": messageId
+          }
         });
         if (response.ok) {
           try {
@@ -388,6 +328,46 @@ if (process.env.NODE_ENV === "test" || process.env.VITEST) {
 // src/oidc.ts
 var import_oidc = require("@vercel/oidc");
 
+// src/transports.ts
+async function streamToBuffer(stream) {
+  let totalLength = 0;
+  const reader = stream.getReader();
+  const chunks = [];
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      chunks.push(value);
+      totalLength += value.length;
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  return Buffer.concat(chunks, totalLength);
+}
+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;
+  }
+  serialize(value) {
+    return Buffer.from(JSON.stringify(value, this.replacer), "utf8");
+  }
+  async deserialize(stream) {
+    const buffer = await streamToBuffer(stream);
+    return JSON.parse(buffer.toString("utf8"), this.reviver);
+  }
+};
+
 // src/client.ts
 function isDebugEnabled() {
   return process.env.VERCEL_QUEUE_DEBUG === "1" || process.env.VERCEL_QUEUE_DEBUG === "true";
@@ -448,6 +428,7 @@ var QueueClient = class {
   providedToken;
   defaultDeploymentId;
   pinToDeployment;
+  transport;
   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/v3/topic";
@@ -455,6 +436,10 @@ var QueueClient = class {
     this.providedToken = options.token;
     this.defaultDeploymentId = options.deploymentId || process.env.VERCEL_DEPLOYMENT_ID;
     this.pinToDeployment = options.pinToDeployment ?? true;
+    this.transport = options.transport || new JsonTransport();
+  }
+  getTransport() {
+    return this.transport;
   }
   getSendDeploymentId() {
     if (isDevMode()) {
@@ -511,6 +496,8 @@ var QueueClient = class {
       }
       console.debug("[VQS Debug] Request:", JSON.stringify(logData, null, 2));
     }
+    init.headers.set("User-Agent", `@vercel/queue/${"0.0.0-alpha.38"}`);
+    init.headers.set("Vqs-Client-Ts", (/* @__PURE__ */ new Date()).toISOString());
     const response = await fetch(url, init);
     if (isDebugEnabled()) {
       const logData = {
@@ -533,7 +520,6 @@ var QueueClient = class {
    * @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
@@ -543,7 +529,8 @@ var QueueClient = class {
    * @throws {ForbiddenError} When access is denied
    * @throws {InternalServerError} When server encounters an error
    */
-  async sendMessage(options, transport) {
+  async sendMessage(options) {
+    const transport = this.transport;
     const {
       queueName,
       payload,
@@ -625,21 +612,24 @@ var QueueClient = class {
   /**
    * Receive messages from a topic as an async generator.
    *
+   * When the queue is empty, the generator completes without yielding any
+   * messages. Callers should handle the case where no messages are yielded.
+   *
    * @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 transport - Deserializer for message payloads
    * @yields Message objects with payload, messageId, receiptHandle, etc.
-   * @throws {QueueEmptyError} When no messages available
+   *         Yields nothing if queue is empty.
    * @throws {InvalidLimitError} When limit is outside 1-10 range
    * @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 *receiveMessages(options, transport) {
+  async *receiveMessages(options) {
+    const transport = this.transport;
     const { queueName, consumerGroup, visibilityTimeoutSeconds, limit } = options;
     if (limit !== void 0 && (limit < 1 || limit > 10)) {
       throw new InvalidLimitError(limit);
@@ -670,7 +660,7 @@ var QueueClient = class {
       }
     );
     if (response.status === 204) {
-      throw new QueueEmptyError(queueName, consumerGroup);
+      return;
     }
     if (!response.ok) {
       const errorText = await response.text();
@@ -711,7 +701,6 @@ var QueueClient = class {
    * @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 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
@@ -721,7 +710,8 @@ var QueueClient = class {
    * @throws {ForbiddenError} When access is denied
    * @throws {InternalServerError} When server encounters an error
    */
-  async receiveMessageById(options, transport) {
+  async receiveMessageById(options) {
+    const transport = this.transport;
     const { queueName, consumerGroup, messageId, visibilityTimeoutSeconds } = options;
     const headers = new Headers({
       Authorization: `Bearer ${await this.getToken()}`,
@@ -984,40 +974,90 @@ var QueueClient = class {
 };
 
 // src/consumer-group.ts
+var DEFAULT_VISIBILITY_TIMEOUT_SECONDS = 300;
+var MIN_VISIBILITY_TIMEOUT_SECONDS = 30;
+var MAX_RENEWAL_INTERVAL_SECONDS = 60;
+var MIN_RENEWAL_INTERVAL_SECONDS = 10;
+var RETRY_INTERVAL_MS = 3e3;
+function calculateRenewalInterval(visibilityTimeoutSeconds) {
+  return Math.min(
+    MAX_RENEWAL_INTERVAL_SECONDS,
+    Math.max(MIN_RENEWAL_INTERVAL_SECONDS, visibilityTimeoutSeconds / 5)
+  );
+}
 var ConsumerGroup = class {
   client;
   topicName;
   consumerGroupName;
   visibilityTimeout;
-  refreshInterval;
-  transport;
   /**
    * Create a new ConsumerGroup instance.
    *
-   * @param client - QueueClient instance to use for API calls
+   * @param client - QueueClient instance to use for API calls (transport is configured on the client)
    * @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)
+   * @param options.visibilityTimeoutSeconds - Message lock duration (default: 300, max: 3600)
    */
   constructor(client, topicName, consumerGroupName, options = {}) {
     this.client = client;
     this.topicName = topicName;
     this.consumerGroupName = consumerGroupName;
-    this.visibilityTimeout = options.visibilityTimeoutSeconds ?? 30;
-    this.refreshInterval = options.visibilityRefreshInterval ?? Math.floor(this.visibilityTimeout / 3);
-    this.transport = options.transport || new JsonTransport();
+    this.visibilityTimeout = Math.max(
+      MIN_VISIBILITY_TIMEOUT_SECONDS,
+      options.visibilityTimeoutSeconds ?? DEFAULT_VISIBILITY_TIMEOUT_SECONDS
+    );
+  }
+  /**
+   * Check if an error is a 4xx client error that should stop retries.
+   * 4xx errors indicate the request is fundamentally invalid and retrying won't help.
+   * - 409: Ticket mismatch (lost ownership to another consumer)
+   * - 404: Message/receipt handle not found
+   * - 400, 401, 403: Other client errors
+   */
+  isClientError(error) {
+    return error instanceof MessageNotAvailableError || // 409 - ticket mismatch, lost ownership
+    error instanceof MessageNotFoundError || // 404 - receipt handle not found
+    error instanceof BadRequestError || // 400 - invalid parameters
+    error instanceof UnauthorizedError || // 401 - auth failed
+    error instanceof ForbiddenError;
   }
   /**
    * Starts a background loop that periodically extends the visibility timeout for a message.
+   *
+   * Timing strategy:
+   * - Renewal interval: min(60s, max(10s, visibilityTimeout/5))
+   * - Extensions request the same duration as the initial visibility timeout
+   * - When `visibilityDeadline` is provided (binary mode small body), the first
+   *   extension delay is calculated from the time remaining until the deadline
+   *   using the same renewal formula, ensuring the first extension fires before
+   *   the server-assigned lease expires. Subsequent renewals use the standard interval.
+   *
+   * Retry strategy:
+   * - On transient failures (5xx, network errors): retry every 3 seconds
+   * - On 4xx client errors: stop retrying (the lease is lost or invalid)
+   *
+   * @param receiptHandle - The receipt handle to extend visibility for
+   * @param options - Optional configuration
+   * @param options.visibilityDeadline - Absolute deadline (from server's `ce-vqsvisibilitydeadline`)
+   *   when the current visibility timeout expires. Used to calculate the first extension delay.
    */
-  startVisibilityExtension(receiptHandle) {
+  startVisibilityExtension(receiptHandle, options) {
     let isRunning = true;
     let isResolved = false;
     let resolveLifecycle;
     let timeoutId = null;
+    const renewalIntervalMs = calculateRenewalInterval(this.visibilityTimeout) * 1e3;
+    let firstDelayMs = renewalIntervalMs;
+    if (options?.visibilityDeadline) {
+      const timeRemainingMs = options.visibilityDeadline.getTime() - Date.now();
+      if (timeRemainingMs > 0) {
+        const timeRemainingSeconds = timeRemainingMs / 1e3;
+        firstDelayMs = calculateRenewalInterval(timeRemainingSeconds) * 1e3;
+      } else {
+        firstDelayMs = 0;
+      }
+    }
     const lifecyclePromise = new Promise((resolve) => {
       resolveLifecycle = resolve;
     });
@@ -1040,19 +1080,31 @@ var ConsumerGroup = class {
           visibilityTimeoutSeconds: this.visibilityTimeout
         });
         if (isRunning) {
-          timeoutId = setTimeout(() => extend(), this.refreshInterval * 1e3);
+          timeoutId = setTimeout(() => extend(), renewalIntervalMs);
         } else {
           safeResolve();
         }
       } catch (error) {
+        if (this.isClientError(error)) {
+          console.error(
+            `Visibility extension failed with client error for receipt handle ${receiptHandle} (stopping retries):`,
+            error
+          );
+          safeResolve();
+          return;
+        }
         console.error(
-          `Failed to extend visibility for receipt handle ${receiptHandle}:`,
+          `Failed to extend visibility for receipt handle ${receiptHandle} (will retry in ${RETRY_INTERVAL_MS / 1e3}s):`,
           error
         );
-        safeResolve();
+        if (isRunning) {
+          timeoutId = setTimeout(() => extend(), RETRY_INTERVAL_MS);
+        } else {
+          safeResolve();
+        }
       }
     };
-    timeoutId = setTimeout(() => extend(), this.refreshInterval * 1e3);
+    timeoutId = setTimeout(() => extend(), firstDelayMs);
     return async (waitForCompletion = false) => {
       isRunning = false;
       if (timeoutId) {
@@ -1066,8 +1118,11 @@ var ConsumerGroup = class {
       }
     };
   }
-  async processMessage(message, handler) {
-    const stopExtension = this.startVisibilityExtension(message.receiptHandle);
+  async processMessage(message, handler, options) {
+    const stopExtension = this.startVisibilityExtension(
+      message.receiptHandle,
+      options
+    );
     try {
       await handler(message.payload, {
         messageId: message.messageId,
@@ -1084,9 +1139,10 @@ var ConsumerGroup = class {
       });
     } catch (error) {
       await stopExtension();
-      if (this.transport.finalize && message.payload !== void 0 && message.payload !== null) {
+      const transport = this.client.getTransport();
+      if (transport.finalize && message.payload !== void 0 && message.payload !== null) {
         try {
-          await this.transport.finalize(message.payload);
+          await transport.finalize(message.payload);
         } catch (finalizeError) {
           console.warn("Failed to finalize message payload:", finalizeError);
         }
@@ -1094,35 +1150,49 @@ var ConsumerGroup = class {
       throw error;
     }
   }
+  /**
+   * Process a pre-fetched message directly, without calling `receiveMessageById`.
+   *
+   * Used by the binary mode (v2beta) small body fast path, where the server
+   * pushes the full message payload in the callback request. The message is
+   * processed with the same lifecycle guarantees as `consume()`:
+   * - Visibility timeout is extended periodically during processing
+   * - Message is deleted on successful handler completion
+   * - Payload is finalized on error if the transport supports it
+   *
+   * @param handler - Function to process the message payload and metadata
+   * @param message - The complete message including payload and receipt handle
+   * @param options - Optional configuration
+   * @param options.visibilityDeadline - Absolute deadline when the server-assigned
+   *   visibility timeout expires (from `ce-vqsvisibilitydeadline`). Used to
+   *   schedule the first visibility extension before the lease expires.
+   */
+  async consumeMessage(handler, message, options) {
+    await this.processMessage(message, handler, options);
+  }
   async consume(handler, options) {
-    if (options?.messageId) {
-      const response = await this.client.receiveMessageById(
-        {
-          queueName: this.topicName,
-          consumerGroup: this.consumerGroupName,
-          messageId: options.messageId,
-          visibilityTimeoutSeconds: this.visibilityTimeout
-        },
-        this.transport
-      );
+    if (options && "messageId" in options) {
+      const response = await this.client.receiveMessageById({
+        queueName: this.topicName,
+        consumerGroup: this.consumerGroupName,
+        messageId: options.messageId,
+        visibilityTimeoutSeconds: this.visibilityTimeout
+      });
       await this.processMessage(response.message, handler);
     } else {
+      const limit = options && "limit" in options ? options.limit : 1;
       let messageFound = false;
-      for await (const message of this.client.receiveMessages(
-        {
-          queueName: this.topicName,
-          consumerGroup: this.consumerGroupName,
-          visibilityTimeoutSeconds: this.visibilityTimeout,
-          limit: 1
-        },
-        this.transport
-      )) {
+      for await (const message of this.client.receiveMessages({
+        queueName: this.topicName,
+        consumerGroup: this.consumerGroupName,
+        visibilityTimeoutSeconds: this.visibilityTimeout,
+        limit
+      })) {
         messageFound = true;
         await this.processMessage(message, handler);
-        break;
       }
       if (!messageFound) {
-        throw new Error("No messages available");
+        await handler(null, null);
       }
     }
   }
@@ -1144,17 +1214,14 @@ var ConsumerGroup = class {
 var Topic = class {
   client;
   topicName;
-  transport;
   /**
    * Create a new Topic instance
-   * @param client QueueClient instance to use for API calls
+   * @param client QueueClient instance to use for API calls (transport is configured on the client)
    * @param topicName Name of the topic to work with
-   * @param transport Optional serializer/deserializer for the payload (defaults to JSON)
    */
-  constructor(client, topicName, transport) {
+  constructor(client, topicName) {
     this.client = client;
     this.topicName = topicName;
-    this.transport = transport || new JsonTransport();
   }
   /**
    * Publish a message to the topic
@@ -1167,17 +1234,14 @@ var Topic = class {
    * @throws {InternalServerError} When server encounters an error
    */
   async publish(payload, options) {
-    const result = await this.client.sendMessage(
-      {
-        queueName: this.topicName,
-        payload,
-        idempotencyKey: options?.idempotencyKey,
-        retentionSeconds: options?.retentionSeconds,
-        delaySeconds: options?.delaySeconds,
-        headers: options?.headers
-      },
-      this.transport
-    );
+    const result = await this.client.sendMessage({
+      queueName: this.topicName,
+      payload,
+      idempotencyKey: options?.idempotencyKey,
+      retentionSeconds: options?.retentionSeconds,
+      delaySeconds: options?.delaySeconds,
+      headers: options?.headers
+    });
     if (isDevMode()) {
       triggerDevCallbacks(this.topicName, result.messageId);
     }
@@ -1190,15 +1254,11 @@ var Topic = class {
    * @returns A ConsumerGroup instance
    */
   consumerGroup(consumerGroupName, options) {
-    const consumerOptions = {
-      ...options,
-      transport: options?.transport || this.transport
-    };
     return new ConsumerGroup(
       this.client,
       this.topicName,
       consumerGroupName,
-      consumerOptions
+      options
     );
   }
   /**
@@ -1207,220 +1267,167 @@ var Topic = class {
   get name() {
     return this.topicName;
   }
-  /**
-   * Get the transport used by this topic
-   */
-  get serializer() {
-    return this.transport;
-  }
 };
 
 // src/callback.ts
-function validateWildcardPattern(pattern) {
-  const firstIndex = pattern.indexOf("*");
-  const lastIndex = pattern.lastIndexOf("*");
-  if (firstIndex !== lastIndex) {
-    return false;
-  }
-  if (firstIndex === -1) {
-    return false;
-  }
-  if (firstIndex !== pattern.length - 1) {
-    return false;
-  }
-  return true;
-}
+var CLOUD_EVENT_TYPE_V1BETA = "com.vercel.queue.v1beta";
+var CLOUD_EVENT_TYPE_V2BETA = "com.vercel.queue.v2beta";
 function matchesWildcardPattern(topicName, pattern) {
   const prefix = pattern.slice(0, -1);
   return topicName.startsWith(prefix);
 }
-function findTopicHandler(queueName, handlers) {
-  const exactHandler = handlers[queueName];
-  if (exactHandler) {
-    return exactHandler;
-  }
-  for (const pattern in handlers) {
-    if (pattern.includes("*") && matchesWildcardPattern(queueName, pattern)) {
-      return handlers[pattern];
-    }
-  }
-  return null;
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
 }
-async function parseCallback(request) {
-  const contentType = request.headers.get("content-type");
+function parseV1StructuredBody(body, contentType) {
   if (!contentType || !contentType.includes("application/cloudevents+json")) {
     throw new Error(
       "Invalid content type: expected 'application/cloudevents+json'"
     );
   }
-  let cloudEvent;
-  try {
-    cloudEvent = await request.json();
-  } catch (error) {
-    throw new Error("Failed to parse CloudEvent from request body");
-  }
-  if (!cloudEvent.type || !cloudEvent.source || !cloudEvent.id || typeof cloudEvent.data !== "object" || cloudEvent.data == null) {
+  if (!isRecord(body) || !body.type || !body.source || !body.id || !isRecord(body.data)) {
     throw new Error("Invalid CloudEvent: missing required fields");
   }
-  if (cloudEvent.type !== "com.vercel.queue.v1beta") {
+  if (body.type !== CLOUD_EVENT_TYPE_V1BETA) {
     throw new Error(
-      `Invalid CloudEvent type: expected 'com.vercel.queue.v1beta', got '${cloudEvent.type}'`
+      `Invalid CloudEvent type: expected '${CLOUD_EVENT_TYPE_V1BETA}', got '${String(body.type)}'`
     );
   }
+  const { data } = body;
   const missingFields = [];
-  if (!("queueName" in cloudEvent.data)) missingFields.push("queueName");
-  if (!("consumerGroup" in cloudEvent.data))
-    missingFields.push("consumerGroup");
-  if (!("messageId" in cloudEvent.data)) missingFields.push("messageId");
+  if (!("queueName" in data)) missingFields.push("queueName");
+  if (!("consumerGroup" in data)) missingFields.push("consumerGroup");
+  if (!("messageId" in data)) missingFields.push("messageId");
   if (missingFields.length > 0) {
     throw new Error(
       `Missing required CloudEvent data fields: ${missingFields.join(", ")}`
     );
   }
-  const { messageId, queueName, consumerGroup } = cloudEvent.data;
   return {
-    queueName,
-    consumerGroup,
-    messageId
+    queueName: String(data.queueName),
+    consumerGroup: String(data.consumerGroup),
+    messageId: String(data.messageId)
   };
 }
-function createCallbackHandler(handlers, client, visibilityTimeoutSeconds) {
-  for (const topicPattern in handlers) {
-    if (topicPattern.includes("*")) {
-      if (!validateWildcardPattern(topicPattern)) {
-        throw new Error(
-          `Invalid wildcard pattern "${topicPattern}": * may only appear once and must be at the end of the topic name`
-        );
-      }
-    }
-  }
-  const routeHandler = async (request) => {
-    try {
-      const { queueName, consumerGroup, messageId } = await parseCallback(request);
-      const topicHandler = findTopicHandler(queueName, handlers);
-      if (!topicHandler) {
-        const availableTopics = Object.keys(handlers).join(", ");
-        return Response.json(
-          {
-            error: `No handler found for topic: ${queueName}`,
-            availableTopics
-          },
-          { status: 404 }
-        );
-      }
-      const consumerGroupHandler = topicHandler[consumerGroup];
-      if (!consumerGroupHandler) {
-        const availableGroups = Object.keys(topicHandler).join(", ");
-        return Response.json(
-          {
-            error: `No handler found for consumer group "${consumerGroup}" in topic "${queueName}".`,
-            availableGroups
-          },
-          { status: 404 }
-        );
-      }
-      const topic = new Topic(client, queueName);
-      const cg = topic.consumerGroup(
-        consumerGroup,
-        visibilityTimeoutSeconds !== void 0 ? { visibilityTimeoutSeconds } : void 0
-      );
-      await cg.consume(consumerGroupHandler, { messageId });
-      return Response.json({ status: "success" });
-    } catch (error) {
-      console.error("Queue callback error:", error);
-      if (error instanceof Error && (error.message.includes("Missing required CloudEvent data fields") || error.message.includes("Invalid CloudEvent") || error.message.includes("Invalid CloudEvent type") || error.message.includes("Invalid content type") || error.message.includes("Failed to parse CloudEvent"))) {
-        return Response.json({ error: error.message }, { status: 400 });
-      }
-      return Response.json(
-        { error: "Failed to process queue message" },
-        { status: 500 }
-      );
-    }
-  };
-  return routeHandler;
-}
-function handleCallback(handlers, options) {
-  return createCallbackHandler(
-    handlers,
-    options?.client || new QueueClient(),
-    options?.visibilityTimeoutSeconds
-  );
-}
-
-// src/nextjs-pages.ts
 function getHeader(headers, name) {
+  if (headers instanceof Headers) {
+    return headers.get(name);
+  }
   const value = headers[name];
-  return Array.isArray(value) ? value[0] : value;
+  if (Array.isArray(value)) return value[0] ?? null;
+  return value ?? null;
 }
-function readBody(req) {
-  return new Promise((resolve, reject) => {
-    const chunks = [];
-    req.on("data", (chunk) => chunks.push(chunk));
-    req.on("end", () => resolve(Buffer.concat(chunks).toString("utf-8")));
-    req.on("error", reject);
-  });
-}
-async function getBody(req) {
-  if (req.body === void 0) {
-    return readBody(req);
+function parseBinaryHeaders(headers) {
+  const ceType = getHeader(headers, "ce-type");
+  if (ceType !== CLOUD_EVENT_TYPE_V2BETA) {
+    throw new Error(
+      `Invalid CloudEvent type: expected '${CLOUD_EVENT_TYPE_V2BETA}', got '${ceType}'`
+    );
+  }
+  const queueName = getHeader(headers, "ce-vqsqueuename");
+  const consumerGroup = getHeader(headers, "ce-vqsconsumergroup");
+  const messageId = getHeader(headers, "ce-vqsmessageid");
+  const missingFields = [];
+  if (!queueName) missingFields.push("ce-vqsqueuename");
+  if (!consumerGroup) missingFields.push("ce-vqsconsumergroup");
+  if (!messageId) missingFields.push("ce-vqsmessageid");
+  if (missingFields.length > 0) {
+    throw new Error(
+      `Missing required CloudEvent headers: ${missingFields.join(", ")}`
+    );
+  }
+  const base = {
+    queueName,
+    consumerGroup,
+    messageId
+  };
+  const receiptHandle = getHeader(headers, "ce-vqsreceipthandle");
+  if (!receiptHandle) {
+    return base;
   }
-  if (typeof req.body === "string") {
-    return req.body;
+  const result = { ...base, receiptHandle };
+  const deliveryCount = getHeader(headers, "ce-vqsdeliverycount");
+  if (deliveryCount) {
+    result.deliveryCount = parseInt(deliveryCount, 10);
   }
-  return JSON.stringify(req.body);
+  const createdAt = getHeader(headers, "ce-vqscreatedat");
+  if (createdAt) {
+    result.createdAt = createdAt;
+  }
+  const contentType = getHeader(headers, "content-type");
+  if (contentType) {
+    result.contentType = contentType;
+  }
+  const visibilityDeadline = getHeader(headers, "ce-vqsvisibilitydeadline");
+  if (visibilityDeadline) {
+    result.visibilityDeadline = visibilityDeadline;
+  }
+  return result;
 }
-async function createRequestFromNextApi(req) {
-  const protocol = getHeader(req.headers, "x-forwarded-proto") ?? "https";
-  const host = getHeader(req.headers, "host");
-  if (!host) {
-    throw new Error("Missing host header");
-  }
-  const url = `${protocol}://${host}${req.url}`;
-  const headers = new Headers();
-  for (const [key, value] of Object.entries(req.headers)) {
-    if (value) {
-      if (Array.isArray(value)) {
-        value.forEach((v) => headers.append(key, v));
-      } else {
-        headers.set(key, value);
-      }
+function parseRawCallback(body, headers) {
+  const ceType = getHeader(headers, "ce-type");
+  if (ceType === CLOUD_EVENT_TYPE_V2BETA) {
+    const result = parseBinaryHeaders(headers);
+    if ("receiptHandle" in result) {
+      result.parsedPayload = body;
     }
+    return result;
   }
-  const body = await getBody(req);
-  return new Request(url, {
-    method: req.method || "POST",
-    headers,
-    body
-  });
+  return parseV1StructuredBody(body, getHeader(headers, "content-type"));
 }
-async function sendResponseToNextApi(response, res) {
-  res.status(response.status);
-  response.headers.forEach((value, key) => {
-    res.setHeader(key, value);
-  });
-  const contentType = response.headers.get("content-type");
-  if (contentType?.includes("application/json")) {
-    const data = await response.json();
-    res.json(data);
+async function handleCallback(handler, request, options) {
+  const { queueName, consumerGroup, messageId } = request;
+  const client = options?.client || new QueueClient();
+  const topic = new Topic(client, queueName);
+  const cg = topic.consumerGroup(
+    consumerGroup,
+    options?.visibilityTimeoutSeconds !== void 0 ? { visibilityTimeoutSeconds: options.visibilityTimeoutSeconds } : void 0
+  );
+  if ("receiptHandle" in request) {
+    const transport = client.getTransport();
+    let payload;
+    if (request.rawBody) {
+      payload = await transport.deserialize(request.rawBody);
+    } else if (request.parsedPayload !== void 0) {
+      payload = request.parsedPayload;
+    } else {
+      throw new Error(
+        "Binary mode callback with receipt handle is missing payload"
+      );
+    }
+    const message = {
+      messageId,
+      payload,
+      deliveryCount: request.deliveryCount ?? 1,
+      createdAt: request.createdAt ? new Date(request.createdAt) : /* @__PURE__ */ new Date(),
+      contentType: request.contentType ?? transport.contentType,
+      receiptHandle: request.receiptHandle
+    };
+    const visibilityDeadline = request.visibilityDeadline ? new Date(request.visibilityDeadline) : void 0;
+    await cg.consumeMessage(handler, message, { visibilityDeadline });
   } else {
-    const text = await response.text();
-    res.send(text);
+    await cg.consume(handler, { messageId });
   }
 }
-function handleCallback2(handlers) {
-  const webHandler = handleCallback(handlers);
+
+// src/nextjs-pages.ts
+function handleCallback2(handler, options) {
   return async (req, res) => {
     if (req.method !== "POST") {
       res.status(200).end();
       return;
     }
     try {
-      const request = await createRequestFromNextApi(req);
-      const response = await webHandler(request);
-      await sendResponseToNextApi(response, res);
+      const parsed = parseRawCallback(req.body, req.headers);
+      await handleCallback(handler, parsed, options);
+      res.status(200).json({ status: "success" });
     } catch (error) {
-      console.error("Pages Router adapter error:", error);
-      res.status(500).json({ error: "Internal server error" });
+      console.error("Queue callback error:", error);
+      if (error instanceof Error && (error.message.includes("Invalid content type") || error.message.includes("Invalid CloudEvent") || error.message.includes("Missing required CloudEvent") || error.message.includes("Failed to parse CloudEvent") || error.message.includes("Binary mode callback"))) {
+        res.status(400).json({ error: error.message });
+        return;
+      }
+      res.status(500).json({ error: "Failed to process queue message" });
     }
   };
 }