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

package/dist/index.js

@@ -32,7 +32,8 @@ var index_exports = {};
 __export(index_exports, {
   BadRequestError: () => BadRequestError,
   BufferTransport: () => BufferTransport,
-  Client: () => Client,
+  CLOUD_EVENT_TYPE_V1BETA: () => CLOUD_EVENT_TYPE_V1BETA,
+  CLOUD_EVENT_TYPE_V2BETA: () => CLOUD_EVENT_TYPE_V2BETA,
   ConsumerDiscoveryError: () => ConsumerDiscoveryError,
   ConsumerRegistryNotConfiguredError: () => ConsumerRegistryNotConfiguredError,
   DuplicateMessageError: () => DuplicateMessageError,
@@ -45,11 +46,13 @@ __export(index_exports, {
   MessageLockedError: () => MessageLockedError,
   MessageNotAvailableError: () => MessageNotAvailableError,
   MessageNotFoundError: () => MessageNotFoundError,
+  QueueClient: () => QueueClient,
   QueueEmptyError: () => QueueEmptyError,
   StreamTransport: () => StreamTransport,
   UnauthorizedError: () => UnauthorizedError,
   handleCallback: () => handleCallback,
   parseCallback: () => parseCallback,
+  parseRawCallback: () => parseRawCallback,
   receive: () => receive,
   send: () => send
 });
@@ -233,15 +236,476 @@ var ConsumerRegistryNotConfiguredError = class extends Error {
   }
 };
 
+// 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;
+  /**
+   * Create a new ConsumerGroup instance.
+   *
+   * @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.visibilityTimeoutSeconds - Message lock duration (default: 300, max: 3600)
+   */
+  constructor(client, topicName, consumerGroupName, options = {}) {
+    this.client = client;
+    this.topicName = topicName;
+    this.consumerGroupName = consumerGroupName;
+    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, 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;
+    });
+    const safeResolve = () => {
+      if (!isResolved) {
+        isResolved = true;
+        resolveLifecycle();
+      }
+    };
+    const extend = async () => {
+      if (!isRunning) {
+        safeResolve();
+        return;
+      }
+      try {
+        await this.client.changeVisibility({
+          queueName: this.topicName,
+          consumerGroup: this.consumerGroupName,
+          receiptHandle,
+          visibilityTimeoutSeconds: this.visibilityTimeout
+        });
+        if (isRunning) {
+          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} (will retry in ${RETRY_INTERVAL_MS / 1e3}s):`,
+          error
+        );
+        if (isRunning) {
+          timeoutId = setTimeout(() => extend(), RETRY_INTERVAL_MS);
+        } else {
+          safeResolve();
+        }
+      }
+    };
+    timeoutId = setTimeout(() => extend(), firstDelayMs);
+    return async (waitForCompletion = false) => {
+      isRunning = false;
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+        timeoutId = null;
+      }
+      if (waitForCompletion) {
+        await lifecyclePromise;
+      } else {
+        safeResolve();
+      }
+    };
+  }
+  async processMessage(message, handler, options) {
+    const stopExtension = this.startVisibilityExtension(
+      message.receiptHandle,
+      options
+    );
+    try {
+      await handler(message.payload, {
+        messageId: message.messageId,
+        deliveryCount: message.deliveryCount,
+        createdAt: message.createdAt,
+        topicName: this.topicName,
+        consumerGroup: this.consumerGroupName
+      });
+      await stopExtension();
+      await this.client.deleteMessage({
+        queueName: this.topicName,
+        consumerGroup: this.consumerGroupName,
+        receiptHandle: message.receiptHandle
+      });
+    } catch (error) {
+      await stopExtension();
+      const transport = this.client.getTransport();
+      if (transport.finalize && message.payload !== void 0 && message.payload !== null) {
+        try {
+          await transport.finalize(message.payload);
+        } catch (finalizeError) {
+          console.warn("Failed to finalize message payload:", finalizeError);
+        }
+      }
+      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" 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
+      })) {
+        messageFound = true;
+        await this.processMessage(message, handler);
+      }
+      if (!messageFound) {
+        await handler(null, null);
+      }
+    }
+  }
+  /**
+   * Get the consumer group name
+   */
+  get name() {
+    return this.consumerGroupName;
+  }
+  /**
+   * Get the topic name this consumer group is subscribed to
+   */
+  get topic() {
+    return this.topicName;
+  }
+};
+
+// src/topic.ts
+var Topic = class {
+  client;
+  topicName;
+  /**
+   * Create a new Topic instance
+   * @param client QueueClient instance to use for API calls (transport is configured on the client)
+   * @param topicName Name of the topic to work with
+   */
+  constructor(client, topicName) {
+    this.client = client;
+    this.topicName = topicName;
+  }
+  /**
+   * Publish a message to the topic
+   * @param payload The data to publish
+   * @param options Optional publish options
+   * @returns An object containing the message ID
+   * @throws {BadRequestError} When request parameters are invalid
+   * @throws {UnauthorizedError} When authentication fails
+   * @throws {ForbiddenError} When access is denied (environment mismatch)
+   * @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
+    });
+    if (isDevMode()) {
+      triggerDevCallbacks(this.topicName, result.messageId);
+    }
+    return { messageId: result.messageId };
+  }
+  /**
+   * Create a consumer group for this topic
+   * @param consumerGroupName Name of the consumer group
+   * @param options Optional configuration for the consumer group
+   * @returns A ConsumerGroup instance
+   */
+  consumerGroup(consumerGroupName, options) {
+    return new ConsumerGroup(
+      this.client,
+      this.topicName,
+      consumerGroupName,
+      options
+    );
+  }
+  /**
+   * Get the topic name
+   */
+  get name() {
+    return this.topicName;
+  }
+};
+
+// src/callback.ts
+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 isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function parseV1StructuredBody(body, contentType) {
+  if (!contentType || !contentType.includes("application/cloudevents+json")) {
+    throw new Error(
+      "Invalid content type: expected 'application/cloudevents+json'"
+    );
+  }
+  if (!isRecord(body) || !body.type || !body.source || !body.id || !isRecord(body.data)) {
+    throw new Error("Invalid CloudEvent: missing required fields");
+  }
+  if (body.type !== CLOUD_EVENT_TYPE_V1BETA) {
+    throw new Error(
+      `Invalid CloudEvent type: expected '${CLOUD_EVENT_TYPE_V1BETA}', got '${String(body.type)}'`
+    );
+  }
+  const { data } = body;
+  const missingFields = [];
+  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(", ")}`
+    );
+  }
+  return {
+    queueName: String(data.queueName),
+    consumerGroup: String(data.consumerGroup),
+    messageId: String(data.messageId)
+  };
+}
+function getHeader(headers, name) {
+  if (headers instanceof Headers) {
+    return headers.get(name);
+  }
+  const value = headers[name];
+  if (Array.isArray(value)) return value[0] ?? null;
+  return value ?? null;
+}
+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;
+  }
+  const result = { ...base, receiptHandle };
+  const deliveryCount = getHeader(headers, "ce-vqsdeliverycount");
+  if (deliveryCount) {
+    result.deliveryCount = parseInt(deliveryCount, 10);
+  }
+  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;
+}
+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;
+  }
+  return parseV1StructuredBody(body, getHeader(headers, "content-type"));
+}
+async function parseCallback(request) {
+  const ceType = request.headers.get("ce-type");
+  if (ceType === CLOUD_EVENT_TYPE_V2BETA) {
+    const result = parseBinaryHeaders(request.headers);
+    if ("receiptHandle" in result && request.body) {
+      result.rawBody = request.body;
+    }
+    return result;
+  }
+  let body;
+  try {
+    body = await request.json();
+  } catch {
+    throw new Error("Failed to parse CloudEvent from request body");
+  }
+  const headers = {};
+  request.headers.forEach((value, key) => {
+    headers[key] = value;
+  });
+  return parseRawCallback(body, headers);
+}
+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 {
+    await cg.consume(handler, { messageId });
+  }
+}
+
 // 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) {
