@commerce-ai-tool/server 2.4.0

package/dist/next.cjs

@@ -0,0 +1,1511 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/next.ts
+var next_exports = {};
+__export(next_exports, {
+  createNextHandlers: () => createNextHandlers
+});
+module.exports = __toCommonJS(next_exports);
+
+// src/handler-response.ts
+function jsonResponse(data, status = 200) {
+  return {
+    status,
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(data)
+  };
+}
+function errorResponse(message, status = 500) {
+  return jsonResponse({ error: message }, status);
+}
+function toWebResponse(handlerResponse) {
+  const headers = new Headers(handlerResponse.headers);
+  const body = typeof handlerResponse.body === "string" ? handlerResponse.body : new Uint8Array(handlerResponse.body);
+  return new Response(body, { status: handlerResponse.status, headers });
+}
+function toWebErrorResponse(message, status = 500) {
+  return Response.json({ error: message }, { status });
+}
+
+// src/route-actions.ts
+var import_core3 = require("@commerce-ai-tool/core");
+
+// src/cart-session.ts
+var import_node_crypto = require("crypto");
+var import_core = require("@commerce-ai-tool/core");
+function readCartSessionHeader(headers) {
+  if (!headers) {
+    return void 0;
+  }
+  if (typeof headers.get === "function") {
+    const value2 = headers.get(import_core.CART_SESSION_HEADER);
+    const trimmed2 = value2?.trim();
+    return trimmed2 || void 0;
+  }
+  const raw = headers[import_core.CART_SESSION_HEADER];
+  const value = Array.isArray(raw) ? raw[0] : raw;
+  const trimmed = value?.trim();
+  return trimmed || void 0;
+}
+var CART_SESSION_TTL_SECONDS = 60 * 60 * 24 * 7;
+var InvalidCartSessionError = class extends Error {
+  constructor(message = "Invalid cart session") {
+    super(message);
+    this.name = "InvalidCartSessionError";
+  }
+};
+function signCartSession(payload, secret, nowSeconds = Math.floor(Date.now() / 1e3)) {
+  const body = {
+    customerId: payload.customerId,
+    email: payload.email,
+    exp: nowSeconds + CART_SESSION_TTL_SECONDS
+  };
+  const encoded = Buffer.from(JSON.stringify(body), "utf8").toString("base64url");
+  const signature = (0, import_node_crypto.createHmac)("sha256", secret).update(encoded).digest("base64url");
+  return `${encoded}.${signature}`;
+}
+function verifyCartSession(token, secret) {
+  const [encoded, signature] = token.split(".");
+  if (!encoded || !signature) {
+    throw new InvalidCartSessionError();
+  }
+  const expected = (0, import_node_crypto.createHmac)("sha256", secret).update(encoded).digest("base64url");
+  const actualBuffer = Buffer.from(signature);
+  const expectedBuffer = Buffer.from(expected);
+  if (actualBuffer.length !== expectedBuffer.length || !(0, import_node_crypto.timingSafeEqual)(actualBuffer, expectedBuffer)) {
+    throw new InvalidCartSessionError();
+  }
+  let payload;
+  try {
+    payload = JSON.parse(Buffer.from(encoded, "base64url").toString("utf8"));
+  } catch {
+    throw new InvalidCartSessionError();
+  }
+  if (typeof payload.customerId !== "string" || !payload.customerId || typeof payload.email !== "string" || typeof payload.exp !== "number") {
+    throw new InvalidCartSessionError();
+  }
+  if (payload.exp < Math.floor(Date.now() / 1e3)) {
+    throw new InvalidCartSessionError("Cart session expired");
+  }
+  return payload;
+}
+
+// src/login-rate-limit.ts
+var LOGIN_RATE_LIMIT_WINDOW_MS = 15 * 60 * 1e3;
+var LOGIN_RATE_LIMIT_MAX_ATTEMPTS = 10;
+var LOGIN_RATE_LIMIT_MESSAGE = "Too many login attempts. Try again later.";
+var ORDER_RATE_LIMIT_WINDOW_MS = 15 * 60 * 1e3;
+var ORDER_RATE_LIMIT_MAX_ATTEMPTS = 20;
+var ORDER_RATE_LIMIT_MESSAGE = "Too many order attempts. Try again later.";
+var PAYMENT_RATE_LIMIT_WINDOW_MS = 15 * 60 * 1e3;
+var PAYMENT_RATE_LIMIT_MAX_ATTEMPTS = 20;
+var PAYMENT_RATE_LIMIT_MESSAGE = "Too many payment attempts. Try again later.";
+var TooManyRequestsError = class extends Error {
+  retryAfterSeconds;
+  constructor(retryAfterSeconds, message = LOGIN_RATE_LIMIT_MESSAGE) {
+    super(message);
+    this.name = "TooManyRequestsError";
+    this.retryAfterSeconds = retryAfterSeconds;
+  }
+};
+function createLoginAttemptLimiter(options = {}) {
+  const windowMs = options.windowMs ?? LOGIN_RATE_LIMIT_WINDOW_MS;
+  const limit = options.limit ?? LOGIN_RATE_LIMIT_MAX_ATTEMPTS;
+  const attempts = /* @__PURE__ */ new Map();
+  return {
+    consume(key) {
+      const now = Date.now();
+      const current = attempts.get(key);
+      if (!current || current.resetAt <= now) {
+        attempts.set(key, { count: 1, resetAt: now + windowMs });
+        return;
+      }
+      if (current.count >= limit) {
+        throw new TooManyRequestsError(Math.max(1, Math.ceil((current.resetAt - now) / 1e3)));
+      }
+      current.count += 1;
+    }
+  };
+}
+function clientKeyFromWebHeaders(headers) {
+  const forwarded = headers.get("x-forwarded-for");
+  if (forwarded) {
+    const first = forwarded.split(",")[0]?.trim();
+    if (first) {
+      return first;
+    }
+  }
+  const realIp = headers.get("x-real-ip")?.trim();
+  return realIp || "local";
+}
+
+// src/route-actions.ts
+var import_core4 = require("@commerce-ai-tool/core");
+
+// src/observability/langfuse.ts
+var import_core2 = require("@commerce-ai-tool/core");
+
+// src/observability/flush.ts
+var FLUSH_GLOBAL_KEY = "__commerceAiToolLangfuseFlush__";
+async function flushLangfuse() {
+  const hasKeys = Boolean(process.env.LANGFUSE_PUBLIC_KEY && process.env.LANGFUSE_SECRET_KEY);
+  const registeredFlush = globalThis[FLUSH_GLOBAL_KEY];
+  if (!hasKeys || !registeredFlush) {
+    return;
+  }
+  await registeredFlush();
+}
+
+// src/observability/langfuse.ts
+async function withRequestSpan(name, attributes, fn) {
+  return (0, import_core2.withPipelineSpan)(name, attributes, async (span) => {
+    try {
+      const result = await fn();
+      span?.update({ output: summarizeResult(result) });
+      return result;
+    } finally {
+      await flushLangfuse();
+    }
+  });
+}
+async function withOptionalRequestSpan(enabled, name, attributes, fn) {
+  if (!enabled) {
+    return fn();
+  }
+  return withRequestSpan(name, attributes, fn);
+}
+function summarizeResult(result) {
+  if (!result || typeof result !== "object") {
+    return void 0;
+  }
+  const record = result;
+  if ("products" in record || "meta" in record) {
+    return {
+      total: record.meta?.total,
+      productCount: Array.isArray(record.products) ? record.products.length : void 0,
+      traceId: record.meta?.traceId,
+      hasTranscript: Boolean(record.transcript),
+      transcript: typeof record.transcript === "string" ? record.transcript : void 0,
+      searchTerms: record.meta?.searchTerms,
+      interpretation: record.meta?.queryInterpretation ?? record.interpretation
+    };
+  }
+  if (Buffer.isBuffer(result)) {
+    return { byteLength: result.byteLength };
+  }
+  return void 0;
+}
+
+// src/utils/log-error.ts
+function isDevLoggingEnabled() {
+  return process.env.NODE_ENV !== "production" || process.env.CAT_DEBUG === "true";
+}
+function formatError(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  if (typeof error === "string") {
+    return error;
+  }
+  try {
+    return JSON.stringify(error);
+  } catch {
+    return String(error);
+  }
+}
+function logServerError(handler, error, context) {
+  if (!isDevLoggingEnabled()) {
+    return;
+  }
+  const prefix = `[commerce-ai-tool/server] ${handler}`;
+  console.error(`${prefix} failed: ${formatError(error)}`);
+  if (context && Object.keys(context).length > 0) {
+    console.error(`${prefix} context:`, context);
+  }
+  if (error instanceof Error && error.stack) {
+    console.error(error.stack);
+  }
+  if (error instanceof Error && error.cause) {
+    console.error(`${prefix} caused by:`, error.cause);
+  }
+}
+function logServerWarning(handler, message, context) {
+  if (!isDevLoggingEnabled()) {
+    return;
+  }
+  const prefix = `[commerce-ai-tool/server] ${handler}`;
+  console.warn(`${prefix}: ${message}`);
+  if (context && Object.keys(context).length > 0) {
+    console.warn(`${prefix} context:`, context);
+  }
+}
+
+// src/utils/locale.ts
+function parseSearchLocaleOptions(fields) {
+  return {
+    queryLocale: fields.queryLocale ?? fields.locale,
+    catalogLocale: fields.catalogLocale,
+    locale: fields.locale
+  };
+}
+
+// src/route-actions.ts
+function parseOptionalBoolean(value) {
+  if (value === "true") {
+    return true;
+  }
+  if (value === "false") {
+    return false;
+  }
+  return void 0;
+}
+var ValidationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ValidationError";
+  }
+};
+function mapRouteError(error, context, fallback, extra) {
+  if (error instanceof import_core3.SearchTimeoutError) {
+    return { message: error.message, status: 504 };
+  }
+  if (error instanceof ValidationError || error instanceof import_core3.CheckoutIncompleteError) {
+    return { message: error.message, status: 400 };
+  }
+  if (error instanceof import_core3.MissingPriceError) {
+    return { message: error.message, status: 400 };
+  }
+  if (error instanceof import_core3.PaymentDeclinedError) {
+    return { message: error.message, status: 402 };
+  }
+  if (error instanceof import_core3.PaymentNotConfiguredError) {
+    return { message: error.message, status: 400 };
+  }
+  if (error instanceof import_core3.CartNotFoundError || error instanceof import_core3.OrderNotFoundError) {
+    return { message: error.message, status: 404 };
+  }
+  if (error instanceof import_core3.CartAccessDeniedError) {
+    return { message: error.message, status: 403 };
+  }
+  if (error instanceof import_core3.InvalidCredentialsError || error instanceof InvalidCartSessionError) {
+    return { message: error.message, status: 401 };
+  }
+  if (error instanceof TooManyRequestsError) {
+    return { message: error.message, status: 429 };
+  }
+  logServerError(context, error, extra);
+  return {
+    message: error instanceof Error ? error.message : fallback,
+    status: 500
+  };
+}
+async function executeSearch(server, body) {
+  if (!body.query?.trim()) {
+    throw new ValidationError("query is required");
+  }
+  if (body.refineQuery && (!body.searchTerms || body.searchTerms.length === 0)) {
+    throw new ValidationError("searchTerms are required for a refinement");
+  }
+  const localeOptions = parseSearchLocaleOptions(body);
+  (0, import_core3.logSearchTrace)("handler", {
+    type: "text",
+    query: body.query,
+    queryLocale: localeOptions.queryLocale,
+    catalogLocale: localeOptions.catalogLocale
+  });
+  return withRequestSpan(
+    "commerce-ai.search",
+    {
+      input: { query: body.query, refineQuery: body.refineQuery },
+      metadata: {
+        searchType: "text",
+        queryLocale: localeOptions.queryLocale ?? "",
+        catalogLocale: localeOptions.catalogLocale ?? ""
+      }
+    },
+    () => server.orchestrator.searchByText({
+      query: body.query,
+      ...localeOptions,
+      limit: body.limit,
+      filters: body.filters,
+      searchTerms: body.searchTerms,
+      sort: body.sort,
+      refineQuery: body.refineQuery,
+      includeFacets: body.includeFacets,
+      suggestedFacets: body.suggestedFacets,
+      enableMissions: body.enableMissions
+    })
+  );
+}
+async function executeFacetSchema(server, options) {
+  if (!server.orchestrator.getFacetSchema) {
+    throw new Error("Facet schema is not available");
+  }
+  return server.orchestrator.getFacetSchema(options);
+}
+async function executeSearchSuggestions(server, body) {
+  const normalizedQuery = (0, import_core4.normalizeSuggestionsPrefix)(body.query ?? "");
+  if (!normalizedQuery) {
+    throw new ValidationError("query must be at least 2 characters");
+  }
+  const localeOptions = parseSearchLocaleOptions(body);
+  (0, import_core3.logSearchTrace)("handler", {
+    type: "suggest",
+    query: normalizedQuery,
+    queryLocale: localeOptions.queryLocale,
+    catalogLocale: localeOptions.catalogLocale
+  });
+  return withOptionalRequestSpan(
+    (0, import_core2.shouldTraceSuggestions)(),
+    "commerce-ai.search.suggestions",
+    {
+      input: { query: normalizedQuery },
+      metadata: {
+        searchType: "suggest",
+        queryLocale: localeOptions.queryLocale ?? "",
+        catalogLocale: localeOptions.catalogLocale ?? ""
+      }
+    },
+    async () => {
+      const result = await server.orchestrator.suggestByText({
+        query: normalizedQuery,
+        ...localeOptions,
+        limit: (0, import_core4.clampSuggestionsLimit)(body.limit)
+      });
+      if (!(0, import_core2.shouldTraceSuggestions)() && result.aiFallbackUsed && (0, import_core2.isLangfuseEnabled)()) {
+        await flushLangfuse();
+      }
+      return result;
+    }
+  );
+}
+async function executeSearchVoice(server, fields, file) {
+  if (!file) {
+    throw new ValidationError("audio file is required");
+  }
+  const localeOptions = parseSearchLocaleOptions(fields);
+  (0, import_core3.logSearchTrace)("handler", {
+    type: "voice",
+    mimeType: file.mimeType,
+    queryLocale: localeOptions.queryLocale,
+    catalogLocale: localeOptions.catalogLocale
+  });
+  return withRequestSpan(
+    "commerce-ai.search.voice",
+    {
+      input: { audio: (0, import_core2.redactBinaryInput)(file.mimeType, file.buffer) },
+      metadata: {
+        searchType: "voice",
+        queryLocale: localeOptions.queryLocale ?? "",
+        catalogLocale: localeOptions.catalogLocale ?? ""
+      }
+    },
+    async () => {
+      const result = await server.orchestrator.searchByVoice(
+        new Uint8Array(file.buffer),
+        file.mimeType,
+        {
+          ...localeOptions,
+          limit: fields.limit ? Number(fields.limit) : void 0,
+          enableTts: fields.enableTts !== "false",
+          enableMissions: parseOptionalBoolean(fields.enableMissions)
+        }
+      );
+      const blockingTts = fields.blockingTts === "true";
+      let audioSummary;
+      if (blockingTts && result.ttsText) {
+        try {
+          const audio = await server.synthesizeSpeech(result.ttsText);
+          audioSummary = audio.toString("base64");
+        } catch (error) {
+          logServerWarning("searchVoice", "TTS summary skipped", {
+            reason: error instanceof Error ? error.message : "unknown"
+          });
+        }
+      }
+      return {
+        transcript: result.transcript,
+        enhancedQuery: result.enhancedQuery,
+        products: result.products,
+        meta: result.meta,
+        mission: result.mission,
+        ttsText: result.ttsText,
+        audioSummary,
+        ttsPending: Boolean(result.ttsText && !audioSummary)
+      };
+    }
+  );
+}
+async function executeSearchImage(server, fields, file) {
+  if (!file) {
+    throw new ValidationError("image file is required");
+  }
+  const localeOptions = parseSearchLocaleOptions(fields);
+  (0, import_core3.logSearchTrace)("handler", {
+    type: "image",
+    mimeType: file.mimeType,
+    queryLocale: localeOptions.queryLocale,
+    catalogLocale: localeOptions.catalogLocale
+  });
+  return withRequestSpan(
+    "commerce-ai.search.image",
+    {
+      input: { image: (0, import_core2.redactBinaryInput)(file.mimeType, file.buffer) },
+      metadata: {
+        searchType: "image",
+        queryLocale: localeOptions.queryLocale ?? "",
+        catalogLocale: localeOptions.catalogLocale ?? ""
+      }
+    },
+    () => server.orchestrator.searchByImage(new Uint8Array(file.buffer), file.mimeType, {
+      ...localeOptions,
+      limit: fields.limit ? Number(fields.limit) : void 0,
+      enableMissions: parseOptionalBoolean(fields.enableMissions)
+    })
+  );
+}
+async function executeTts(server, text) {
+  if (!text.trim()) {
+    throw new ValidationError("text is required");
+  }
+  return withRequestSpan(
+    "commerce-ai.tts",
+    {
+      input: { textLength: text.length },
+      metadata: { searchType: "tts" }
+    },
+    () => server.synthesizeSpeech(text)
+  );
+}
+
+// src/cart-actions.ts
+var import_core5 = require("@commerce-ai-tool/core");
+var ANONYMOUS_ID_MAX_LENGTH = 128;
+function requiredAnonymousId(value) {
+  const anonymousId = requiredString(value, "anonymousId");
+  if (anonymousId.length > ANONYMOUS_ID_MAX_LENGTH) {
+    throw new ValidationError("anonymousId is too long");
+  }
+  return anonymousId;
+}
+function optionalAnonymousId(value) {
+  if (typeof value !== "string" || !value.trim()) {
+    return void 0;
+  }
+  if (value.trim().length > ANONYMOUS_ID_MAX_LENGTH) {
+    throw new ValidationError("anonymousId is too long");
+  }
+  return value.trim();
+}
+function requiredString(value, field) {
+  if (typeof value !== "string" || !value.trim()) {
+    throw new ValidationError(`${field} is required`);
+  }
+  return value.trim();
+}
+function optionalString(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const trimmed = value.trim();
+  return trimmed || void 0;
+}
+function optionalNumber(value) {
+  if (value === void 0 || value === null || value === "") {
+    return void 0;
+  }
+  const parsed = typeof value === "number" ? value : Number(value);
+  if (!Number.isFinite(parsed)) {
+    throw new ValidationError("quantity must be a number");
+  }
+  return parsed;
+}
+function resolveLocale(server, catalogLocale) {
+  return catalogLocale?.trim() || server.cartDefaults.catalogLocale;
+}
+function resolveCartIdentity(server, sessionToken, anonymousId) {
+  const token = optionalString(sessionToken);
+  if (token) {
+    const session = verifyCartSession(token, server.cartSessionSecret);
+    return { customerId: session.customerId };
+  }
+  return { anonymousId: requiredAnonymousId(anonymousId) };
+}
+async function executeGetCart(server, body) {
+  const identity = resolveCartIdentity(server, body.sessionToken, body.anonymousId);
+  const locale = resolveLocale(server, body.catalogLocale);
+  const cart = identity.customerId ? await server.commercetools.getCustomerCart(identity.customerId, locale) : await server.commercetools.getCart(identity.anonymousId ?? "", locale);
+  return { cart };
+}
+async function executeAddToCart(server, body) {
+  const identity = resolveCartIdentity(server, body.sessionToken, body.anonymousId);
+  const sku = optionalString(body.sku);
+  const productId = optionalString(body.productId);
+  if (!sku && !productId) {
+    throw new ValidationError("sku or productId is required");
+  }
+  const quantity = optionalNumber(body.quantity) ?? 1;
+  if (quantity < 1) {
+    throw new ValidationError("quantity must be at least 1");
+  }
+  const cart = await server.commercetools.addToCart({
+    anonymousId: identity.anonymousId,
+    customerId: identity.customerId,
+    sku,
+    productId,
+    variantId: body.variantId,
+    quantity,
+    currency: optionalString(body.currency) ?? server.cartDefaults.currency,
+    country: optionalString(body.country) ?? server.cartDefaults.country,
+    catalogLocale: resolveLocale(server, body.catalogLocale),
+    cartId: optionalString(body.cartId)
+  });
+  return { cart };
+}
+var MAX_ADD_ITEMS = 20;
+async function executeAddItemsToCart(server, body) {
+  const identity = resolveCartIdentity(server, body.sessionToken, body.anonymousId);
+  if (!Array.isArray(body.items) || body.items.length === 0) {
+    throw new ValidationError("items is required");
+  }
+  if (body.items.length > MAX_ADD_ITEMS) {
+    throw new ValidationError(`items must not exceed ${MAX_ADD_ITEMS}`);
+  }
+  const items = body.items.map((item, index) => {
+    const sku = optionalString(item.sku);
+    const productId = optionalString(item.productId);
+    if (!sku && !productId) {
+      throw new ValidationError(`items[${index}]: sku or productId is required`);
+    }
+    const quantity = optionalNumber(item.quantity) ?? 1;
+    if (quantity < 1) {
+      throw new ValidationError(`items[${index}]: quantity must be at least 1`);
+    }
+    if (quantity > import_core5.MAX_LINE_ITEM_QUANTITY) {
+      throw new ValidationError(
+        `items[${index}]: quantity must be at most ${import_core5.MAX_LINE_ITEM_QUANTITY}`
+      );
+    }
+    return {
+      sku,
+      productId,
+      variantId: item.variantId,
+      quantity
+    };
+  });
+  const cart = await server.commercetools.addItemsToCart({
+    anonymousId: identity.anonymousId,
+    customerId: identity.customerId,
+    items,
+    currency: optionalString(body.currency) ?? server.cartDefaults.currency,
+    country: optionalString(body.country) ?? server.cartDefaults.country,
+    catalogLocale: resolveLocale(server, body.catalogLocale),
+    cartId: optionalString(body.cartId)
+  });
+  return { cart };
+}
+async function executeRemoveFromCart(server, body) {
+  const identity = resolveCartIdentity(server, body.sessionToken, body.anonymousId);
+  const lineItemId = requiredString(body.lineItemId, "lineItemId");
+  const cart = await server.commercetools.removeLineItem({
+    anonymousId: identity.anonymousId,
+    customerId: identity.customerId,
+    lineItemId,
+    cartId: optionalString(body.cartId),
+    cartVersion: body.cartVersion,
+    catalogLocale: resolveLocale(server, body.catalogLocale)
+  });
+  return { cart };
+}
+async function executeUpdateCartQuantity(server, body) {
+  const identity = resolveCartIdentity(server, body.sessionToken, body.anonymousId);
+  const lineItemId = requiredString(body.lineItemId, "lineItemId");
+  const quantity = optionalNumber(body.quantity);
+  if (quantity === void 0 || quantity < 0) {
+    throw new ValidationError("quantity must be a non-negative number");
+  }
+  const cart = await server.commercetools.changeLineItemQuantity({
+    anonymousId: identity.anonymousId,
+    customerId: identity.customerId,
+    lineItemId,
+    quantity,
+    cartId: optionalString(body.cartId),
+    cartVersion: body.cartVersion,
+    catalogLocale: resolveLocale(server, body.catalogLocale)
+  });
+  return { cart };
+}
+async function executeLogin(server, body) {
+  const email = requiredString(body.email, "email");
+  const password = requiredString(body.password, "password");
+  const locale = resolveLocale(server, body.catalogLocale);
+  const result = await server.commercetools.loginAndMerge({
+    email,
+    password,
+    anonymousId: optionalAnonymousId(body.anonymousId),
+    cartId: optionalString(body.cartId),
+    catalogLocale: locale
+  });
+  const sessionToken = signCartSession(
+    { customerId: result.customer.id, email: result.customer.email },
+    server.cartSessionSecret
+  );
+  return {
+    cart: result.cart,
+    customer: result.customer,
+    sessionToken
+  };
+}
+async function executeLogout() {
+  return { cart: null, customer: null };
+}
+
+// src/checkout-actions.ts
+function parseAddress(value, field) {
+  if (!value || typeof value !== "object") {
+    throw new ValidationError(`${field} is required`);
+  }
+  const address = value;
+  const country = requiredString(address.country, `${field}.country`).toUpperCase();
+  if (!/^[A-Z]{2}$/.test(country)) {
+    throw new ValidationError(`${field}.country must be an ISO 3166-1 alpha-2 code`);
+  }
+  return {
+    firstName: requiredString(address.firstName, `${field}.firstName`),
+    lastName: requiredString(address.lastName, `${field}.lastName`),
+    streetName: requiredString(address.streetName, `${field}.streetName`),
+    additionalStreetInfo: optionalString(address.additionalStreetInfo),
+    postalCode: requiredString(address.postalCode, `${field}.postalCode`),
+    city: requiredString(address.city, `${field}.city`),
+    region: optionalString(address.region),
+    country,
+    email: optionalString(address.email),
+    phone: optionalString(address.phone)
+  };
+}
+function checkoutIdentity(server, body) {
+  return {
+    ...resolveCartIdentity(server, body.sessionToken, body.anonymousId),
+    cartId: optionalString(body.cartId),
+    catalogLocale: resolveLocale(server, body.catalogLocale)
+  };
+}
+async function executeSetCartAddresses(server, body) {
+  const cart = await server.commercetools.setCartAddresses({
+    ...checkoutIdentity(server, body),
+    shippingAddress: parseAddress(body.shippingAddress, "shippingAddress"),
+    billingAddress: body.billingAddress ? parseAddress(body.billingAddress, "billingAddress") : void 0
+  });
+  return { cart };
+}
+async function executeGetShippingMethods(server, body) {
+  const shippingMethods = await server.commercetools.getShippingMethods(
+    checkoutIdentity(server, body)
+  );
+  return { shippingMethods };
+}
+async function executeSetShippingMethod(server, body) {
+  const cart = await server.commercetools.setShippingMethod({
+    ...checkoutIdentity(server, body),
+    shippingMethodId: requiredString(body.shippingMethodId, "shippingMethodId")
+  });
+  return { cart };
+}
+async function executeCreateOrder(server, body) {
+  const order = await server.commercetools.createOrder({
+    ...checkoutIdentity(server, body),
+    orderNumber: optionalString(body.orderNumber)
+  });
+  return { order };
+}
+
+// src/payment-actions.ts
+function paymentIdentity(server, body) {
+  return {
+    ...resolveCartIdentity(server, body.sessionToken, body.anonymousId),
+    cartId: optionalString(body.cartId),
+    catalogLocale: resolveLocale(server, body.catalogLocale)
+  };
+}
+async function executeGetPaymentMethods(server, body) {
+  const identity = paymentIdentity(server, body);
+  const paymentMethods = await server.commercetools.listPaymentMethods({
+    locale: identity.catalogLocale,
+    country: server.cartDefaults.country
+  });
+  return { paymentMethods };
+}
+async function executeAuthorizePayment(server, body) {
+  return server.commercetools.authorizePayment({
+    ...paymentIdentity(server, body),
+    method: requiredString(body.method, "method"),
+    orderNumber: optionalString(body.orderNumber)
+  });
+}
+
+// src/order-actions.ts
+async function executeGetOrder(server, body) {
+  const identity = resolveCartIdentity(server, body.sessionToken, body.anonymousId);
+  const catalogLocale = resolveLocale(server, optionalString(body.catalogLocale));
+  const anonymousId = identity.anonymousId ?? optionalString(body.anonymousId);
+  const orderNumber = optionalString(body.orderNumber);
+  if (!orderNumber) {
+    const orders = await server.commercetools.listOrders({
+      anonymousId,
+      customerId: identity.customerId,
+      catalogLocale
+    });
+    return { orders };
+  }
+  const order = await server.commercetools.getOrder({
+    orderNumber,
+    anonymousId,
+    customerId: identity.customerId,
+    catalogLocale
+  });
+  return { order };
+}
+
+// src/utils/multipart.ts
+var import_busboy = __toESM(require("busboy"), 1);
+async function parseMultipart(req) {
+  return new Promise((resolve, reject) => {
+    const fields = {};
+    let file;
+    const busboy = (0, import_busboy.default)({ headers: req.headers });
+    const chunks = [];
+    busboy.on("field", (name, value) => {
+      fields[name] = value;
+    });
+    busboy.on("file", (_name, stream, info) => {
+      stream.on("data", (chunk) => chunks.push(chunk));
+      stream.on("end", () => {
+        file = {
+          buffer: Buffer.concat(chunks),
+          mimeType: info.mimeType,
+          filename: info.filename
+        };
+      });
+    });
+    busboy.on("finish", () => resolve({ fields, file }));
+    busboy.on("error", reject);
+    req.pipe(busboy);
+  });
+}
+async function readJsonBody(req) {
+  const chunks = [];
+  for await (const chunk of req) {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+  }
+  const raw = Buffer.concat(chunks).toString("utf8");
+  return JSON.parse(raw);
+}
+async function parseMultipartRequest(req) {
+  const formData = await req.formData();
+  const fields = {};
+  let file;
+  for (const [key, value] of formData.entries()) {
+    if (typeof value === "string") {
+      fields[key] = value;
+      continue;
+    }
+    const buffer = Buffer.from(await value.arrayBuffer());
+    file = {
+      buffer,
+      mimeType: value.type || "application/octet-stream",
+      filename: value.name
+    };
+  }
+  return { fields, file };
+}
+
+// src/handlers.ts
+function createHandlers(server) {
+  return {
+    async health() {
+      return jsonResponse({ status: "ok" });
+    },
+    async search(req) {
+      try {
+        const body = await readJsonBody(req);
+        const result = await executeSearch(server, body);
+        return jsonResponse(result);
+      } catch (error) {
+        const mapped = mapRouteError(error, "search", "Search failed");
+        return errorResponse(mapped.message, mapped.status);
+      }
+    },
+    async facetSchema() {
+      try {
+        return jsonResponse(await executeFacetSchema(server, void 0));
+      } catch (error) {
+        const mapped = mapRouteError(error, "facetSchema", "Facet schema failed");
+        return errorResponse(mapped.message, mapped.status);
+      }
+    },
+    async searchSuggestions(req) {
+      try {
+        const body = await readJsonBody(req);
+        const result = await executeSearchSuggestions(server, body);
+        return jsonResponse(result);
+      } catch (error) {
+        const mapped = mapRouteError(error, "searchSuggestions", "Suggestions failed");
+        return errorResponse(mapped.message, mapped.status);
+      }
+    },
+    async searchVoice(req) {
+      let fields = {};
+      let file;
+      try {
+        const parsed = await parseMultipart(req);
+        fields = parsed.fields;
+        file = parsed.file;
+        const result = await executeSearchVoice(server, fields, file);
+        return jsonResponse(result);
+      } catch (error) {
+        const mapped = mapRouteError(error, "searchVoice", "Voice search failed", {
+          queryLocale: fields.queryLocale ?? fields.locale,
+          catalogLocale: fields.catalogLocale,
+          mimeType: file?.mimeType,
+          size: file?.buffer.length
+        });
+        return errorResponse(mapped.message, mapped.status);
+      }
+    },
+    async searchImage(req) {
+      try {
+        const { fields, file } = await parseMultipart(req);
+        const result = await executeSearchImage(server, fields, file);
+        return jsonResponse(result);
+      } catch (error) {
+        const mapped = mapRouteError(error, "searchImage", "Image search failed");
+        return errorResponse(mapped.message, mapped.status);
+      }
+    },
+    async tts(req) {
+      try {
+        const body = await readJsonBody(req);
+        const audio = await executeTts(server, body.text);
+        return {
+          status: 200,
+          headers: { "Content-Type": "audio/mpeg" },
+          body: audio
+        };
+      } catch (error) {
+        const mapped = mapRouteError(error, "tts", "TTS failed");
+        return errorResponse(mapped.message, mapped.status);
+      }
+    },
+    async getCart(req) {
+      try {
+        const query = parseRequestQuery(req);
+        const result = await executeGetCart(server, {
+          anonymousId: query.anonymousId ?? "",
+          catalogLocale: query.catalogLocale,
+          sessionToken: readCartSessionHeader(req.headers)
+        });
+        return jsonResponse(result);
+      } catch (error) {
+        const mapped = mapRouteError(error, "getCart", "Get cart failed");
+        return errorResponse(mapped.message, mapped.status);
+      }
+    },
+    async addToCart(req) {
+      try {
+        const body = await readJsonBody(req);
+        const result = await executeAddToCart(server, body);
+        return jsonResponse(result);
+      } catch (error) {
+        const mapped = mapRouteError(error, "addToCart", "Add to cart failed");
+        return errorResponse(mapped.message, mapped.status);
+      }
+    },
+    async addItemsToCart(req) {
+      try {
+        const body = await readJsonBody(req);
+        const result = await executeAddItemsToCart(server, body);
+        return jsonResponse(result);
+      } catch (error) {
+        const mapped = mapRouteError(error, "addItemsToCart", "Add items to cart failed");
+        return errorResponse(mapped.message, mapped.status);
+      }
+    },
+    async removeFromCart(req) {
+      try {
+        const body = await readJsonBody(req);
+        const result = await executeRemoveFromCart(server, body);
+        return jsonResponse(result);
+      } catch (error) {
+        const mapped = mapRouteError(error, "removeFromCart", "Remove from cart failed");
+        return errorResponse(mapped.message, mapped.status);
+      }
+    },
+    async updateCartQuantity(req) {
+      try {
+        const body = await readJsonBody(req);
+        const result = await executeUpdateCartQuantity(server, body);
+        return jsonResponse(result);
+      } catch (error) {
+        const mapped = mapRouteError(error, "updateCartQuantity", "Update cart quantity failed");
+        return errorResponse(mapped.message, mapped.status);
+      }
+    },
+    async setCartAddresses(req) {
+      try {
+        const body = await readJsonBody(req);
+        return jsonResponse(await executeSetCartAddresses(server, body));
+      } catch (error) {
+        const mapped = mapRouteError(error, "setCartAddresses", "Set cart addresses failed");
+        return errorResponse(mapped.message, mapped.status);
+      }
+    },
+    async getShippingMethods(req) {
+      try {
+        const query = parseRequestQuery(req);
+        return jsonResponse(
+          await executeGetShippingMethods(server, {
+            anonymousId: query.anonymousId,
+            cartId: query.cartId,
+            catalogLocale: query.catalogLocale,
+            sessionToken: readCartSessionHeader(req.headers)
+          })
+        );
+      } catch (error) {
+        const mapped = mapRouteError(
+          error,
+          "getShippingMethods",
+          "Get shipping methods failed"
+        );
+        return errorResponse(mapped.message, mapped.status);
+      }
+    },
+    async setShippingMethod(req) {
+      try {
+        const body = await readJsonBody(req);
+        return jsonResponse(await executeSetShippingMethod(server, body));
+      } catch (error) {
+        const mapped = mapRouteError(
+          error,
+          "setShippingMethod",
+          "Set shipping method failed"
+        );
+        return errorResponse(mapped.message, mapped.status);
+      }
+    },
+    async createOrder(req) {
+      try {
+        const body = await readJsonBody(req);
+        return jsonResponse(await executeCreateOrder(server, body));
+      } catch (error) {
+        const mapped = mapRouteError(error, "createOrder", "Create order failed");
+        return errorResponse(mapped.message, mapped.status);
+      }
+    },
+    async getPaymentMethods(req) {
+      try {
+        const query = parseRequestQuery(req);
+        return jsonResponse(
+          await executeGetPaymentMethods(server, {
+            anonymousId: query.anonymousId,
+            cartId: query.cartId,
+            catalogLocale: query.catalogLocale,
+            sessionToken: readCartSessionHeader(req.headers)
+          })
+        );
+      } catch (error) {
+        const mapped = mapRouteError(
+          error,
+          "getPaymentMethods",
+          "Get payment methods failed"
+        );
+        return errorResponse(mapped.message, mapped.status);
+      }
+    },
+    async authorizePayment(req) {
+      try {
+        const body = await readJsonBody(req);
+        return jsonResponse(await executeAuthorizePayment(server, body));
+      } catch (error) {
+        const mapped = mapRouteError(error, "authorizePayment", "Payment failed");
+        return errorResponse(mapped.message, mapped.status);
+      }
+    },
+    async getOrder(req) {
+      try {
+        const query = parseRequestQuery(req);
+        return jsonResponse(
+          await executeGetOrder(server, {
+            orderNumber: query.orderNumber ?? "",
+            anonymousId: query.anonymousId,
+            catalogLocale: query.catalogLocale,
+            sessionToken: readCartSessionHeader(req.headers)
+          })
+        );
+      } catch (error) {
+        const mapped = mapRouteError(error, "getOrder", "Get order failed");
+        return errorResponse(mapped.message, mapped.status);
+      }
+    },
+    async login(req) {
+      try {
+        const body = await readJsonBody(req);
+        const result = await executeLogin(server, body);
+        return jsonResponse(result);
+      } catch (error) {
+        const mapped = mapRouteError(error, "login", "Login failed");
+        return errorResponse(mapped.message, mapped.status);
+      }
+    },
+    async logout() {
+      try {
+        const result = await executeLogout();
+        return jsonResponse(result);
+      } catch (error) {
+        const mapped = mapRouteError(error, "logout", "Logout failed");
+        return errorResponse(mapped.message, mapped.status);
+      }
+    }
+  };
+}
+function parseRequestQuery(req) {
+  const query = {};
+  const url = new URL(req.url ?? "", "http://localhost");
+  for (const [key, value] of url.searchParams.entries()) {
+    query[key] = value;
+  }
+  return query;
+}
+
+// src/server.ts
+var import_elevenlabs_js = require("@elevenlabs/elevenlabs-js");
+var import_core6 = require("@commerce-ai-tool/core");
+function createCommerceAIServer(options) {
+  const { config } = options;
+  const voiceMode = resolveVoiceMode(config);
+  const elevenlabs = config.elevenlabs ? createElevenLabsClient(config.elevenlabs) : null;
+  const commercetools = (0, import_core6.createCommercetoolsClient)(config.commercetools, {
+    payments: config.payments
+  });
+  const orchestrator = (0, import_core6.createSearchOrchestrator)({
+    config,
+    commercetoolsClient: commercetools,
+    transcribeAudio: voiceMode === "elevenlabs-stt" && elevenlabs ? async (audio, mimeType) => withElevenLabsSpan(
+      "elevenlabs.stt",
+      { audio: (0, import_core6.redactBinaryInput)(mimeType, audio) },
+      () => transcribeWithElevenLabs(elevenlabs, audio, mimeType, config)
+    ) : void 0
+  });
+  return {
+    orchestrator,
+    commercetools,
+    cartDefaults: {
+      currency: config.defaults?.currency ?? "EUR",
+      country: config.defaults?.country,
+      catalogLocale: config.defaults?.catalogLocale ?? config.defaults?.locale ?? "en"
+    },
+    cartSessionSecret: process.env.CAT_CART_SESSION_SECRET?.trim() || config.commercetools.clientSecret,
+    async transcribeAudio(audio, mimeType) {
+      if (!elevenlabs) {
+        throw new Error("ElevenLabs is not configured");
+      }
+      return withElevenLabsSpan(
+        "elevenlabs.stt",
+        { audio: (0, import_core6.redactBinaryInput)(mimeType, audio) },
+        () => transcribeWithElevenLabs(elevenlabs, audio, mimeType, config)
+      );
+    },
+    async synthesizeSpeech(text) {
+      if (!elevenlabs) {
+        throw new Error("ElevenLabs is not configured");
+      }
+      return withElevenLabsSpan("elevenlabs.tts", { input: { textLength: text.length } }, async () => {
+        const voiceId = config.elevenlabs?.ttsVoiceId ?? "JBFqnCBsd6RMkjVDRZzb";
+        const audio = await elevenlabs.textToSpeech.convert(voiceId, {
+          text,
+          modelId: config.elevenlabs?.ttsModel ?? "eleven_multilingual_v2",
+          outputFormat: "mp3_44100_128"
+        });
+        const chunks = [];
+        for await (const chunk of audio) {
+          chunks.push(chunk);
+        }
+        return Buffer.concat(chunks);
+      });
+    }
+  };
+}
+async function withElevenLabsSpan(name, attributes, fn) {
+  return (0, import_core6.withPipelineSpan)(
+    name,
+    {
+      input: attributes.input ?? attributes.audio,
+      metadata: { vendor: "elevenlabs" }
+    },
+    async (span) => {
+      const result = await fn();
+      if (typeof result === "string") {
+        span?.update({ output: { transcriptLength: result.length } });
+      } else if (Buffer.isBuffer(result)) {
+        span?.update({ output: { byteLength: result.byteLength } });
+      }
+      return result;
+    }
+  );
+}
+function createElevenLabsClient(config) {
+  return new import_elevenlabs_js.ElevenLabsClient({ apiKey: config.apiKey });
+}
+async function transcribeWithElevenLabs(elevenlabs, audio, mimeType, config) {
+  const blob = new Blob([audio], { type: mimeType });
+  const result = await elevenlabs.speechToText.convert({
+    file: blob,
+    modelId: getSttModelId(config.elevenlabs?.sttModel)
+  });
+  if (typeof result === "string") {
+    return result;
+  }
+  if ("text" in result && typeof result.text === "string") {
+    return result.text;
+  }
+  throw new Error("Failed to transcribe audio");
+}
+function resolveVoiceMode(config) {
+  if (config.voiceMode) {
+    return config.voiceMode;
+  }
+  if (config.ai.provider === "openrouter") {
+    return "openrouter-audio";
+  }
+  return "elevenlabs-stt";
+}
+function getSttModelId(model) {
+  return model === "scribe_v2" ? "scribe_v2" : "scribe_v2";
+}
+
+// src/next.ts
+var loginLimiter = createLoginAttemptLimiter();
+var orderLimiter = createLoginAttemptLimiter({
+  windowMs: ORDER_RATE_LIMIT_WINDOW_MS,
+  limit: ORDER_RATE_LIMIT_MAX_ATTEMPTS
+});
+var paymentLimiter = createLoginAttemptLimiter({
+  windowMs: PAYMENT_RATE_LIMIT_WINDOW_MS,
+  limit: PAYMENT_RATE_LIMIT_MAX_ATTEMPTS
+});
+function createNextHandlers(config) {
+  const server = createCommerceAIServer({ config });
+  const handlers = createHandlers(server);
+  return {
+    health: async () => toWebResponse(await handlers.health()),
+    facetSchema: async () => {
+      try {
+        return Response.json(await executeFacetSchema(server, void 0));
+      } catch (error) {
+        const mapped = mapRouteError(error, "facetSchema", "Facet schema failed");
+        return toWebErrorResponse(mapped.message, mapped.status);
+      }
+    },
+    search: async (req) => {
+      try {
+        const body = await req.json();
+        const result = await executeSearch(server, body);
+        return Response.json(result);
+      } catch (error) {
+        const mapped = mapRouteError(error, "search", "Search failed");
+        return toWebErrorResponse(mapped.message, mapped.status);
+      }
+    },
+    searchSuggestions: async (req) => {
+      try {
+        const body = await req.json();
+        const result = await executeSearchSuggestions(server, body);
+        return Response.json(result);
+      } catch (error) {
+        const mapped = mapRouteError(error, "searchSuggestions", "Suggestions failed");
+        return toWebErrorResponse(mapped.message, mapped.status);
+      }
+    },
+    searchVoice: async (req) => {
+      let fields = {};
+      let file;
+      try {
+        const parsed = await parseMultipartRequest(req);
+        fields = parsed.fields;
+        file = parsed.file;
+        const result = await executeSearchVoice(server, fields, file);
+        return Response.json(result);
+      } catch (error) {
+        const mapped = mapRouteError(error, "searchVoice", "Voice search failed", {
+          queryLocale: fields.queryLocale ?? fields.locale,
+          catalogLocale: fields.catalogLocale,
+          mimeType: file?.mimeType,
+          size: file?.buffer.length
+        });
+        return toWebErrorResponse(mapped.message, mapped.status);
+      }
+    },
+    searchImage: async (req) => {
+      try {
+        const { fields, file } = await parseMultipartRequest(req);
+        const result = await executeSearchImage(server, fields, file);
+        return Response.json(result);
+      } catch (error) {
+        const mapped = mapRouteError(error, "searchImage", "Image search failed");
+        return toWebErrorResponse(mapped.message, mapped.status);
+      }
+    },
+    tts: async (req) => {
+      try {
+        const body = await req.json();
+        const audio = await executeTts(server, body.text);
+        return new Response(audio, {
+          headers: { "Content-Type": "audio/mpeg" }
+        });
+      } catch (error) {
+        const mapped = mapRouteError(error, "tts", "TTS failed");
+        return toWebErrorResponse(mapped.message, mapped.status);
+      }
+    },
+    getCart: async (req) => {
+      try {
+        const url = new URL(req.url);
+        const result = await executeGetCart(server, {
+          anonymousId: url.searchParams.get("anonymousId") ?? "",
+          catalogLocale: url.searchParams.get("catalogLocale") ?? void 0,
+          sessionToken: readCartSessionHeader(req.headers)
+        });
+        return Response.json(result);
+      } catch (error) {
+        const mapped = mapRouteError(error, "getCart", "Get cart failed");
+        return toWebErrorResponse(mapped.message, mapped.status);
+      }
+    },
+    addToCart: async (req) => {
+      try {
+        const result = await executeAddToCart(server, await req.json());
+        return Response.json(result);
+      } catch (error) {
+        const mapped = mapRouteError(error, "addToCart", "Add to cart failed");
+        return toWebErrorResponse(mapped.message, mapped.status);
+      }
+    },
+    addItemsToCart: async (req) => {
+      try {
+        const result = await executeAddItemsToCart(
+          server,
+          await req.json()
+        );
+        return Response.json(result);
+      } catch (error) {
+        const mapped = mapRouteError(error, "addItemsToCart", "Add items to cart failed");
+        return toWebErrorResponse(mapped.message, mapped.status);
+      }
+    },
+    removeFromCart: async (req) => {
+      try {
+        const result = await executeRemoveFromCart(server, await req.json());
+        return Response.json(result);
+      } catch (error) {
+        const mapped = mapRouteError(error, "removeFromCart", "Remove from cart failed");
+        return toWebErrorResponse(mapped.message, mapped.status);
+      }
+    },
+    updateCartQuantity: async (req) => {
+      try {
+        const result = await executeUpdateCartQuantity(
+          server,
+          await req.json()
+        );
+        return Response.json(result);
+      } catch (error) {
+        const mapped = mapRouteError(error, "updateCartQuantity", "Update cart quantity failed");
+        return toWebErrorResponse(mapped.message, mapped.status);
+      }
+    },
+    setCartAddresses: async (req) => {
+      try {
+        const result = await executeSetCartAddresses(
+          server,
+          await req.json()
+        );
+        return Response.json(result);
+      } catch (error) {
+        const mapped = mapRouteError(error, "setCartAddresses", "Set cart addresses failed");
+        return toWebErrorResponse(mapped.message, mapped.status);
+      }
+    },
+    getShippingMethods: async (req) => {
+      try {
+        const url = new URL(req.url);
+        const result = await executeGetShippingMethods(server, {
+          anonymousId: url.searchParams.get("anonymousId") ?? void 0,
+          cartId: url.searchParams.get("cartId") ?? void 0,
+          catalogLocale: url.searchParams.get("catalogLocale") ?? void 0,
+          sessionToken: readCartSessionHeader(req.headers)
+        });
+        return Response.json(result);
+      } catch (error) {
+        const mapped = mapRouteError(
+          error,
+          "getShippingMethods",
+          "Get shipping methods failed"
+        );
+        return toWebErrorResponse(mapped.message, mapped.status);
+      }
+    },
+    setShippingMethod: async (req) => {
+      try {
+        const result = await executeSetShippingMethod(
+          server,
+          await req.json()
+        );
+        return Response.json(result);
+      } catch (error) {
+        const mapped = mapRouteError(
+          error,
+          "setShippingMethod",
+          "Set shipping method failed"
+        );
+        return toWebErrorResponse(mapped.message, mapped.status);
+      }
+    },
+    createOrder: async (req) => {
+      try {
+        orderLimiter.consume(clientKeyFromWebHeaders(req.headers));
+        const result = await executeCreateOrder(
+          server,
+          await req.json()
+        );
+        return Response.json(result);
+      } catch (error) {
+        if (error instanceof TooManyRequestsError) {
+          return Response.json(
+            { error: ORDER_RATE_LIMIT_MESSAGE },
+            {
+              status: 429,
+              headers: { "Retry-After": String(error.retryAfterSeconds) }
+            }
+          );
+        }
+        const mapped = mapRouteError(error, "createOrder", "Create order failed");
+        return toWebErrorResponse(mapped.message, mapped.status);
+      }
+    },
+    getPaymentMethods: async (req) => {
+      try {
+        const url = new URL(req.url);
+        const result = await executeGetPaymentMethods(server, {
+          anonymousId: url.searchParams.get("anonymousId") ?? void 0,
+          cartId: url.searchParams.get("cartId") ?? void 0,
+          catalogLocale: url.searchParams.get("catalogLocale") ?? void 0,
+          sessionToken: readCartSessionHeader(req.headers)
+        });
+        return Response.json(result);
+      } catch (error) {
+        const mapped = mapRouteError(
+          error,
+          "getPaymentMethods",
+          "Get payment methods failed"
+        );
+        return toWebErrorResponse(mapped.message, mapped.status);
+      }
+    },
+    authorizePayment: async (req) => {
+      try {
+        paymentLimiter.consume(clientKeyFromWebHeaders(req.headers));
+        const result = await executeAuthorizePayment(
+          server,
+          await req.json()
+        );
+        return Response.json(result);
+      } catch (error) {
+        if (error instanceof TooManyRequestsError) {
+          return Response.json(
+            { error: PAYMENT_RATE_LIMIT_MESSAGE },
+            {
+              status: 429,
+              headers: { "Retry-After": String(error.retryAfterSeconds) }
+            }
+          );
+        }
+        const mapped = mapRouteError(error, "authorizePayment", "Payment failed");
+        return toWebErrorResponse(mapped.message, mapped.status);
+      }
+    },
+    getOrder: async (req) => {
+      try {
+        const url = new URL(req.url);
+        const result = await executeGetOrder(server, {
+          orderNumber: url.searchParams.get("orderNumber") ?? "",
+          anonymousId: url.searchParams.get("anonymousId") ?? void 0,
+          catalogLocale: url.searchParams.get("catalogLocale") ?? void 0,
+          sessionToken: readCartSessionHeader(req.headers)
+        });
+        return Response.json(result);
+      } catch (error) {
+        const mapped = mapRouteError(error, "getOrder", "Get order failed");
+        return toWebErrorResponse(mapped.message, mapped.status);
+      }
+    },
+    login: async (req) => {
+      try {
+        loginLimiter.consume(clientKeyFromWebHeaders(req.headers));
+        const result = await executeLogin(server, await req.json());
+        return Response.json(result);
+      } catch (error) {
+        if (error instanceof TooManyRequestsError) {
+          return Response.json(
+            { error: error.message },
+            {
+              status: 429,
+              headers: { "Retry-After": String(error.retryAfterSeconds) }
+            }
+          );
+        }
+        const mapped = mapRouteError(error, "login", "Login failed");
+        return toWebErrorResponse(mapped.message, mapped.status);
+      }
+    },
+    logout: async () => {
+      try {
+        const result = await executeLogout();
+        return Response.json(result);
+      } catch (error) {
+        const mapped = mapRouteError(error, "logout", "Logout failed");
+        return toWebErrorResponse(mapped.message, mapped.status);
+      }
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createNextHandlers
+});
+//# sourceMappingURL=next.cjs.map