@@ -262,11 +726,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)
           });
         }
       }
@@ -299,20 +763,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) {
@@ -386,26 +846,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 {
@@ -512,6 +961,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";
@@ -519,6 +969,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()) {
@@ -575,6 +1029,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.39"}`);
+    init.headers.set("Vqs-Client-Ts", (/* @__PURE__ */ new Date()).toISOString());
     const response = await fetch(url, init);
     if (isDebugEnabled()) {
       const logData = {
@@ -597,7 +1053,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
@@ -607,7 +1062,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,
@@ -689,21 +1145,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);
@@ -734,7 +1193,7 @@ var QueueClient = class {
       }
     );
     if (response.status === 204) {
-      throw new QueueEmptyError(queueName, consumerGroup);
+      return;
     }
     if (!response.ok) {
       const errorText = await response.text();
@@ -775,7 +1234,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
@@ -785,7 +1243,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()}`,
@@ -797,212 +1256,86 @@ var QueueClient = class {
         "Vqs-Visibility-Timeout-Seconds",
         visibilityTimeoutSeconds.toString()
       );
-    }
-    const effectiveDeploymentId = this.getConsumeDeploymentId();
-    if (effectiveDeploymentId) {
-      headers.set("Vqs-Deployment-Id", effectiveDeploymentId);
-    }
-    const response = await this.fetch(
-      this.buildUrl(queueName, "consumer", consumerGroup, "id", messageId),
-      {
-        method: "POST",
-        headers
-      }
-    );
-    if (!response.ok) {
-      const errorText = await response.text();
-      if (response.status === 404) {
-        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 === 410) {
-        throw new MessageAlreadyProcessedError(messageId);
-      }
-      throwCommonHttpError(
-        response.status,
-        response.statusText,
-        errorText,
-        "receive message by ID"
-      );
-    }
-    for await (const multipartMessage of (0, import_mixpart.parseMultipartStream)(response)) {
-      const parsedHeaders = parseQueueHeaders(multipartMessage.headers);
-      if (!parsedHeaders) {
-        await consumeStream(multipartMessage.payload);
-        throw new MessageCorruptedError(
-          messageId,
-          "Missing required queue headers in response"
-        );
-      }
-      const deserializedPayload = await transport.deserialize(
-        multipartMessage.payload
-      );
-      const message = {
-        ...parsedHeaders,
-        payload: deserializedPayload
-      };
-      return { message };
-    }
-    throw new MessageNotFoundError(messageId);
-  }
-  /**
-   * 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
-   * @throws {InternalServerError} When server encounters an error
-   */
-  async deleteMessage(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.buildUrl(
-        queueName,
-        "consumer",
-        consumerGroup,
-        "lease",
-        receiptHandle
-      ),
-      {
-        method: "DELETE",
-        headers
-      }
-    );
-    if (!response.ok) {
-      const errorText = await response.text();
-      if (response.status === 404) {
-        throw new MessageNotFoundError(receiptHandle);
-      }
-      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,
-        "delete message",
-        "Missing or invalid receipt handle"
-      );
-    }
-    return { deleted: true };
-  }
-  /**
-   * 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
-   * @throws {InternalServerError} When server encounters an error
-   */
-  async changeVisibility(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);
     }
     const response = await this.fetch(
-      this.buildUrl(
-        queueName,
-        "consumer",
-        consumerGroup,
-        "lease",
-        receiptHandle
-      ),
+      this.buildUrl(queueName, "consumer", consumerGroup, "id", messageId),
       {
-        method: "PATCH",
-        headers,
-        body: JSON.stringify({ visibilityTimeoutSeconds })
+        method: "POST",
+        headers
       }
     );
     if (!response.ok) {
       const errorText = await response.text();
       if (response.status === 404) {
-        throw new MessageNotFoundError(receiptHandle);
+        throw new MessageNotFoundError(messageId);
       }
       if (response.status === 409) {
-        throw new MessageNotAvailableError(
-          receiptHandle,
-          errorText || "Invalid receipt handle, message not in correct state, or already processed"
-        );
+        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 === 410) {
+        throw new MessageAlreadyProcessedError(messageId);
       }
       throwCommonHttpError(
         response.status,
         response.statusText,
         errorText,
-        "change visibility",
-        "Missing receipt handle or invalid visibility timeout"
+        "receive message by ID"
       );
     }
-    return { success: true };
+    for await (const multipartMessage of (0, import_mixpart.parseMultipartStream)(response)) {
+      const parsedHeaders = parseQueueHeaders(multipartMessage.headers);
+      if (!parsedHeaders) {
+        await consumeStream(multipartMessage.payload);
+        throw new MessageCorruptedError(
+          messageId,
+          "Missing required queue headers in response"
+        );
+      }
+      const deserializedPayload = await transport.deserialize(
+        multipartMessage.payload
+      );
+      const message = {
+        ...parsedHeaders,
+        payload: deserializedPayload
+      };
+      return { message };
+    }
+    throw new MessageNotFoundError(messageId);
   }
   /**
-   * 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.
+   * Delete (acknowledge) a message after successful processing.
    *
-   * @param options - Options for changing visibility
-   * @returns Promise resolving to change visibility response
+   * @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
+   * @throws {InternalServerError} When server encounters an error
    */
-  async changeVisibilityAlt(options) {
-    const {
-      queueName,
-      consumerGroup,
-      receiptHandle,
-      visibilityTimeoutSeconds
-    } = options;
+  async deleteMessage(options) {
+    const { queueName, consumerGroup, receiptHandle } = options;
     const headers = new Headers({
       Authorization: `Bearer ${await this.getToken()}`,
-      "Content-Type": "application/json",
       ...this.customHeaders
     });
     const effectiveDeploymentId = this.getConsumeDeploymentId();
@@ -1015,503 +1348,202 @@ var QueueClient = class {
         "consumer",
         consumerGroup,
         "lease",
-        receiptHandle,
-        "visibility"
-      ),
-      {
-        method: "PATCH",
-        headers,
-        body: JSON.stringify({ visibilityTimeoutSeconds })
-      }
-    );
-    if (!response.ok) {
-      const errorText = await response.text();
-      if (response.status === 404) {
-        throw new MessageNotFoundError(receiptHandle);
-      }
-      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"
-      );
-    }
-    return { success: true };
-  }
-};
-
-// src/consumer-group.ts
-var ConsumerGroup = class {
-  client;
-  topicName;
-  consumerGroupName;
-  visibilityTimeout;
-  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 (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.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.
-   */
-  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) {
-        safeResolve();
-        return;
-      }
-      try {
-        await this.client.changeVisibility({
-          queueName: this.topicName,
-          consumerGroup: this.consumerGroupName,
-          receiptHandle,
-          visibilityTimeoutSeconds: this.visibilityTimeout
-        });
-        if (isRunning) {
-          timeoutId = setTimeout(() => extend(), this.refreshInterval * 1e3);
-        } else {
-          safeResolve();
-        }
-      } catch (error) {
-        console.error(
-          `Failed to extend visibility for receipt handle ${receiptHandle}:`,
-          error
-        );
-        safeResolve();
-      }
-    };
-    timeoutId = setTimeout(() => extend(), this.refreshInterval * 1e3);
-    return async (waitForCompletion = false) => {
-      isRunning = false;
-      if (timeoutId) {
-        clearTimeout(timeoutId);
-        timeoutId = null;
-      }
-      if (waitForCompletion) {
-        await lifecyclePromise;
-      } else {
-        safeResolve();
-      }
-    };
-  }
-  async processMessage(message, handler) {
-    const stopExtension = this.startVisibilityExtension(message.receiptHandle);
-    try {
-      await handler(message.payload, {
-        messageId: message.messageId,
-        deliveryCount: message.deliveryCount,
-        createdAt: message.createdAt,
-        topicName: this.topicName,
-        consumerGroup: this.consumerGroupName
-      });
-      await stopExtension();
-      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) {
-        try {
-          await this.transport.finalize(message.payload);
-        } catch (finalizeError) {
-          console.warn("Failed to finalize message payload:", finalizeError);
-        }
-      }
-      throw error;
-    }
-  }
-  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
-      );
-      await this.processMessage(response.message, handler);
-    } else {
-      let messageFound = false;
-      for await (const message of this.client.receiveMessages(
-        {
-          queueName: this.topicName,
-          consumerGroup: this.consumerGroupName,
-          visibilityTimeoutSeconds: this.visibilityTimeout,
-          limit: 1
-        },
-        this.transport
-      )) {
-        messageFound = true;
-        await this.processMessage(message, handler);
-        break;
-      }
-      if (!messageFound) {
-        throw new Error("No messages available");
-      }
-    }
-  }
-  /**
-   * Get the consumer group name
-   */
-  get name() {
-    return this.consumerGroupName;
-  }
-  /**
-   * Get the topic name this consumer group is subscribed to
-   */
-  get topic() {
-    return this.topicName;
-  }
-};
-
-// src/topic.ts
-var Topic = class {
-  client;
-  topicName;
-  transport;
-  /**
-   * Create a new Topic instance
-   * @param client QueueClient instance to use for API calls
-   * @param topicName Name of the topic to work with
-   * @param transport Optional serializer/deserializer for the payload (defaults to JSON)
-   */
-  constructor(client, topicName, transport) {
-    this.client = client;
-    this.topicName = topicName;
-    this.transport = transport || new JsonTransport();
+        receiptHandle
+      ),
+      {
+        method: "DELETE",
+        headers
+      }
+    );
+    if (!response.ok) {
+      const errorText = await response.text();
+      if (response.status === 404) {
+        throw new MessageNotFoundError(receiptHandle);
+      }
+      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,
+        "delete message",
+        "Missing or invalid receipt handle"
+      );
+    }
+    return { deleted: true };
   }
   /**
-   * Publish a message to the topic
-   * @param payload The data to publish
-   * @param options Optional publish options
-   * @returns An object containing the message ID
-   * @throws {BadRequestError} When request parameters are invalid
+   * 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 publish(payload, options) {
-    const result = await this.client.sendMessage(
+  async changeVisibility(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);
+    }
+    const response = await this.fetch(
+      this.buildUrl(
+        queueName,
+        "consumer",
+        consumerGroup,
+        "lease",
+        receiptHandle
+      ),
       {
-        queueName: this.topicName,
-        payload,
-        idempotencyKey: options?.idempotencyKey,
-        retentionSeconds: options?.retentionSeconds,
-        delaySeconds: options?.delaySeconds,
-        headers: options?.headers
-      },
-      this.transport
+        method: "PATCH",
+        headers,
+        body: JSON.stringify({ visibilityTimeoutSeconds })
+      }
     );
-    if (isDevMode()) {
-      triggerDevCallbacks(this.topicName, result.messageId);
+    if (!response.ok) {
+      const errorText = await response.text();
+      if (response.status === 404) {
+        throw new MessageNotFoundError(receiptHandle);
+      }
+      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",
+        "Missing receipt handle or invalid visibility timeout"
+      );
     }
-    return { messageId: result.messageId };
-  }
-  /**
-   * Create a consumer group for this topic
-   * @param consumerGroupName Name of the consumer group
-   * @param options Optional configuration for the consumer group
-   * @returns A ConsumerGroup instance
-   */
-  consumerGroup(consumerGroupName, options) {
-    const consumerOptions = {
-      ...options,
-      transport: options?.transport || this.transport
-    };
-    return new ConsumerGroup(
-      this.client,
-      this.topicName,
-      consumerGroupName,
-      consumerOptions
-    );
-  }
-  /**
-   * Get the topic name
-   */
-  get name() {
-    return this.topicName;
+    return { success: true };
   }
   /**
-   * Get the transport used by this topic
+   * 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
    */
-  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;
-}
-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];
+  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);
     }
-  }
-  return null;
-}
-async function parseCallback(request) {
-  const contentType = request.headers.get("content-type");
-  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) {
-    throw new Error("Invalid CloudEvent: missing required fields");
-  }
-  if (cloudEvent.type !== "com.vercel.queue.v1beta") {
-    throw new Error(
-      `Invalid CloudEvent type: expected 'com.vercel.queue.v1beta', got '${cloudEvent.type}'`
-    );
-  }
-  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 (missingFields.length > 0) {
-    throw new Error(
-      `Missing required CloudEvent data fields: ${missingFields.join(", ")}`
-    );
-  }
-  const { messageId, queueName, consumerGroup } = cloudEvent.data;
-  return {
-    queueName,
-    consumerGroup,
-    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 response = await this.fetch(
+      this.buildUrl(
+        queueName,
+        "consumer",
+        consumerGroup,
+        "lease",
+        receiptHandle,
+        "visibility"
+      ),
+      {
+        method: "PATCH",
+        headers,
+        body: JSON.stringify({ visibilityTimeoutSeconds })
       }
-    }
-  }
-  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 }
-        );
+    );
+    if (!response.ok) {
+      const errorText = await response.text();
+      if (response.status === 404) {
+        throw new MessageNotFoundError(receiptHandle);
       }
-      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 }
+      if (response.status === 409) {
+        throw new MessageNotAvailableError(
+          receiptHandle,
+          errorText || "Invalid receipt handle, message not in correct state, or already processed"
         );
       }
-      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 }
+      throwCommonHttpError(
+        response.status,
+        response.statusText,
+        errorText,
+        "change visibility (alt)",
+        "Missing receipt handle or invalid visibility timeout"
       );
     }
-  };
-  return routeHandler;
-}
-function handleCallback(handlers, options) {
-  return createCallbackHandler(
-    handlers,
-    options?.client || new QueueClient(),
-    options?.visibilityTimeoutSeconds
-  );
-}
+    return { success: true };
+  }
+};
 
 // src/factory.ts
 async function send(topicName, payload, options) {
-  const transport = options?.transport || new JsonTransport();
   const client = options?.client || new QueueClient();
-  const result = await client.sendMessage(
-    {
-      queueName: topicName,
-      payload,
-      idempotencyKey: options?.idempotencyKey,
-      retentionSeconds: options?.retentionSeconds,
-      delaySeconds: options?.delaySeconds,
-      headers: options?.headers
-    },
-    transport
-  );
+  const result = await client.sendMessage({
+    queueName: topicName,
+    payload,
+    idempotencyKey: options?.idempotencyKey,
+    retentionSeconds: options?.retentionSeconds,
+    delaySeconds: options?.delaySeconds,
+    headers: options?.headers
+  });
   if (isDevMode()) {
     triggerDevCallbacks(topicName, result.messageId, options?.delaySeconds);
   }
   return { messageId: result.messageId };
 }
 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, client: _, ...consumerGroupOptions } = options || {};
-  const consumer = topic.consumerGroup(consumerGroup, consumerGroupOptions);
-  if (messageId) {
-    return consumer.consume(handler, { messageId });
+  const topic = new Topic(client, topicName);
+  const { client: _, ...rest } = options || {};
+  const { visibilityTimeoutSeconds } = rest;
+  const consumer = topic.consumerGroup(
+    consumerGroup,
+    visibilityTimeoutSeconds !== void 0 ? { visibilityTimeoutSeconds } : {}
+  );
+  if (options && "messageId" in options) {
+    return consumer.consume(handler, { messageId: options.messageId });
   } else {
-    return consumer.consume(handler);
+    const limit = options && "limit" in options ? options.limit : void 0;
+    return consumer.consume(handler, limit !== void 0 ? { limit } : {});
   }
 }
-
-// src/queue-client.ts
-var Client = class {
-  client;
-  /**
-   * Create a new Client
-   * @param options QueueClient configuration options
-   */
-  constructor(options = {}) {
-    this.client = new QueueClient(options);
-  }
-  /**
-   * Send a message to a topic
-   * @param topicName Name of the topic to send to
-   * @param payload The data to send
-   * @param options Optional publish options and transport
-   * @returns Promise with the message ID
-   * @throws {BadRequestError} When request parameters are invalid
-   * @throws {UnauthorizedError} When authentication fails
-   * @throws {ForbiddenError} When access is denied (environment mismatch)
-   * @throws {InternalServerError} When server encounters an error
-   */
-  async send(topicName, payload, options) {
-    return send(topicName, payload, {
-      ...options,
-      client: this.client
-    });
-  }
-  /**
-   * 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, options) {
-    return handleCallback(handlers, {
-      ...options,
-      client: this.client
-    });
-  }
-};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   BadRequestError,
   BufferTransport,
-  Client,
+  CLOUD_EVENT_TYPE_V1BETA,
+  CLOUD_EVENT_TYPE_V2BETA,
   ConsumerDiscoveryError,
   ConsumerRegistryNotConfiguredError,
   DuplicateMessageError,
@@ -1524,11 +1556,13 @@ var Client = class {
   MessageLockedError,
   MessageNotAvailableError,
   MessageNotFoundError,
+  QueueClient,
   QueueEmptyError,
   StreamTransport,
   UnauthorizedError,
   handleCallback,
   parseCallback,
+  parseRawCallback,
   receive,
   send
 });