@01.software/sdk 0.44.0 → 0.46.0

package/dist/client.js

@@ -28,10 +28,136 @@ var SDKError = class extends Error {
       details: this.details,
       userMessage: this.userMessage,
       suggestion: this.suggestion,
-      ...this.requestId !== void 0 && { requestId: this.requestId }
+      ...this.requestId !== void 0 && { requestId: this.requestId },
+      ...this.kind !== void 0 && { kind: this.kind },
+      ...this.reason !== void 0 && { reason: this.reason },
+      ...this.rawReason !== void 0 && { rawReason: this.rawReason },
+      ...this.retryable !== void 0 && { retryable: this.retryable },
+      ...this.retryAfter !== void 0 && { retryAfter: this.retryAfter }
     };
   }
 };
+var COMMERCE_ERROR_CODES = [
+  "validation_failed",
+  "unauthorized",
+  "forbidden",
+  "token_expired",
+  "origin_not_allowed",
+  "server_credentials_required",
+  "not_found",
+  "conflict",
+  "cart_revision_conflict",
+  "rate_limit_exceeded",
+  "usage_limit_exceeded",
+  "service_unavailable",
+  "idempotency_conflict",
+  "idempotency_in_progress",
+  "cart_not_active",
+  "cart_locked",
+  "cart_empty",
+  "cart_market_unavailable",
+  "cart_market_mismatch",
+  "checkout_not_open",
+  "payment_slot_held",
+  "reservation_expired",
+  "payment_session_not_cancelable",
+  "provider_identity_mismatch",
+  "provider_unavailable",
+  "lock_timeout",
+  "price_changed",
+  "pricing_fact_in_use",
+  "insufficient_stock",
+  "market_not_found",
+  "market_shipping_currency_unsupported",
+  "missing_market_rate",
+  "missing_shipping_amount",
+  "no_enabled_payment_provider",
+  "product_market_unavailable",
+  "unsupported_currency",
+  "missing_price_row",
+  "payment_provider_currency_unsupported",
+  "discount_code_not_found",
+  "discount_not_started",
+  "discount_expired",
+  "discount_usage_limit",
+  "discount_per_customer_limit",
+  "discount_customer_required",
+  "discount_first_order_only",
+  "discount_customer_not_eligible",
+  "discount_customer_excluded",
+  "discount_items_required",
+  "discount_product_not_eligible",
+  "discount_product_excluded",
+  "discount_min_order_amount",
+  "discount_currency_scope_required",
+  "discount_allocation_method_unsupported",
+  "currency_mismatch"
+];
+var COMMERCE_ERROR_CODE_SET = new Set(
+  COMMERCE_ERROR_CODES
+);
+var COMMERCE_ERROR_ENVELOPE_KEYS = /* @__PURE__ */ new Set([
+  "error",
+  "reason",
+  "requestId",
+  "retryable",
+  "details"
+]);
+function isPlainRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function commerceProtocolError(issue, trustedRequestId) {
+  return createApiError(
+    "Invalid canonical commerce error response.",
+    502,
+    { protocol: "commerce-error-envelope", issue },
+    "The server returned an incompatible commerce error response.",
+    "Verify that the Console commerce contract is deployed before using this SDK version.",
+    trustedRequestId
+  );
+}
+function parseCommerceErrorEnvelope(body, headerRequestId) {
+  if (!isPlainRecord(body)) {
+    throw commerceProtocolError("expected_object", headerRequestId);
+  }
+  if (Object.keys(body).some((key) => !COMMERCE_ERROR_ENVELOPE_KEYS.has(key))) {
+    throw commerceProtocolError("unexpected_field", headerRequestId);
+  }
+  if (typeof body.error !== "string" || body.error.length === 0 || typeof body.reason !== "string" || body.reason.length === 0 || typeof body.requestId !== "string" || body.requestId.length === 0 || body.retryable !== void 0 && typeof body.retryable !== "boolean" || body.details !== void 0 && !isPlainRecord(body.details)) {
+    throw commerceProtocolError("invalid_field", headerRequestId);
+  }
+  if (headerRequestId && headerRequestId !== body.requestId) {
+    throw commerceProtocolError("request_id_mismatch", headerRequestId);
+  }
+  return {
+    error: body.error,
+    reason: body.reason,
+    requestId: body.requestId,
+    retryable: body.retryable === true,
+    ...body.details === void 0 ? {} : { details: body.details }
+  };
+}
+function enhanceCommerceError(error, body, headerRequestId) {
+  const envelope = parseCommerceErrorEnvelope(body, headerRequestId);
+  const known = COMMERCE_ERROR_CODE_SET.has(envelope.reason);
+  Object.assign(error, {
+    code: envelope.reason,
+    kind: "commerce",
+    reason: known ? envelope.reason : "unknown_commerce_error",
+    ...known ? {} : { rawReason: envelope.reason },
+    requestId: envelope.requestId,
+    retryable: envelope.retryable,
+    details: envelope.details
+  });
+  return error;
+}
+function isCommerceSDKError(error) {
+  if (!(error instanceof SDKError) || error.kind !== "commerce") return false;
+  if (typeof error.requestId !== "string" || typeof error.retryable !== "boolean" || error.retryAfter !== void 0 && (!Number.isSafeInteger(error.retryAfter) || error.retryAfter < 0) || typeof error.reason !== "string") {
+    return false;
+  }
+  return error.reason === "unknown_commerce_error" ? typeof error.rawReason === "string" : COMMERCE_ERROR_CODE_SET.has(error.reason) && error.rawReason === void 0;
+}
 var NetworkError = class extends SDKError {
   constructor(message, status, details, userMessage, suggestion) {
     super("NETWORK_ERROR", message, status, details, userMessage, suggestion);
@@ -225,6 +351,7 @@ var NON_RETRYABLE_STATUSES = [400, 401, 403, 404, 409, 422];
 var SAFE_METHODS = ["GET", "HEAD", "OPTIONS"];
 var DEFAULT_MAX_RETRIES = 3;
 var STOREFRONT_BROWSER_MAX_RETRIES = 1;
+var MAX_AUTOMATIC_RETRY_AFTER_SECONDS = 5 * 60;
 function debugLog(debug, type, message, data) {
   if (!debug) return;
   const shouldLog = debug === true || type === "request" && debug.logRequests || type === "response" && debug.logResponses || type === "error" && debug.logErrors;
@@ -248,6 +375,11 @@ function redactSensitiveHeaders(headers) {
       redacted["x-preview-token"]
     );
   }
+  if (redacted["x-custom-payment-signature"]) {
+    redacted["x-custom-payment-signature"] = redactSensitiveHeader(
+      redacted["x-custom-payment-signature"]
+    );
+  }
   return redacted;
 }
 function getErrorSuggestion(status) {
@@ -339,116 +471,129 @@ function attachRequestId(err, id) {
 }
 function parseRetryAfter(response) {
   const raw = response.headers.get("Retry-After");
-  if (!raw) return void 0;
-  return parseInt(raw, 10) || void 0;
+  if (!raw) return { permitsAutomaticRetry: true };
+  const trimmed = raw.trim();
+  let seconds;
+  if (/^\d+$/.test(trimmed)) {
+    seconds = Number(trimmed);
+    if (!Number.isSafeInteger(seconds)) {
+      return { permitsAutomaticRetry: false };
+    }
+  } else {
+    const retryAt = Date.parse(trimmed);
+    if (!Number.isFinite(retryAt)) return { permitsAutomaticRetry: true };
+    seconds = Math.max(0, Math.ceil((retryAt - Date.now()) / 1e3));
+  }
+  return {
+    seconds,
+    permitsAutomaticRetry: seconds <= MAX_AUTOMATIC_RETRY_AFTER_SECONDS
+  };
 }
-function mapResponseToError(status, parsed, details, requestId, retryAfter) {
+function mapResponseToError(status, parsed, details, requestId, retryAfter, errorFamily) {
   const errorDetails = {
     ...details,
     ...parsed.errors && { errors: parsed.errors },
-    ...parsed.body && { body: parsed.body }
+    ...errorFamily !== "commerce" && parsed.body && { body: parsed.body }
   };
   const suggestion = getParsedErrorSuggestion(status, parsed);
+  const finalize = (error) => {
+    const withRequestId = attachRequestId(error, requestId);
+    if (retryAfter !== void 0) {
+      Object.assign(withRequestId, { retryAfter });
+    }
+    return errorFamily === "commerce" ? enhanceCommerceError(withRequestId, parsed.body, requestId) : withRequestId;
+  };
   if (status === 400 || status === 422) {
-    return attachRequestId(
+    return finalize(
       createValidationError(
         parsed.errorMessage,
         errorDetails,
         parsed.userMessage,
         suggestion,
         status
-      ),
-      requestId
+      )
     );
   }
   if (status === 401) {
-    return attachRequestId(
+    return finalize(
       createAuthError(
         parsed.errorMessage,
         errorDetails,
         parsed.userMessage,
         suggestion
-      ),
-      requestId
+      )
     );
   }
   if (status === 403) {
-    return attachRequestId(
+    return finalize(
       createPermissionError(
         parsed.errorMessage,
         errorDetails,
         parsed.userMessage,
         suggestion
-      ),
-      requestId
+      )
     );
   }
   if (status === 404) {
-    return attachRequestId(
+    return finalize(
       createNotFoundError(
         parsed.errorMessage,
         errorDetails,
         parsed.userMessage,
         suggestion
-      ),
-      requestId
+      )
     );
   }
   if (status === 409) {
-    return attachRequestId(
+    return finalize(
       createConflictError(
         parsed.errorMessage,
         errorDetails,
         parsed.userMessage,
         suggestion
-      ),
-      requestId
+      )
     );
   }
   if (status === 410) {
-    return attachRequestId(
+    return finalize(
       createGoneError(
         parsed.errorMessage,
         errorDetails,
         parsed.userMessage,
         suggestion
-      ),
-      requestId
+      )
     );
   }
   if (status === 429) {
-    return attachRequestId(
+    return finalize(
       createRateLimitError(
         parsed.errorMessage,
         retryAfter,
         errorDetails,
         parsed.userMessage,
         suggestion
-      ),
-      requestId
+      )
     );
   }
   if (status === 503) {
-    return attachRequestId(
+    return finalize(
       createServiceUnavailableError(
         parsed.errorMessage,
         retryAfter,
         errorDetails,
         parsed.userMessage,
         suggestion
-      ),
-      requestId
+      )
     );
   }
-  return attachRequestId(
+  return finalize(
     createNetworkError(
       parsed.errorMessage,
       status,
       errorDetails,
       parsed.userMessage,
       suggestion
-    ),
-    requestId
+    )
   );
 }
 async function httpFetch(url, options) {
@@ -461,6 +606,7 @@ async function httpFetch(url, options) {
     debug,
     retry,
     onUnauthorized,
+    errorFamily,
     ...requestInit
   } = options || {};
   const baseUrl = resolveApiUrl(apiUrl);
@@ -513,6 +659,8 @@ async function httpFetch(url, options) {
         headers: redactSensitiveHeaders(response.headers)
       });
       if (!response.ok) {
+        const parsed = await parseErrorBody(response);
+        const commerceEnvelope = errorFamily === "commerce" ? parseCommerceErrorEnvelope(parsed.body, requestId) : void 0;
         if (isUsageLimitExceededResponse(response)) {
           const limit = parseInt(
             response.headers.get("X-Usage-Limit") || "0",
@@ -526,7 +674,7 @@ async function httpFetch(url, options) {
             response.headers.get("X-Usage-Remaining") || "0",
             10
           );
-          throw attachRequestId(
+          const usageError = attachRequestId(
             createUsageLimitError(
               `Monthly API usage limit exceeded (${current.toLocaleString()}/${limit.toLocaleString()})`,
               { limit, current, remaining },
@@ -540,9 +688,9 @@ async function httpFetch(url, options) {
             ),
             requestId
           );
+          throw errorFamily === "commerce" ? enhanceCommerceError(usageError, parsed.body, requestId) : usageError;
         }
-        const parsed = await parseErrorBody(response);
-        if (response.status === 401 && onUnauthorized && customerToken && !hasRetried401 && parsed.reason === "token_expired") {
+        if (response.status === 401 && onUnauthorized && customerToken && !hasRetried401 && (commerceEnvelope?.reason ?? parsed.reason) === "token_expired") {
           hasRetried401 = true;
           try {
             const newToken = await onUnauthorized();
@@ -564,13 +712,18 @@ async function httpFetch(url, options) {
           parsed,
           details,
           requestId,
-          retryAfter
+          retryAfter.seconds,
+          errorFamily
         );
         const method2 = (requestInit.method || "GET").toUpperCase();
         const isTerminal = error instanceof RateLimitError || error instanceof UsageLimitError;
-        if (attempt < retryConfig.maxRetries && SAFE_METHODS.includes(method2) && !isTerminal && !NON_RETRYABLE_STATUSES.includes(response.status) && retryConfig.retryableStatuses.includes(response.status)) {
+        const responseAllowsRetry = isCommerceSDKError(error) ? error.retryable : true;
+        if (attempt < retryConfig.maxRetries && SAFE_METHODS.includes(method2) && !isTerminal && responseAllowsRetry && retryAfter.permitsAutomaticRetry && !NON_RETRYABLE_STATUSES.includes(response.status) && retryConfig.retryableStatuses.includes(response.status)) {
           lastError = error;
-          const retryDelay = retryConfig.retryDelay(attempt);
+          const retryDelay = Math.max(
+            retryConfig.retryDelay(attempt),
+            (retryAfter.seconds ?? 0) * 1e3
+          );
           debugLog(debug, "error", `Retrying in ${retryDelay}ms...`, error);
           await delay(retryDelay);
           continue;
@@ -640,87 +793,45 @@ async function httpFetch(url, options) {
   throw lastError ?? new NetworkError("Request failed after retries");
 }
 
-// src/core/api/endpoints.ts
-var COMMERCE_ENDPOINTS = {
-  orders: {
-    create: "/api/orders/create",
-    update: "/api/orders/update",
-    confirmPayment: "/api/orders/confirm-payment",
-    byPayment: "/api/orders/by-payment",
-    cancel: "/api/orders/cancel",
-    resolveCancelRefund: "/api/orders/resolve-cancel-refund",
-    checkout: "/api/orders/checkout",
-    createFulfillment: "/api/orders/create-fulfillment",
-    updateFulfillment: "/api/orders/update-fulfillment"
-  },
-  transactions: {
-    update: "/api/transactions/update"
-  },
-  returns: {
-    create: "/api/returns/create",
-    update: "/api/returns/update",
-    returnRefund: "/api/returns/return-refund"
-  },
-  fulfillmentOrders: {
-    prepare: "/api/fulfillment-orders/prepare-fulfillment-order"
-  },
-  fulfillments: {
-    bulkImport: "/api/fulfillments/bulk-import"
-  },
-  carts: {
-    mine: "/api/carts/mine",
-    merge: "/api/carts/merge",
-    addItem: "/api/carts/add-item",
-    updateItem: "/api/carts/update-item",
-    removeItem: "/api/carts/remove-item",
-    applyDiscount: "/api/carts/apply-discount",
-    removeDiscount: "/api/carts/remove-discount",
-    clear: "/api/carts/clear"
-  },
-  products: {
-    stockCheck: "/api/products/stock-check",
-    stockSnapshot: "/api/products/stock",
-    listingGroups: "/api/products/listing-groups",
-    listingGroupsCatalog: "/api/products/listing-groups/catalog",
-    listingGroupsQuery: "/api/products/listing-groups/query",
-    listingGroupsQueryCatalog: "/api/products/listing-groups/query/catalog",
-    detail: "/api/products/detail",
-    detailCatalog: "/api/products/detail/catalog",
-    upsert: "/api/products/upsert"
-  }
-};
-var COMMERCE_ENDPOINT_PATHS = Object.values(
-  COMMERCE_ENDPOINTS
-).flatMap((group) => Object.values(group));
-var MEMBERSHIP_ENDPOINTS = {
-  subscribe: "/api/memberships/subscribe",
-  cancel: (id) => `/api/memberships/${id}/cancel`,
-  me: "/api/memberships/me"
-};
-
 // src/core/internal/utils/query-string.ts
-function productDetailQuery(params) {
-  const search = new URLSearchParams();
-  if ("slug" in params) {
-    search.set("slug", params.slug);
-  } else {
-    search.set("id", params.id);
+function normalizedMarket(value) {
+  const market = value?.trim();
+  return market || void 0;
+}
+function appendProductLocaleSearchParams(search, options) {
+  if (options?.locale) search.set("locale", options.locale);
+  if (options?.fallbackLocale !== void 0) {
+    search.set(
+      "fallbackLocale",
+      options.fallbackLocale === false ? "none" : options.fallbackLocale
+    );
   }
-  return `${COMMERCE_ENDPOINTS.products.detail}?${search}`;
 }
-function productDetailCatalogQuery(params) {
+function productDetailSearchParams(params) {
   const search = new URLSearchParams();
   if ("slug" in params) {
     search.set("slug", params.slug);
   } else {
     search.set("id", params.id);
   }
-  return `${COMMERCE_ENDPOINTS.products.detailCatalog}?${search}`;
+  const market = normalizedMarket(params.market);
+  if (market) search.set("market", market);
+  appendProductLocaleSearchParams(search, params);
+  return search.toString();
 }
-function listingGroupsCatalogQuery(params) {
-  return `${COMMERCE_ENDPOINTS.products.listingGroupsCatalog}?ids=${params.productIds.map(encodeURIComponent).join(",")}`;
+function listingGroupsSearchParams(params) {
+  const ids = params.productIds.map(encodeURIComponent).join(",");
+  const search = new URLSearchParams();
+  const market = normalizedMarket(params.market);
+  if (market) search.set("market", market);
+  appendProductLocaleSearchParams(search, params);
+  const query = search.toString();
+  return `ids=${ids}${query ? `&${query}` : ""}`;
 }
 function appendListingGroupsQuerySearchParams(search, options) {
+  const market = normalizedMarket(options?.market);
+  if (market) search.set("market", market);
+  appendProductLocaleSearchParams(search, options);
   if (options?.page != null) search.set("page", String(options.page));
   if (options?.limit != null) search.set("limit", String(options.limit));
   if (options?.sort != null) {
@@ -731,20 +842,13 @@ function appendListingGroupsQuerySearchParams(search, options) {
     search.set("whereJson", JSON.stringify(options.where));
   }
 }
-function listingGroupsQueryUrl(options) {
+function listingPageSearchParams(options) {
   const search = new URLSearchParams();
   appendListingGroupsQuerySearchParams(search, options);
-  const query = search.toString();
-  return `${COMMERCE_ENDPOINTS.products.listingGroupsQuery}${query ? `?${query}` : ""}`;
-}
-function listingGroupsQueryCatalogUrl(options) {
-  const search = new URLSearchParams();
-  appendListingGroupsQuerySearchParams(search, options);
-  const query = search.toString();
-  return `${COMMERCE_ENDPOINTS.products.listingGroupsQueryCatalog}${query ? `?${query}` : ""}`;
+  return search.toString();
 }
-function stockSnapshotQuery(params) {
-  return `${COMMERCE_ENDPOINTS.products.stockSnapshot}?variantIds=${params.variantIds.map(encodeURIComponent).join(",")}`;
+function stockSnapshotSearchParams(params) {
+  return `variantIds=${params.variantIds.map(encodeURIComponent).join(",")}`;
 }
 
 // src/core/collection/http-client.ts
@@ -787,10 +891,15 @@ var HttpClient = class {
       throw err;
     }
   }
-  buildUrl(endpoint, options) {
-    if (!options) return endpoint;
-    const queryString = stringify(options, { addQueryPrefix: true });
-    return queryString ? `${endpoint}${queryString}` : endpoint;
+  buildUrl(endpoint2, options) {
+    if (!options) return endpoint2;
+    const { fallbackLocale, ...rest } = options;
+    const queryOptions = fallbackLocale === void 0 ? rest : {
+      ...rest,
+      "fallback-locale": fallbackLocale === false ? "none" : fallbackLocale
+    };
+    const queryString = stringify(queryOptions, { addQueryPrefix: true });
+    return queryString ? `${endpoint2}${queryString}` : endpoint2;
   }
   assertJsonResponse(response) {
     const contentType = response.headers.get("content-type");
@@ -932,39 +1041,39 @@ var ReadOnlyCollectionClient = class extends HttpClient {
   from(collection) {
     return new ReadOnlyCollectionQueryBuilder(this, collection);
   }
-  async requestFind(endpoint, options) {
-    const url = this.buildUrl(endpoint, options);
+  async requestFind(endpoint2, options) {
+    const url = this.buildUrl(endpoint2, options);
     const response = await this.fetchWithTracking(url, {
       ...this.defaultOptions,
       method: "GET"
     });
     return this.parseFindResponse(response);
   }
-  async requestFindEndpoint(endpoint, data) {
-    const response = await this.fetchWithTracking(endpoint, {
+  async requestFindEndpoint(endpoint2, data) {
+    const response = await this.fetchWithTracking(endpoint2, {
       ...this.defaultOptions,
       method: "POST",
       body: data ? JSON.stringify(data) : void 0
     });
     return this.parseFindResponse(response);
   }
-  async requestFindEndpointGet(endpoint) {
-    const response = await this.fetchWithTracking(endpoint, {
+  async requestFindEndpointGet(endpoint2) {
+    const response = await this.fetchWithTracking(endpoint2, {
       ...this.defaultOptions,
       method: "GET"
     });
     return this.parseFindResponse(response);
   }
-  async requestFindById(endpoint, options) {
-    const url = this.buildUrl(endpoint, options);
+  async requestFindById(endpoint2, options) {
+    const url = this.buildUrl(endpoint2, options);
     const response = await this.fetchWithTracking(url, {
       ...this.defaultOptions,
       method: "GET"
     });
     return this.parseDocumentResponse(response);
   }
-  async requestCount(endpoint, options) {
-    const url = this.buildUrl(endpoint, options);
+  async requestCount(endpoint2, options) {
+    const url = this.buildUrl(endpoint2, options);
     const response = await this.fetchWithTracking(url, {
       ...this.defaultOptions,
       method: "GET"
@@ -974,53 +1083,347 @@ var ReadOnlyCollectionClient = class extends HttpClient {
 };
 
 // src/core/api/parse-response.ts
-async function parseApiResponse(response, endpoint) {
-  let data;
+async function parseApiResponse(response, endpoint2, options = {}) {
+  if (response.status === 204 || response.headers.get("content-length") === "0") {
+    return void 0;
+  }
+  let parsed;
   try {
-    data = await response.json();
+    parsed = await response.json();
   } catch {
     throw createApiError(
-      `Invalid JSON response from ${endpoint}`,
+      `Invalid JSON response from ${endpoint2}`,
       response.status,
       void 0,
       "Server returned an invalid response.",
       "Check if the API endpoint is available."
     );
   }
+  if (parsed === null || typeof parsed !== "object") {
+    return parsed;
+  }
+  const data = parsed;
   if (data.error) {
     const errorMessage = typeof data.error === "string" ? data.error : "Unknown API error";
     const reason = typeof data.reason === "string" ? data.reason : void 0;
     const requestId = response.headers.get("x-request-id") ?? void 0;
-    const retryAfterRaw = response.headers.get("Retry-After");
-    const retryAfter = retryAfterRaw ? parseInt(retryAfterRaw, 10) || void 0 : void 0;
+    const retryAfter = parseRetryAfter(response).seconds;
+    let error;
     if (reason === "validation_failed") {
-      throw attachRequestId(createValidationError(errorMessage, data, errorMessage), requestId);
-    }
-    if (reason === "token_expired" || reason === "token_invalid" || reason === "preview_token_invalid" || reason === "preview_token_required" || reason === "key_invalid" || reason === "key_revoked") {
-      throw attachRequestId(createAuthError(errorMessage, data, errorMessage), requestId);
+      error = createValidationError(errorMessage, data, errorMessage);
+    } else if (reason === "token_expired" || reason === "token_invalid" || reason === "preview_token_invalid" || reason === "preview_token_required" || reason === "key_invalid" || reason === "key_revoked") {
+      error = createAuthError(errorMessage, data, errorMessage);
+    } else if (reason === "forbidden") {
+      error = createPermissionError(errorMessage, data, errorMessage);
+    } else if (reason === "rate_limit_exceeded") {
+      error = createRateLimitError(errorMessage, retryAfter, data, errorMessage);
+    } else if (reason === "not_found") {
+      error = createNotFoundError(errorMessage, data, errorMessage);
+    } else if (reason === "conflict") {
+      error = createConflictError(errorMessage, data, errorMessage);
+    } else {
+      error = createApiError(
+        errorMessage,
+        response.status,
+        data,
+        errorMessage,
+        "An error occurred while processing the request."
+      );
     }
-    if (reason === "forbidden") {
-      throw attachRequestId(createPermissionError(errorMessage, data, errorMessage), requestId);
+    const withRequestId = attachRequestId(error, requestId);
+    if (retryAfter !== void 0) Object.assign(withRequestId, { retryAfter });
+    throw options.errorFamily === "commerce" ? enhanceCommerceError(withRequestId, data, requestId) : withRequestId;
+  }
+  return data;
+}
+
+// ../../internal/http-contracts/src/index.ts
+var operationBrand = /* @__PURE__ */ Symbol("sdk-http-operation");
+var operation = (collection, method, path) => Object.freeze({
+  [operationBrand]: true,
+  collection,
+  method,
+  path
+});
+var COMMERCE_ENDPOINT_OPERATIONS = {
+  products: {
+    detail: operation("products", "get", "/detail"),
+    detailCatalog: operation("products", "get", "/detail/catalog"),
+    listingGroups: operation("products", "get", "/listing-groups"),
+    listingGroupsCatalog: operation(
+      "products",
+      "get",
+      "/listing-groups/catalog"
+    ),
+    listingGroupsQuery: operation("products", "post", "/listing-groups/query"),
+    listingGroupsQueryGet: operation(
+      "products",
+      "get",
+      "/listing-groups/query"
+    ),
+    listingGroupsQueryCatalog: operation(
+      "products",
+      "get",
+      "/listing-groups/query/catalog"
+    ),
+    stockCheck: operation("products", "post", "/stock-check"),
+    stockSnapshot: operation("products", "get", "/stock"),
+    upsert: operation("products", "post", "/upsert")
+  },
+  orders: {
+    create: operation("orders", "post", "/create"),
+    update: operation("orders", "post", "/update"),
+    confirmPayment: operation("orders", "post", "/confirm-payment"),
+    byPayment: operation("orders", "get", "/by-payment"),
+    cancel: operation("orders", "post", "/cancel"),
+    resolveCancelRefund: operation("orders", "post", "/resolve-cancel-refund"),
+    checkout: operation("orders", "post", "/checkout"),
+    createFulfillment: operation("orders", "post", "/create-fulfillment"),
+    updateFulfillment: operation("orders", "post", "/update-fulfillment")
+  },
+  checkouts: {
+    detail: operation("checkouts", "post", "/detail"),
+    query: operation("checkouts", "post", "/query")
+  },
+  transactions: {
+    update: operation("transactions", "post", "/update")
+  },
+  returns: {
+    create: operation("returns", "post", "/create"),
+    update: operation("returns", "post", "/update"),
+    returnRefund: operation("returns", "post", "/return-refund")
+  },
+  fulfillmentOrders: {
+    prepare: operation(
+      "fulfillment-orders",
+      "post",
+      "/prepare-fulfillment-order"
+    )
+  },
+  fulfillments: {
+    bulkImport: operation("fulfillments", "post", "/bulk-import")
+  },
+  carts: {
+    create: operation("carts", "post", "/create"),
+    retrieve: operation("carts", "post", "/retrieve"),
+    mine: operation("carts", "post", "/mine"),
+    merge: operation("carts", "post", "/merge"),
+    addItem: operation("carts", "post", "/add-item"),
+    updateItem: operation("carts", "post", "/update-item"),
+    removeItem: operation("carts", "post", "/remove-item"),
+    updateDiscountCodes: operation("carts", "post", "/update-discount-codes"),
+    updateAttributes: operation("carts", "post", "/update-attributes"),
+    clear: operation("carts", "post", "/clear")
+  },
+  paymentSessions: {
+    create: operation("payment-sessions", "post", "/create"),
+    retrieve: operation("payment-sessions", "post", "/retrieve"),
+    cancel: operation("payment-sessions", "post", "/cancel"),
+    server: {
+      create: operation("payment-sessions", "post", "/server/create"),
+      retrieve: operation("payment-sessions", "post", "/server/retrieve"),
+      cancel: operation("payment-sessions", "post", "/server/cancel"),
+      confirm: operation("payment-sessions", "post", "/server/confirm")
+    },
+    custom: {
+      create: operation("orders", "post", "/custom-payment-sessions"),
+      confirm: operation("orders", "post", "/custom-payment-sessions/confirm")
     }
-    if (reason === "rate_limit_exceeded") {
-      throw attachRequestId(createRateLimitError(errorMessage, retryAfter, data, errorMessage), requestId);
+  },
+  shippingPolicies: {
+    calculate: operation("shipping-policies", "post", "/calculate")
+  },
+  discounts: {
+    validate: operation("discounts", "post", "/validate")
+  }
+};
+var MEMBERSHIP_ENDPOINT_OPERATIONS = {
+  subscribe: operation(null, "post", "/memberships/subscribe"),
+  cancel: operation(null, "post", "/memberships/:id/cancel"),
+  me: operation(null, "get", "/memberships/me")
+};
+var EVENTS_ENDPOINT_OPERATIONS = {
+  occurrences: {
+    range: operation("event-occurrences", "get", "/range"),
+    admissionAvailability: operation(
+      "event-occurrences",
+      "get",
+      "/admission-availability"
+    )
+  }
+};
+function resolveOperationTemplate(descriptor) {
+  return descriptor.collection ? `/api/${descriptor.collection}${descriptor.path}` : `/api${descriptor.path}`;
+}
+function resolveOperationPath(descriptor, options) {
+  const path = resolveOperationTemplate(descriptor).replace(
+    /:([A-Za-z][A-Za-z0-9_]*)/g,
+    (_, key) => {
+      const value = options?.pathParams?.[key];
+      if (value === void 0) {
+        throw new TypeError(`Missing path parameter: ${key}`);
+      }
+      return encodeURIComponent(value);
     }
-    if (reason === "not_found") {
-      throw attachRequestId(createNotFoundError(errorMessage, data, errorMessage), requestId);
+  );
+  const unresolved = path.match(/:([A-Za-z][A-Za-z0-9_]*)/);
+  if (unresolved) {
+    throw new TypeError(`Missing path parameter: ${unresolved[1]}`);
+  }
+  const query = options?.query?.toString().replace(/^\?/, "");
+  return query ? `${path}?${query}` : path;
+}
+function resolveOperationMethod(descriptor) {
+  return descriptor.method.toUpperCase();
+}
+
+// src/core/api/endpoints.ts
+var endpoint = (method, path) => ({ method, path });
+var sharedEndpoint = (descriptor) => descriptor;
+function resolveOperationMethod2(descriptor) {
+  return "collection" in descriptor ? resolveOperationMethod(descriptor) : descriptor.method;
+}
+function resolveOperationPath2(descriptor, options) {
+  if ("collection" in descriptor) {
+    return resolveOperationPath(descriptor, options);
+  }
+  const query = options?.query?.toString().replace(/^\?/, "");
+  return query ? `${descriptor.path}?${query}` : descriptor.path;
+}
+var COMMERCE_ENDPOINTS = {
+  products: {
+    detail: endpoint("GET", "/api/products/detail"),
+    detailCatalog: endpoint("GET", "/api/products/detail/catalog"),
+    listingGroups: endpoint("GET", "/api/products/listing-groups"),
+    listingGroupsCatalog: endpoint(
+      "GET",
+      "/api/products/listing-groups/catalog"
+    ),
+    listingGroupsQuery: endpoint("GET", "/api/products/listing-groups/query"),
+    listingGroupsQueryCatalog: endpoint(
+      "GET",
+      "/api/products/listing-groups/query/catalog"
+    ),
+    stockCheck: endpoint("POST", "/api/products/stock-check"),
+    stockSnapshot: endpoint("GET", "/api/products/stock"),
+    upsert: endpoint("POST", "/api/products/upsert")
+  },
+  orders: {
+    update: endpoint("POST", "/api/orders/update"),
+    byPayment: endpoint("GET", "/api/orders/by-payment"),
+    cancel: endpoint("POST", "/api/orders/cancel"),
+    resolveCancelRefund: endpoint("POST", "/api/orders/resolve-cancel-refund"),
+    createFulfillment: endpoint("POST", "/api/orders/create-fulfillment"),
+    updateFulfillment: endpoint("POST", "/api/orders/update-fulfillment")
+  },
+  checkouts: {
+    create: endpoint("POST", "/api/orders/checkout"),
+    retrieve: endpoint("POST", "/api/checkouts/detail"),
+    server: {
+      create: endpoint("POST", "/api/orders/checkout"),
+      retrieve: endpoint("POST", "/api/checkouts/detail"),
+      query: endpoint("POST", "/api/checkouts/query")
     }
-    if (reason === "conflict") {
-      throw attachRequestId(createConflictError(errorMessage, data, errorMessage), requestId);
+  },
+  returns: {
+    create: endpoint("POST", "/api/returns/create"),
+    update: endpoint("POST", "/api/returns/update"),
+    returnRefund: endpoint("POST", "/api/returns/return-refund")
+  },
+  fulfillmentOrders: {
+    prepare: endpoint(
+      "POST",
+      "/api/fulfillment-orders/prepare-fulfillment-order"
+    )
+  },
+  fulfillments: {
+    bulkImport: endpoint("POST", "/api/fulfillments/bulk-import")
+  },
+  carts: {
+    create: endpoint("POST", "/api/carts/create"),
+    retrieve: sharedEndpoint(COMMERCE_ENDPOINT_OPERATIONS.carts.retrieve),
+    mine: endpoint("POST", "/api/carts/mine"),
+    merge: endpoint("POST", "/api/carts/merge"),
+    server: {
+      // Server credentials are an authorization lane, not a second Cart
+      // transport. These must stay bound to the registered shared operations.
+      create: sharedEndpoint(COMMERCE_ENDPOINT_OPERATIONS.carts.create),
+      retrieve: sharedEndpoint(COMMERCE_ENDPOINT_OPERATIONS.carts.retrieve),
+      mine: sharedEndpoint(COMMERCE_ENDPOINT_OPERATIONS.carts.mine),
+      merge: sharedEndpoint(COMMERCE_ENDPOINT_OPERATIONS.carts.merge),
+      addItem: sharedEndpoint(COMMERCE_ENDPOINT_OPERATIONS.carts.addItem),
+      updateItem: sharedEndpoint(COMMERCE_ENDPOINT_OPERATIONS.carts.updateItem),
+      removeItem: sharedEndpoint(COMMERCE_ENDPOINT_OPERATIONS.carts.removeItem),
+      updateDiscountCodes: sharedEndpoint(
+        COMMERCE_ENDPOINT_OPERATIONS.carts.updateDiscountCodes
+      ),
+      updateAttributes: sharedEndpoint(
+        COMMERCE_ENDPOINT_OPERATIONS.carts.updateAttributes
+      ),
+      clear: sharedEndpoint(COMMERCE_ENDPOINT_OPERATIONS.carts.clear)
+    },
+    addItem: sharedEndpoint(COMMERCE_ENDPOINT_OPERATIONS.carts.addItem),
+    updateItem: endpoint("POST", "/api/carts/update-item"),
+    removeItem: endpoint("POST", "/api/carts/remove-item"),
+    updateDiscountCodes: endpoint("POST", "/api/carts/update-discount-codes"),
+    updateAttributes: endpoint("POST", "/api/carts/update-attributes"),
+    clear: endpoint("POST", "/api/carts/clear")
+  },
+  paymentSessions: {
+    create: endpoint("POST", "/api/payment-sessions/create"),
+    retrieve: endpoint("POST", "/api/payment-sessions/retrieve"),
+    cancel: endpoint("POST", "/api/payment-sessions/cancel"),
+    custom: {
+      create: sharedEndpoint(
+        COMMERCE_ENDPOINT_OPERATIONS.paymentSessions.custom.create
+      ),
+      confirm: sharedEndpoint(
+        COMMERCE_ENDPOINT_OPERATIONS.paymentSessions.custom.confirm
+      )
+    },
+    server: {
+      create: endpoint("POST", "/api/payment-sessions/server/create"),
+      retrieve: endpoint("POST", "/api/payment-sessions/server/retrieve"),
+      cancel: endpoint("POST", "/api/payment-sessions/server/cancel"),
+      confirm: endpoint("POST", "/api/payment-sessions/server/confirm")
     }
-    throw attachRequestId(
-      createApiError(errorMessage, response.status, data, errorMessage, "An error occurred while processing the request."),
-      requestId
-    );
+  },
+  shippingPolicies: {
+    calculate: endpoint("POST", "/api/shipping-policies/calculate")
   }
-  return data;
+};
+function isCommerceEndpointDescriptor(value) {
+  if (!value || typeof value !== "object") return false;
+  const candidate = value;
+  return typeof candidate.method === "string" && typeof candidate.path === "string";
+}
+function flattenEndpointPaths(value) {
+  if (isCommerceEndpointDescriptor(value)) return [resolveOperationPath2(value)];
+  if (!value || typeof value !== "object") return [];
+  return Object.values(value).flatMap((entry) => flattenEndpointPaths(entry));
+}
+function flattenEndpointDescriptors(value) {
+  if (isCommerceEndpointDescriptor(value)) return [value];
+  if (!value || typeof value !== "object") return [];
+  return Object.values(value).flatMap(
+    (entry) => flattenEndpointDescriptors(entry)
+  );
 }
+var COMMERCE_ENDPOINT_PATHS = flattenEndpointPaths(COMMERCE_ENDPOINTS);
+var COMMERCE_ENDPOINT_DESCRIPTORS = flattenEndpointDescriptors(COMMERCE_ENDPOINTS);
+var MEMBERSHIP_ENDPOINTS = {
+  subscribe: "/api/memberships/subscribe",
+  cancel: (id) => `/api/memberships/${id}/cancel`,
+  me: "/api/memberships/me"
+};
+var MEMBERSHIP_ENDPOINT_PATHS = [
+  MEMBERSHIP_ENDPOINTS.subscribe,
+  MEMBERSHIP_ENDPOINTS.cancel(":id"),
+  MEMBERSHIP_ENDPOINTS.me
+];
 
 // src/core/api/customer-scoped-api.ts
-var CustomerScopedApi = class {
+var CustomerScopedTransport = class {
   constructor(apiName, options) {
     if (options.requiresCredential !== false && !options.secretKey && !options.customerToken) {
       throw createConfigError(
@@ -1038,10 +1441,10 @@ var CustomerScopedApi = class {
     this.onUnauthorized = options.onUnauthorized;
     this.onRequestId = options.onRequestId;
   }
-  async request(endpoint, options) {
+  async request(endpoint2, options) {
     const token = typeof this.customerToken === "function" ? this.customerToken() : this.customerToken;
     try {
-      const response = await httpFetch(endpoint, {
+      const response = await httpFetch(endpoint2, {
         method: options.method,
         apiUrl: this.apiUrl,
         publishableKey: this.publishableKey,
@@ -1051,10 +1454,13 @@ var CustomerScopedApi = class {
         ...options.body !== void 0 && {
           body: JSON.stringify(options.body)
         },
-        ...options.headers && { headers: options.headers }
+        ...options.headers && { headers: options.headers },
+        ...options.errorFamily && { errorFamily: options.errorFamily }
       });
       this.onRequestId?.(response.headers.get("x-request-id") ?? null);
-      return parseApiResponse(response, endpoint);
+      return parseApiResponse(response, endpoint2, {
+        errorFamily: options.errorFamily
+      });
     } catch (err) {
       const id = err instanceof SDKError ? err.requestId ?? null : null;
       this.onRequestId?.(id);
@@ -1062,6 +1468,26 @@ var CustomerScopedApi = class {
     }
   }
 };
+var CustomerScopedApi = class {
+  constructor(apiName, options) {
+    this.transport = new CustomerScopedTransport(apiName, options);
+  }
+  requestEndpoint(endpoint2, body, options) {
+    return this.transport.request(resolveOperationPath2(endpoint2, options), {
+      method: resolveOperationMethod2(endpoint2),
+      body,
+      headers: options?.headers
+    });
+  }
+};
+var RawCustomerScopedApi = class {
+  constructor(apiName, options) {
+    this.transport = new CustomerScopedTransport(apiName, options);
+  }
+  request(endpoint2, options) {
+    return this.transport.request(endpoint2, options);
+  }
+};
 
 // src/core/community/community-client.ts
 var DEFAULT_POST_LIST_SORT = "-lastActivityAt";
@@ -1072,7 +1498,7 @@ function unwrapPayloadDoc(value) {
   }
   return value;
 }
-var CommunityClient = class extends CustomerScopedApi {
+var CommunityClient = class extends RawCustomerScopedApi {
   constructor(options) {
     super("CommunityClient", { ...options, requiresCredential: false });
   }
@@ -1116,11 +1542,11 @@ var CommunityClient = class extends CustomerScopedApi {
     if (params.page !== void 0) urlParams.set("page", String(params.page));
     return `/api/comments/public?${urlParams.toString()}`;
   }
-  async execute(endpoint, method, body) {
-    return this.request(endpoint, { method, body });
+  async execute(endpoint2, method, body) {
+    return this.request(endpoint2, { method, body });
   }
-  async executeDoc(endpoint, method, body) {
-    const response = await this.execute(endpoint, method, body);
+  async executeDoc(endpoint2, method, body) {
+    const response = await this.execute(endpoint2, method, body);
     return unwrapPayloadDoc(response);
   }
   createPost(params) {
@@ -1356,56 +1782,1538 @@ var CommunityClient = class extends CustomerScopedApi {
       body
     );
   }
-};
-
-// src/core/content/content-client.ts
-var PublicContentApi = class extends CustomerScopedApi {
-  get(endpoint) {
-    return this.request(endpoint, { method: "GET" });
-  }
-};
-function appendCommonParams(search, options, defaultSort) {
-  search.set("sort", options?.sort ?? defaultSort);
-  if (options?.page != null) search.set("page", String(options.page));
-  if (options?.limit != null) search.set("limit", String(options.limit));
-}
-function linksListPath(options) {
-  const search = new URLSearchParams();
-  appendCommonParams(search, options, "-publishedAt,-createdAt");
-  if (options?.categoryId) search.set("categoryId", options.categoryId);
-  if (options?.categorySlug) {
-    search.set("categorySlug", options.categorySlug);
-  }
-  if (options?.tagId) search.set("tagId", options.tagId);
-  if (options?.tagSlug) search.set("tagSlug", options.tagSlug);
-  if (options?.featured != null) search.set("featured", String(options.featured));
-  return `/api/links/storefront?${search}`;
-}
-function galleryItemsListPath(options) {
-  const search = new URLSearchParams();
-  appendCommonParams(search, options, "manual");
-  if (options?.galleryId) search.set("galleryId", options.galleryId);
-  if (options?.gallerySlug) search.set("gallerySlug", options.gallerySlug);
-  return `/api/gallery-items/storefront?${search}`;
+};
+
+// src/core/content/content-client.ts
+var PublicContentApi = class extends RawCustomerScopedApi {
+  get(endpoint2) {
+    return this.request(endpoint2, { method: "GET" });
+  }
+};
+function appendCommonParams(search, options, defaultSort) {
+  search.set("sort", options?.sort ?? defaultSort);
+  if (options?.page != null) search.set("page", String(options.page));
+  if (options?.limit != null) search.set("limit", String(options.limit));
+}
+function linksListPath(options) {
+  const search = new URLSearchParams();
+  appendCommonParams(search, options, "-publishedAt,-createdAt");
+  if (options?.categoryId) search.set("categoryId", options.categoryId);
+  if (options?.categorySlug) {
+    search.set("categorySlug", options.categorySlug);
+  }
+  if (options?.tagId) search.set("tagId", options.tagId);
+  if (options?.tagSlug) search.set("tagSlug", options.tagSlug);
+  if (options?.featured != null)
+    search.set("featured", String(options.featured));
+  return `/api/links/storefront?${search}`;
+}
+function galleryItemsListPath(options) {
+  const search = new URLSearchParams();
+  appendCommonParams(search, options, "manual");
+  if (options?.galleryId) search.set("galleryId", options.galleryId);
+  if (options?.gallerySlug) search.set("gallerySlug", options.gallerySlug);
+  return `/api/gallery-items/storefront?${search}`;
+}
+var ContentClient = class {
+  constructor(options) {
+    const api = new PublicContentApi("ContentClient", {
+      publishableKey: options.publishableKey,
+      apiUrl: options.apiUrl,
+      onRequestId: options.onRequestId,
+      requiresCredential: false
+    });
+    this.links = {
+      list: (params) => api.get(linksListPath(params))
+    };
+    this.galleryItems = {
+      list: (params) => api.get(
+        galleryItemsListPath(params)
+      )
+    };
+  }
+};
+
+// src/core/api/canonical-response.ts
+var CART_STATUSES = ["active", "completed", "abandoned"];
+var MAX_CART_LINE_QUANTITY = 99;
+var MAX_COMMERCE_SHORT_TEXT_LENGTH = 200;
+var MAX_COMMERCE_ADDRESS_LENGTH = 500;
+var MAX_COMMERCE_EMAIL_LENGTH = 254;
+var MAX_COMMERCE_PHONE_LENGTH = 32;
+var MAX_COMMERCE_POSTAL_CODE_LENGTH = 32;
+var MAX_COMMERCE_EXTENSION_VALUE_LENGTH = 500;
+var MAX_COMMERCE_RESOURCE_ID_LENGTH = 255;
+var MAX_COMMERCE_CAPABILITY_LENGTH = 512;
+var MAX_CART_DISCOUNT_CODE_LENGTH = 128;
+var ORDER_FINANCIAL_STATUSES = [
+  "pending",
+  "authorized",
+  "expired",
+  "partially_paid",
+  "paid",
+  "canceled",
+  "partially_refunded",
+  "refunded",
+  "reconciliation_required"
+];
+var ORDER_FULFILLMENT_STATUSES = [
+  "unfulfilled",
+  "in_progress",
+  "on_hold",
+  "partially_fulfilled",
+  "shipped",
+  "fulfilled",
+  "canceled"
+];
+var ORDER_RETURN_STATUSES = [
+  "no_return",
+  "return_requested",
+  "in_progress",
+  "returned"
+];
+var ORDER_CONFIRMATION_STATUSES = ["unconfirmed", "confirmed"];
+var ORDER_PRIMARY_DISPLAY_STATUSES = [
+  "pending",
+  "paid",
+  "canceled",
+  "refunded",
+  "preparing",
+  "shipped",
+  "delivered",
+  "confirmed"
+];
+var CHECKOUT_STATUSES = ["open", "placed", "abandoned"];
+var ABANDONED_REASONS = ["expired", "customer", "operator"];
+var PAYMENT_PROVIDERS = ["toss"];
+var PAYMENT_PROVIDER_STATUSES = [
+  "requires_payment_method",
+  "requires_action",
+  "requires_confirmation",
+  "initializing",
+  "processing",
+  "authorized",
+  "canceling",
+  "unknown",
+  "captured",
+  "failed",
+  "canceled"
+];
+var PAYMENT_FAILURE_REASONS = [
+  "payment_declined",
+  "authentication_failed",
+  "authorization_expired",
+  "payment_method_unavailable",
+  "provider_terminal_failure",
+  "unknown_provider_terminal_failure"
+];
+var CART_WARNING_CODES = [
+  "DISCOUNT_CODE_NOT_HONOURED",
+  "DISCOUNT_CURRENTLY_INACTIVE",
+  "DISCOUNT_CUSTOMER_NOT_ELIGIBLE",
+  "DISCOUNT_CUSTOMER_USAGE_LIMIT_REACHED",
+  "DISCOUNT_ELIGIBLE_CUSTOMER_MISSING",
+  "DISCOUNT_NO_ENTITLED_LINE_ITEMS",
+  "DISCOUNT_NO_ENTITLED_SHIPPING_LINES",
+  "DISCOUNT_NOT_FOUND",
+  "DISCOUNT_PURCHASE_NOT_IN_RANGE",
+  "DISCOUNT_USAGE_LIMIT_REACHED",
+  "MERCHANDISE_NOT_ENOUGH_STOCK",
+  "MERCHANDISE_OUT_OF_STOCK"
+];
+function invalidCanonicalResponse(resource, details) {
+  throw createApiError(
+    `Invalid canonical ${resource} response.`,
+    502,
+    { resource, ...details },
+    `The server returned an incompatible ${resource} response.`,
+    "Verify that the Console commerce contract is deployed before using this SDK version."
+  );
+}
+function fail(resource, path, expected) {
+  invalidCanonicalResponse(resource, { path, expected });
+}
+function record(value, resource, path) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    fail(resource, path, "object");
+  }
+  return value;
+}
+function exact(value, required, optional, resource, path) {
+  for (const key of required) {
+    if (!(key in value)) fail(resource, `${path}.${key}`, "required field");
+  }
+  const allowed = /* @__PURE__ */ new Set([...required, ...optional]);
+  const unexpected = Object.keys(value).find((key) => !allowed.has(key));
+  if (unexpected) fail(resource, `${path}.${unexpected}`, "no unknown fields");
+}
+function string(value, resource, path) {
+  if (typeof value !== "string" || value.length === 0) {
+    fail(resource, path, "non-empty string");
+  }
+  return value;
+}
+function boundedString(value, maxLength, resource, path, allowEmpty = false) {
+  if (typeof value !== "string" || !allowEmpty && value.length === 0 || value.length > maxLength) {
+    fail(
+      resource,
+      path,
+      `${allowEmpty ? "" : "non-empty "}string of at most ${maxLength} characters`
+    );
+  }
+  return value;
+}
+function nullableString(value, resource, path) {
+  if (value !== null && typeof value !== "string") {
+    fail(resource, path, "string or null");
+  }
+}
+function cartLineQuantity(value, resource, path) {
+  const quantity = positiveInteger(value, resource, path);
+  if (quantity > MAX_CART_LINE_QUANTITY) {
+    fail(resource, path, `integer between 1 and ${MAX_CART_LINE_QUANTITY}`);
+  }
+  return quantity;
+}
+function boolean(value, resource, path) {
+  if (typeof value !== "boolean") fail(resource, path, "boolean");
+}
+function safeMinor(value, resource, path) {
+  if (!Number.isSafeInteger(value) || value < 0) {
+    fail(resource, path, "non-negative safe integer");
+  }
+  return value;
+}
+function positiveInteger(value, resource, path) {
+  if (!Number.isSafeInteger(value) || value <= 0) {
+    fail(resource, path, "positive safe integer");
+  }
+  return value;
+}
+function enumValue(value, values, resource, path) {
+  if (typeof value !== "string" || !values.includes(value)) {
+    fail(resource, path, values.join(" | "));
+  }
+  return value;
+}
+function timestamp(value, resource, path) {
+  if (typeof value !== "string" || !/^\d{4}-\d{2}-\d{2}T.*(?:Z|[+-]\d{2}:\d{2})$/.test(value) || !Number.isFinite(Date.parse(value))) {
+    fail(resource, path, "ISO 8601 timestamp with offset");
+  }
+}
+function currency(value, resource, path) {
+  if (typeof value !== "string" || !/^[A-Z]{3}$/.test(value)) {
+    fail(resource, path, "three-letter uppercase currency code");
+  }
+}
+function array(value, resource, path) {
+  if (!Array.isArray(value)) fail(resource, path, "array");
+  return value;
+}
+function optionalNullableNumber(value, resource, path) {
+  if (value !== void 0 && value !== null && typeof value !== "number") {
+    fail(resource, path, "number or null");
+  }
+}
+function validateMediaSize(value, resource, path) {
+  const item = record(value, resource, path);
+  exact(
+    item,
+    [],
+    ["width", "height", "mimeType", "filename", "url"],
+    resource,
+    path
+  );
+  optionalNullableNumber(item.width, resource, `${path}.width`);
+  optionalNullableNumber(item.height, resource, `${path}.height`);
+  for (const key of ["mimeType", "filename", "url"]) {
+    if (item[key] !== void 0)
+      nullableString(item[key], resource, `${path}.${key}`);
+  }
+}
+function validateMedia(value, resource, path) {
+  if (typeof value === "string") return;
+  const media = record(value, resource, path);
+  exact(
+    media,
+    [],
+    ["id", "alt", "width", "height", "mimeType", "filename", "url", "sizes"],
+    resource,
+    path
+  );
+  if (media.id !== void 0 && media.id !== null && typeof media.id !== "string" && typeof media.id !== "number") {
+    fail(resource, `${path}.id`, "string, number, or null");
+  }
+  for (const key of ["alt", "mimeType", "filename", "url"]) {
+    if (media[key] !== void 0)
+      nullableString(media[key], resource, `${path}.${key}`);
+  }
+  optionalNullableNumber(media.width, resource, `${path}.width`);
+  optionalNullableNumber(media.height, resource, `${path}.height`);
+  if (media.sizes !== void 0) {
+    const sizes = record(media.sizes, resource, `${path}.sizes`);
+    Object.entries(sizes).forEach(
+      ([key, size]) => validateMediaSize(size, resource, `${path}.sizes.${key}`)
+    );
+  }
+}
+function validateReference(value, resource, path) {
+  const ref = record(value, resource, path);
+  exact(ref, ["id", "title", "handle", "image"], [], resource, path);
+  string(ref.id, resource, `${path}.id`);
+  string(ref.title, resource, `${path}.title`);
+  if (ref.handle !== null) string(ref.handle, resource, `${path}.handle`);
+  if (ref.image !== null) validateMedia(ref.image, resource, `${path}.image`);
+}
+function validateAdmission(value, resource, path) {
+  const admission = record(value, resource, path);
+  exact(
+    admission,
+    ["eventId", "occurrenceId", "admissionTypeId"],
+    [],
+    resource,
+    path
+  );
+  string(admission.eventId, resource, `${path}.eventId`);
+  string(admission.occurrenceId, resource, `${path}.occurrenceId`);
+  string(admission.admissionTypeId, resource, `${path}.admissionTypeId`);
+}
+function compareAdmissions(left, right) {
+  for (const field of ["eventId", "occurrenceId", "admissionTypeId"]) {
+    if (left[field] < right[field]) return -1;
+    if (left[field] > right[field]) return 1;
+  }
+  return 0;
+}
+function validateAdmissions(value, resource, path) {
+  const admissions = array(value, resource, path);
+  if (admissions.length > 32) fail(resource, path, "at most 32 admissions");
+  let prior;
+  admissions.forEach((admission, index) => {
+    validateAdmission(admission, resource, `${path}[${index}]`);
+    const item = admission;
+    const comparison = prior ? compareAdmissions(item, prior) : void 0;
+    if (comparison !== void 0 && comparison <= 0) {
+      fail(resource, `${path}[${index}]`, "unique canonical-sorted admissions");
+    }
+    prior = item;
+  });
+}
+function validateAttributes(value, resource, path) {
+  const attributes = array(value, resource, path);
+  if (attributes.length > 50) fail(resource, path, "at most 50 attributes");
+  const keys = /* @__PURE__ */ new Set();
+  attributes.forEach((value2, index) => {
+    const itemPath = `${path}[${index}]`;
+    const attribute = record(value2, resource, itemPath);
+    exact(attribute, ["key", "value"], [], resource, itemPath);
+    const key = string(attribute.key, resource, `${itemPath}.key`);
+    if (key.length > 40 || key.startsWith("__") || keys.has(key)) {
+      fail(
+        resource,
+        `${itemPath}.key`,
+        "unique, non-reserved key of at most 40 characters"
+      );
+    }
+    keys.add(key);
+    if (typeof attribute.value !== "string" || attribute.value.length > 500) {
+      fail(resource, `${itemPath}.value`, "string of at most 500 characters");
+    }
+  });
+}
+function validateCustomer(value, resource, path) {
+  const customer = record(value, resource, path);
+  exact(customer, ["email"], ["name", "phone"], resource, path);
+  const email = boundedString(
+    customer.email,
+    MAX_COMMERCE_EMAIL_LENGTH,
+    resource,
+    `${path}.email`
+  );
+  if (!/^(?!\.)(?!.*\.\.)([A-Za-z0-9_'+\-.]*)[A-Za-z0-9_+-]@([A-Za-z0-9][A-Za-z0-9-]*\.)+[A-Za-z]{2,}$/.test(
+    email
+  )) {
+    fail(resource, `${path}.email`, "email address");
+  }
+  if (customer.name !== void 0)
+    boundedString(
+      customer.name,
+      MAX_COMMERCE_SHORT_TEXT_LENGTH,
+      resource,
+      `${path}.name`
+    );
+  if (customer.phone !== void 0)
+    boundedString(
+      customer.phone,
+      MAX_COMMERCE_PHONE_LENGTH,
+      resource,
+      `${path}.phone`
+    );
+}
+function validateShippingAddress(value, resource, path) {
+  const address = record(value, resource, path);
+  exact(
+    address,
+    ["recipientName", "phone", "postalCode", "address", "detailAddress"],
+    ["countryCode", "regionCode", "deliveryMessage"],
+    resource,
+    path
+  );
+  boundedString(
+    address.recipientName,
+    MAX_COMMERCE_SHORT_TEXT_LENGTH,
+    resource,
+    `${path}.recipientName`
+  );
+  boundedString(
+    address.phone,
+    MAX_COMMERCE_PHONE_LENGTH,
+    resource,
+    `${path}.phone`
+  );
+  boundedString(
+    address.postalCode,
+    MAX_COMMERCE_POSTAL_CODE_LENGTH,
+    resource,
+    `${path}.postalCode`
+  );
+  for (const key of ["address", "detailAddress"]) {
+    boundedString(
+      address[key],
+      MAX_COMMERCE_ADDRESS_LENGTH,
+      resource,
+      `${path}.${key}`
+    );
+  }
+  if (address.countryCode !== void 0) {
+    if (typeof address.countryCode !== "string" || address.countryCode.trim().length !== 2) {
+      fail(resource, `${path}.countryCode`, "two-letter country code");
+    }
+  }
+  if (address.regionCode !== void 0) {
+    if (typeof address.regionCode !== "string" || address.regionCode.trim().length === 0 || address.regionCode.trim().length > 64) {
+      fail(
+        resource,
+        `${path}.regionCode`,
+        "trimmed string of at most 64 characters"
+      );
+    }
+  }
+  if (address.deliveryMessage !== void 0) {
+    boundedString(
+      address.deliveryMessage,
+      MAX_COMMERCE_EXTENSION_VALUE_LENGTH,
+      resource,
+      `${path}.deliveryMessage`,
+      true
+    );
+  }
+}
+function validateOrderReference(value, resource, path) {
+  const order = record(value, resource, path);
+  exact(order, ["id", "orderNumber"], [], resource, path);
+  string(order.id, resource, `${path}.id`);
+  string(order.orderNumber, resource, `${path}.orderNumber`);
+}
+function validateIntegrationMetadata(value, resource, path) {
+  const metadata = record(value, resource, path);
+  if (Object.keys(metadata).length > 50)
+    fail(resource, path, "at most 50 entries");
+  Object.entries(metadata).forEach(([key, entry]) => {
+    if (!key || key.length > 40 || key.includes("[") || key.includes("]")) {
+      fail(resource, `${path}.${key}`, "valid metadata key");
+    }
+    if (typeof entry !== "string" || entry.length > 500) {
+      fail(resource, `${path}.${key}`, "string of at most 500 characters");
+    }
+  });
+}
+function validateCartItem(value, resource, path) {
+  const item = record(value, resource, path);
+  exact(
+    item,
+    [
+      "id",
+      "product",
+      "variant",
+      "admissions",
+      "quantity",
+      "unitPriceMinor",
+      "discountMinor",
+      "estimatedLineTotalMinor",
+      "requiresShipping"
+    ],
+    [],
+    resource,
+    path
+  );
+  string(item.id, resource, `${path}.id`);
+  validateReference(item.product, resource, `${path}.product`);
+  validateReference(item.variant, resource, `${path}.variant`);
+  validateAdmissions(item.admissions, resource, `${path}.admissions`);
+  cartLineQuantity(item.quantity, resource, `${path}.quantity`);
+  const unitPrice = safeMinor(
+    item.unitPriceMinor,
+    resource,
+    `${path}.unitPriceMinor`
+  );
+  const discount = safeMinor(
+    item.discountMinor,
+    resource,
+    `${path}.discountMinor`
+  );
+  const estimatedLineTotal = safeMinor(
+    item.estimatedLineTotalMinor,
+    resource,
+    `${path}.estimatedLineTotalMinor`
+  );
+  const quantity = item.quantity;
+  const expectedLineTotal = BigInt(unitPrice) * BigInt(quantity) - BigInt(discount);
+  if (expectedLineTotal < 0n || BigInt(estimatedLineTotal) !== expectedLineTotal) {
+    fail(
+      resource,
+      `${path}.estimatedLineTotalMinor`,
+      "unitPriceMinor * quantity - discountMinor"
+    );
+  }
+  boolean(item.requiresShipping, resource, `${path}.requiresShipping`);
+}
+function validatePublicCart(value, resource = "Cart") {
+  const cart = record(value, resource, "$");
+  exact(
+    cart,
+    [
+      "id",
+      "status",
+      "revision",
+      "currency",
+      "market",
+      "subtotalMinor",
+      "discountMinor",
+      "estimatedTotalMinor",
+      "discountCodes",
+      "attributes",
+      "items",
+      "expiresAt",
+      "createdAt",
+      "updatedAt"
+    ],
+    [],
+    resource,
+    "$"
+  );
+  string(cart.id, resource, "$.id");
+  enumValue(cart.status, CART_STATUSES, resource, "$.status");
+  safeMinor(cart.revision, resource, "$.revision");
+  currency(cart.currency, resource, "$.currency");
+  const market = record(cart.market, resource, "$.market");
+  exact(market, ["id", "handle", "name"], [], resource, "$.market");
+  for (const key of ["id", "handle", "name"])
+    string(market[key], resource, `$.market.${key}`);
+  const subtotal = safeMinor(cart.subtotalMinor, resource, "$.subtotalMinor");
+  const discount = safeMinor(cart.discountMinor, resource, "$.discountMinor");
+  const estimatedTotal = safeMinor(
+    cart.estimatedTotalMinor,
+    resource,
+    "$.estimatedTotalMinor"
+  );
+  array(cart.discountCodes, resource, "$.discountCodes").forEach(
+    (value2, index) => {
+      const itemPath = `$.discountCodes[${index}]`;
+      const code = record(value2, resource, itemPath);
+      exact(code, ["code", "applicable"], [], resource, itemPath);
+      boundedString(
+        code.code,
+        MAX_CART_DISCOUNT_CODE_LENGTH,
+        resource,
+        `${itemPath}.code`
+      );
+      boolean(code.applicable, resource, `${itemPath}.applicable`);
+    }
+  );
+  validateAttributes(cart.attributes, resource, "$.attributes");
+  const items = array(cart.items, resource, "$.items");
+  items.forEach(
+    (item, index) => validateCartItem(item, resource, `$.items[${index}]`)
+  );
+  const expectedSubtotal = items.reduce((total, value2) => {
+    const item = value2;
+    return total + BigInt(item.unitPriceMinor) * BigInt(item.quantity);
+  }, 0n);
+  const expectedDiscount = items.reduce((total, value2) => {
+    const item = value2;
+    return total + BigInt(item.discountMinor);
+  }, 0n);
+  if (BigInt(subtotal) !== expectedSubtotal) {
+    fail(resource, "$.subtotalMinor", "sum of undiscounted cart line totals");
+  }
+  if (BigInt(discount) !== expectedDiscount) {
+    fail(resource, "$.discountMinor", "sum of cart line discounts");
+  }
+  if (expectedSubtotal - BigInt(discount) < 0n || BigInt(estimatedTotal) !== expectedSubtotal - BigInt(discount)) {
+    fail(resource, "$.estimatedTotalMinor", "subtotalMinor - discountMinor");
+  }
+  timestamp(cart.expiresAt, resource, "$.expiresAt");
+  timestamp(cart.createdAt, resource, "$.createdAt");
+  timestamp(cart.updatedAt, resource, "$.updatedAt");
+  return value;
+}
+function validateWarnings(value, resource, path) {
+  array(value, resource, path).forEach((value2, index) => {
+    const itemPath = `${path}[${index}]`;
+    const warning = record(value2, resource, itemPath);
+    exact(warning, ["code", "message", "target"], [], resource, itemPath);
+    enumValue(warning.code, CART_WARNING_CODES, resource, `${itemPath}.code`);
+    string(warning.message, resource, `${itemPath}.message`);
+    string(warning.target, resource, `${itemPath}.target`);
+  });
+}
+function validateCartMutationResult(value) {
+  const result = record(value, "Cart mutation result", "$");
+  exact(result, ["cart", "warnings"], [], "Cart mutation result", "$");
+  validatePublicCart(result.cart);
+  validateWarnings(result.warnings, "Cart mutation result", "$.warnings");
+  return value;
+}
+function validateCreateCartResult(value) {
+  const result = record(value, "Cart create result", "$");
+  exact(
+    result,
+    ["cart", "warnings", "cartToken"],
+    [],
+    "Cart create result",
+    "$"
+  );
+  const cart = record(result.cart, "Cart create result", "$.cart");
+  validatePublicCart(cart);
+  if (cart.revision !== 0) {
+    fail("Cart create result", "$.cart.revision", "0 for a newly created Cart");
+  }
+  validateWarnings(result.warnings, "Cart create result", "$.warnings");
+  boundedString(
+    result.cartToken,
+    MAX_COMMERCE_CAPABILITY_LENGTH,
+    "Cart create result",
+    "$.cartToken"
+  );
+  return value;
+}
+function validateCartMineResult(value) {
+  const result = record(value, "Cart mine result", "$");
+  exact(result, ["cart", "cartToken"], [], "Cart mine result", "$");
+  if (result.cart === null || result.cartToken === null) {
+    if (result.cart !== null || result.cartToken !== null) {
+      fail("Cart mine result", "$", "cart and cartToken must both be null");
+    }
+  } else {
+    validatePublicCart(result.cart);
+    boundedString(
+      result.cartToken,
+      MAX_COMMERCE_CAPABILITY_LENGTH,
+      "Cart mine result",
+      "$.cartToken"
+    );
+  }
+  return value;
+}
+function validateCartMergeResult(value) {
+  const result = record(value, "Cart merge result", "$");
+  exact(
+    result,
+    ["cart", "warnings", "cartToken", "resolution", "merged", "claimed"],
+    [],
+    "Cart merge result",
+    "$"
+  );
+  validatePublicCart(result.cart);
+  validateWarnings(result.warnings, "Cart merge result", "$.warnings");
+  boundedString(
+    result.cartToken,
+    MAX_COMMERCE_CAPABILITY_LENGTH,
+    "Cart merge result",
+    "$.cartToken"
+  );
+  const resolution = enumValue(
+    result.resolution,
+    ["unchanged", "claimed", "merged"],
+    "Cart merge result",
+    "$.resolution"
+  );
+  boolean(result.merged, "Cart merge result", "$.merged");
+  boolean(result.claimed, "Cart merge result", "$.claimed");
+  const expected = resolution === "merged" ? [true, false] : resolution === "claimed" ? [false, true] : [false, false];
+  if (result.merged !== expected[0] || result.claimed !== expected[1]) {
+    fail("Cart merge result", "$", "resolution-consistent merged/claimed flags");
+  }
+  return value;
+}
+function validatePublicOrderItem(value, resource, path) {
+  const item = record(value, resource, path);
+  exact(
+    item,
+    [
+      "id",
+      "product",
+      "variant",
+      "productTitle",
+      "variantTitle",
+      "sku",
+      "admissions",
+      "quantity",
+      "unitPriceMinor",
+      "discountMinor",
+      "lineTotalMinor",
+      "requiresShipping"
+    ],
+    [],
+    resource,
+    path
+  );
+  string(item.id, resource, `${path}.id`);
+  if (item.product !== null) {
+    validateReference(item.product, resource, `${path}.product`);
+  }
+  if (item.variant !== null) {
+    validateReference(item.variant, resource, `${path}.variant`);
+  }
+  string(item.productTitle, resource, `${path}.productTitle`);
+  nullableString(item.variantTitle, resource, `${path}.variantTitle`);
+  nullableString(item.sku, resource, `${path}.sku`);
+  validateAdmissions(item.admissions, resource, `${path}.admissions`);
+  const quantity = positiveInteger(item.quantity, resource, `${path}.quantity`);
+  const unitPrice = safeMinor(
+    item.unitPriceMinor,
+    resource,
+    `${path}.unitPriceMinor`
+  );
+  const discount = safeMinor(
+    item.discountMinor,
+    resource,
+    `${path}.discountMinor`
+  );
+  const lineTotal = safeMinor(
+    item.lineTotalMinor,
+    resource,
+    `${path}.lineTotalMinor`
+  );
+  const expected = BigInt(unitPrice) * BigInt(quantity) - BigInt(discount);
+  if (expected < 0n || BigInt(lineTotal) !== expected) {
+    fail(
+      resource,
+      `${path}.lineTotalMinor`,
+      "unitPriceMinor * quantity - discountMinor"
+    );
+  }
+  boolean(item.requiresShipping, resource, `${path}.requiresShipping`);
+}
+function validatePublicOrderAt(value, resource, path) {
+  const order = record(value, resource, path);
+  exact(
+    order,
+    [
+      "id",
+      "orderNumber",
+      "amounts",
+      "market",
+      "customerSnapshot",
+      "shippingAddress",
+      "attributes",
+      "items",
+      "financialStatus",
+      "fulfillmentStatus",
+      "returnStatus",
+      "confirmationStatus",
+      "primaryDisplayStatus",
+      "placedAt",
+      "createdAt",
+      "updatedAt"
+    ],
+    [],
+    resource,
+    path
+  );
+  string(order.id, resource, `${path}.id`);
+  string(order.orderNumber, resource, `${path}.orderNumber`);
+  const amounts = record(order.amounts, resource, `${path}.amounts`);
+  exact(
+    amounts,
+    [
+      "currency",
+      "subtotalMinor",
+      "shippingMinor",
+      "discountMinor",
+      "totalMinor",
+      "refundedMinor",
+      "currentTotalMinor"
+    ],
+    [],
+    resource,
+    `${path}.amounts`
+  );
+  currency(amounts.currency, resource, `${path}.amounts.currency`);
+  const subtotal = safeMinor(
+    amounts.subtotalMinor,
+    resource,
+    `${path}.amounts.subtotalMinor`
+  );
+  const shipping = safeMinor(
+    amounts.shippingMinor,
+    resource,
+    `${path}.amounts.shippingMinor`
+  );
+  const discount = safeMinor(
+    amounts.discountMinor,
+    resource,
+    `${path}.amounts.discountMinor`
+  );
+  const total = safeMinor(
+    amounts.totalMinor,
+    resource,
+    `${path}.amounts.totalMinor`
+  );
+  const refunded = safeMinor(
+    amounts.refundedMinor,
+    resource,
+    `${path}.amounts.refundedMinor`
+  );
+  const current = safeMinor(
+    amounts.currentTotalMinor,
+    resource,
+    `${path}.amounts.currentTotalMinor`
+  );
+  const expectedTotal = BigInt(subtotal) + BigInt(shipping) - BigInt(discount);
+  if (expectedTotal < 0n || BigInt(total) !== expectedTotal) {
+    fail(
+      resource,
+      `${path}.amounts.totalMinor`,
+      "subtotalMinor + shippingMinor - discountMinor"
+    );
+  }
+  if (BigInt(total) - BigInt(refunded) < 0n || current !== total - refunded) {
+    fail(
+      resource,
+      `${path}.amounts.currentTotalMinor`,
+      "totalMinor - refundedMinor"
+    );
+  }
+  if (order.market !== null) {
+    const market = record(order.market, resource, `${path}.market`);
+    exact(market, ["id", "handle", "name"], [], resource, `${path}.market`);
+    for (const key of ["id", "handle", "name"]) {
+      string(market[key], resource, `${path}.market.${key}`);
+    }
+  }
+  validateCustomer(order.customerSnapshot, resource, `${path}.customerSnapshot`);
+  if (order.shippingAddress !== null) {
+    validateShippingAddress(
+      order.shippingAddress,
+      resource,
+      `${path}.shippingAddress`
+    );
+  }
+  validateAttributes(order.attributes, resource, `${path}.attributes`);
+  const items = array(order.items, resource, `${path}.items`);
+  if (items.length === 0) fail(resource, `${path}.items`, "non-empty array");
+  items.forEach(
+    (item, index) => validatePublicOrderItem(item, resource, `${path}.items[${index}]`)
+  );
+  const expectedSubtotal = items.reduce((sum, value2) => {
+    const item = value2;
+    return sum + BigInt(item.unitPriceMinor) * BigInt(item.quantity);
+  }, 0n);
+  const expectedDiscount = items.reduce((sum, value2) => {
+    const item = value2;
+    return sum + BigInt(item.discountMinor);
+  }, 0n);
+  if (BigInt(subtotal) !== expectedSubtotal) {
+    fail(resource, `${path}.amounts.subtotalMinor`, "sum of line subtotals");
+  }
+  if (BigInt(discount) !== expectedDiscount) {
+    fail(resource, `${path}.amounts.discountMinor`, "sum of line discounts");
+  }
+  enumValue(
+    order.financialStatus,
+    ORDER_FINANCIAL_STATUSES,
+    resource,
+    `${path}.financialStatus`
+  );
+  enumValue(
+    order.fulfillmentStatus,
+    ORDER_FULFILLMENT_STATUSES,
+    resource,
+    `${path}.fulfillmentStatus`
+  );
+  enumValue(
+    order.returnStatus,
+    ORDER_RETURN_STATUSES,
+    resource,
+    `${path}.returnStatus`
+  );
+  enumValue(
+    order.confirmationStatus,
+    ORDER_CONFIRMATION_STATUSES,
+    resource,
+    `${path}.confirmationStatus`
+  );
+  enumValue(
+    order.primaryDisplayStatus,
+    ORDER_PRIMARY_DISPLAY_STATUSES,
+    resource,
+    `${path}.primaryDisplayStatus`
+  );
+  timestamp(order.placedAt, resource, `${path}.placedAt`);
+  timestamp(order.createdAt, resource, `${path}.createdAt`);
+  timestamp(order.updatedAt, resource, `${path}.updatedAt`);
+}
+function nullablePositiveInteger(value, resource, path) {
+  if (value !== null) positiveInteger(value, resource, path);
+}
+function validatePublicOrderList(value) {
+  const resource = "Order list";
+  const result = record(value, resource, "$");
+  exact(
+    result,
+    [
+      "docs",
+      "totalDocs",
+      "limit",
+      "totalPages",
+      "page",
+      "pagingCounter",
+      "hasPrevPage",
+      "hasNextPage",
+      "prevPage",
+      "nextPage"
+    ],
+    [],
+    resource,
+    "$"
+  );
+  array(result.docs, resource, "$.docs").forEach(
+    (order, index) => validatePublicOrderAt(order, resource, `$.docs[${index}]`)
+  );
+  safeMinor(result.totalDocs, resource, "$.totalDocs");
+  positiveInteger(result.limit, resource, "$.limit");
+  safeMinor(result.totalPages, resource, "$.totalPages");
+  positiveInteger(result.page, resource, "$.page");
+  positiveInteger(result.pagingCounter, resource, "$.pagingCounter");
+  boolean(result.hasPrevPage, resource, "$.hasPrevPage");
+  boolean(result.hasNextPage, resource, "$.hasNextPage");
+  nullablePositiveInteger(result.prevPage, resource, "$.prevPage");
+  nullablePositiveInteger(result.nextPage, resource, "$.nextPage");
+  return value;
+}
+function validateCheckoutItem(value, resource, path) {
+  const item = record(value, resource, path);
+  exact(
+    item,
+    [
+      "id",
+      "product",
+      "variant",
+      "productTitle",
+      "variantTitle",
+      "sku",
+      "admissions",
+      "quantity",
+      "unitPriceMinor",
+      "discountMinor",
+      "lineTotalMinor",
+      "requiresShipping"
+    ],
+    [],
+    resource,
+    path
+  );
+  string(item.id, resource, `${path}.id`);
+  validateReference(item.product, resource, `${path}.product`);
+  validateReference(item.variant, resource, `${path}.variant`);
+  string(item.productTitle, resource, `${path}.productTitle`);
+  nullableString(item.variantTitle, resource, `${path}.variantTitle`);
+  nullableString(item.sku, resource, `${path}.sku`);
+  validateAdmissions(item.admissions, resource, `${path}.admissions`);
+  cartLineQuantity(item.quantity, resource, `${path}.quantity`);
+  const unitPrice = safeMinor(
+    item.unitPriceMinor,
+    resource,
+    `${path}.unitPriceMinor`
+  );
+  const discount = safeMinor(
+    item.discountMinor,
+    resource,
+    `${path}.discountMinor`
+  );
+  const lineTotal = safeMinor(
+    item.lineTotalMinor,
+    resource,
+    `${path}.lineTotalMinor`
+  );
+  const expectedLineTotal = BigInt(unitPrice) * BigInt(item.quantity) - BigInt(discount);
+  if (expectedLineTotal < 0n || BigInt(lineTotal) !== expectedLineTotal) {
+    fail(
+      resource,
+      `${path}.lineTotalMinor`,
+      "unitPriceMinor * quantity - discountMinor"
+    );
+  }
+  boolean(item.requiresShipping, resource, `${path}.requiresShipping`);
+}
+function validateCheckoutAmounts(value, resource, path) {
+  const amounts = record(value, resource, path);
+  exact(
+    amounts,
+    [
+      "currency",
+      "subtotalMinor",
+      "shippingMinor",
+      "discountMinor",
+      "totalMinor"
+    ],
+    [],
+    resource,
+    path
+  );
+  currency(amounts.currency, resource, `${path}.currency`);
+  const subtotal = safeMinor(
+    amounts.subtotalMinor,
+    resource,
+    `${path}.subtotalMinor`
+  );
+  const shipping = safeMinor(
+    amounts.shippingMinor,
+    resource,
+    `${path}.shippingMinor`
+  );
+  const discount = safeMinor(
+    amounts.discountMinor,
+    resource,
+    `${path}.discountMinor`
+  );
+  const total = safeMinor(amounts.totalMinor, resource, `${path}.totalMinor`);
+  if (BigInt(total) !== BigInt(subtotal) + BigInt(shipping) - BigInt(discount)) {
+    fail(
+      resource,
+      `${path}.totalMinor`,
+      "subtotalMinor + shippingMinor - discountMinor"
+    );
+  }
+}
+function validatePaymentSessionReference(value, resource, path) {
+  const session = record(value, resource, path);
+  exact(session, ["id", "provider", "providerStatus"], [], resource, path);
+  string(session.id, resource, `${path}.id`);
+  enumValue(session.provider, PAYMENT_PROVIDERS, resource, `${path}.provider`);
+  enumValue(
+    session.providerStatus,
+    PAYMENT_PROVIDER_STATUSES,
+    resource,
+    `${path}.providerStatus`
+  );
+}
+function checkoutVariantKeys(status, placedVia) {
+  const base = [
+    "id",
+    "amounts",
+    "items",
+    "customerSnapshot",
+    "shippingAddress",
+    "attributes",
+    "expiresAt",
+    "createdAt",
+    "updatedAt",
+    "status",
+    "paymentState",
+    "order"
+  ];
+  if (status === "open") return { required: base, optional: [] };
+  if (status === "abandoned") {
+    return {
+      required: [...base, "abandonedAt", "abandonedReason"],
+      optional: []
+    };
+  }
+  return placedVia === "late_capture" ? {
+    required: [
+      ...base,
+      "placedAt",
+      "placedVia",
+      "abandonedAt",
+      "abandonedReason"
+    ],
+    optional: []
+  } : { required: [...base, "placedAt"], optional: [] };
+}
+function validateCheckoutCore(value, resource, list, server) {
+  const checkout = record(value, resource, "$");
+  const status = enumValue(
+    checkout.status,
+    CHECKOUT_STATUSES,
+    resource,
+    "$.status"
+  );
+  const keys = checkoutVariantKeys(status, checkout.placedVia);
+  if (list) {
+    keys.required = keys.required.filter(
+      (key) => !["items", "shippingAddress", "attributes"].includes(key)
+    );
+    keys.required.push("clientReferenceId");
+  } else if (server) {
+    keys.required.push("clientReferenceId", "integrationMetadata");
+  }
+  exact(checkout, keys.required, keys.optional, resource, "$");
+  string(checkout.id, resource, "$.id");
+  validateCheckoutAmounts(checkout.amounts, resource, "$.amounts");
+  if (!list) {
+    const items = array(checkout.items, resource, "$.items");
+    if (items.length === 0) fail(resource, "$.items", "non-empty array");
+    items.forEach(
+      (item, index) => validateCheckoutItem(item, resource, `$.items[${index}]`)
+    );
+    const expectedSubtotal = items.reduce((total, value2) => {
+      const item = value2;
+      return total + BigInt(item.unitPriceMinor) * BigInt(item.quantity);
+    }, 0n);
+    const expectedDiscount = items.reduce((total, value2) => {
+      const item = value2;
+      return total + BigInt(item.discountMinor);
+    }, 0n);
+    const amounts = checkout.amounts;
+    if (BigInt(amounts.subtotalMinor) !== expectedSubtotal) {
+      fail(
+        resource,
+        "$.amounts.subtotalMinor",
+        "sum of undiscounted checkout line totals"
+      );
+    }
+    if (BigInt(amounts.discountMinor) !== expectedDiscount) {
+      fail(
+        resource,
+        "$.amounts.discountMinor",
+        "sum of checkout line discounts"
+      );
+    }
+    if (checkout.shippingAddress !== null) {
+      validateShippingAddress(
+        checkout.shippingAddress,
+        resource,
+        "$.shippingAddress"
+      );
+    }
+    validateAttributes(checkout.attributes, resource, "$.attributes");
+  }
+  validateCustomer(checkout.customerSnapshot, resource, "$.customerSnapshot");
+  timestamp(checkout.expiresAt, resource, "$.expiresAt");
+  timestamp(checkout.createdAt, resource, "$.createdAt");
+  timestamp(checkout.updatedAt, resource, "$.updatedAt");
+  const paymentState = record(checkout.paymentState, resource, "$.paymentState");
+  exact(paymentState, ["activePaymentSession"], [], resource, "$.paymentState");
+  if (status === "open") {
+    if (paymentState.activePaymentSession !== null) {
+      validatePaymentSessionReference(
+        paymentState.activePaymentSession,
+        resource,
+        "$.paymentState.activePaymentSession"
+      );
+    }
+    if (checkout.order !== null)
+      fail(resource, "$.order", "null for open Checkout");
+  } else {
+    if (paymentState.activePaymentSession !== null) {
+      fail(
+        resource,
+        "$.paymentState.activePaymentSession",
+        "null for spent Checkout"
+      );
+    }
+    if (status === "placed") {
+      timestamp(checkout.placedAt, resource, "$.placedAt");
+      validateOrderReference(checkout.order, resource, "$.order");
+      if (checkout.placedVia !== void 0 && checkout.placedVia !== "late_capture") {
+        fail(resource, "$.placedVia", "late_capture");
+      }
+      if (checkout.placedVia === "late_capture") {
+        timestamp(checkout.abandonedAt, resource, "$.abandonedAt");
+        enumValue(
+          checkout.abandonedReason,
+          ABANDONED_REASONS,
+          resource,
+          "$.abandonedReason"
+        );
+      }
+    } else {
+      timestamp(checkout.abandonedAt, resource, "$.abandonedAt");
+      enumValue(
+        checkout.abandonedReason,
+        ABANDONED_REASONS,
+        resource,
+        "$.abandonedReason"
+      );
+      if (checkout.order !== null)
+        fail(resource, "$.order", "null for abandoned Checkout");
+    }
+  }
+  if (list || server) {
+    if (checkout.clientReferenceId !== null) {
+      boundedString(
+        checkout.clientReferenceId,
+        MAX_COMMERCE_RESOURCE_ID_LENGTH,
+        resource,
+        "$.clientReferenceId"
+      );
+    }
+  }
+  if (server)
+    validateIntegrationMetadata(
+      checkout.integrationMetadata,
+      resource,
+      "$.integrationMetadata"
+    );
+}
+function validatePublicCheckout(value) {
+  validateCheckoutCore(value, "Checkout", false, false);
+  return value;
+}
+function validateServerCheckout(value) {
+  validateCheckoutCore(value, "Server Checkout", false, true);
+  return value;
+}
+function validateCreateCheckoutResult(value, server) {
+  const resource = server ? "Server Checkout create result" : "Checkout create result";
+  const result = record(value, resource, "$");
+  exact(result, ["checkout", "checkoutToken"], [], resource, "$");
+  if (server) validateServerCheckout(result.checkout);
+  else validatePublicCheckout(result.checkout);
+  boundedString(
+    result.checkoutToken,
+    MAX_COMMERCE_CAPABILITY_LENGTH,
+    resource,
+    "$.checkoutToken"
+  );
+  return value;
+}
+function validateCheckoutQueryResult(value) {
+  const result = record(value, "Checkout query result", "$");
+  exact(
+    result,
+    ["data", "hasMore", "nextCursor"],
+    [],
+    "Checkout query result",
+    "$"
+  );
+  array(result.data, "Checkout query result", "$.data").forEach(
+    (item) => validateCheckoutCore(item, "Checkout list item", true, false)
+  );
+  boolean(result.hasMore, "Checkout query result", "$.hasMore");
+  if (result.nextCursor !== null)
+    boundedString(
+      result.nextCursor,
+      MAX_COMMERCE_CAPABILITY_LENGTH,
+      "Checkout query result",
+      "$.nextCursor"
+    );
+  if (result.hasMore === true && result.nextCursor === null) {
+    fail(
+      "Checkout query result",
+      "$.nextCursor",
+      "non-null when hasMore is true"
+    );
+  }
+  return value;
+}
+function validateMoney(value, resource, path) {
+  const money = record(value, resource, path);
+  exact(money, ["amountMinor", "currency"], [], resource, path);
+  safeMinor(money.amountMinor, resource, `${path}.amountMinor`);
+  currency(money.currency, resource, `${path}.currency`);
+}
+function validateCaptureEvidence(value, resource, path) {
+  const evidence = record(value, resource, path);
+  exact(evidence, ["amountMinor", "currency", "observedAt"], [], resource, path);
+  safeMinor(evidence.amountMinor, resource, `${path}.amountMinor`);
+  currency(evidence.currency, resource, `${path}.currency`);
+  timestamp(evidence.observedAt, resource, `${path}.observedAt`);
+}
+function validateNoReconciliation(value, resource, path) {
+  const reconciliation = record(value, resource, path);
+  exact(reconciliation, ["status"], [], resource, path);
+  if (reconciliation.status !== "none") fail(resource, `${path}.status`, "none");
+}
+function validateRequiredReconciliation(value, allowed, resource, path) {
+  const reconciliation = record(value, resource, path);
+  exact(reconciliation, ["status", "reasons"], [], resource, path);
+  if (reconciliation.status !== "required")
+    fail(resource, `${path}.status`, "required");
+  const reasons = array(reconciliation.reasons, resource, `${path}.reasons`);
+  if (reasons.length === 0) fail(resource, `${path}.reasons`, "non-empty array");
+  let previous = -1;
+  reasons.forEach((reason, index) => {
+    const current = allowed.indexOf(reason);
+    if (current < 0 || current <= previous) {
+      fail(
+        resource,
+        `${path}.reasons[${index}]`,
+        "unique canonical-sorted reconciliation reason"
+      );
+    }
+    previous = current;
+  });
+}
+function validateNextAction(value, resource, path) {
+  const action = record(value, resource, path);
+  exact(
+    action,
+    [
+      "type",
+      "clientKey",
+      "paymentMethodVariantKey",
+      "agreementVariantKey",
+      "providerOrderId",
+      "providerCustomerKey",
+      "orderName"
+    ],
+    ["customerName", "customerEmail"],
+    resource,
+    path
+  );
+  if (action.type !== "toss_widget")
+    fail(resource, `${path}.type`, "toss_widget");
+  for (const key of [
+    "clientKey",
+    "paymentMethodVariantKey",
+    "agreementVariantKey"
+  ]) {
+    boundedString(action[key], 255, resource, `${path}.${key}`);
+  }
+  string(action.providerOrderId, resource, `${path}.providerOrderId`);
+  string(action.providerCustomerKey, resource, `${path}.providerCustomerKey`);
+  boundedString(
+    action.orderName,
+    MAX_COMMERCE_SHORT_TEXT_LENGTH,
+    resource,
+    `${path}.orderName`
+  );
+  if (!/^[A-Za-z0-9_-]{6,64}$/.test(action.providerOrderId)) {
+    fail(resource, `${path}.providerOrderId`, "valid Toss provider order ID");
+  }
+  if (action.providerCustomerKey !== "ANONYMOUS" && !/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(
+    action.providerCustomerKey
+  )) {
+    fail(resource, `${path}.providerCustomerKey`, "ANONYMOUS or UUIDv4");
+  }
+  if (action.customerName !== void 0)
+    boundedString(
+      action.customerName,
+      MAX_COMMERCE_SHORT_TEXT_LENGTH,
+      resource,
+      `${path}.customerName`
+    );
+  if (action.customerEmail !== void 0)
+    validateCustomer({ email: action.customerEmail }, resource, path);
+}
+function validatePublicPaymentSession(value) {
+  const resource = "PaymentSession";
+  const session = record(value, resource, "$");
+  enumValue(session.provider, PAYMENT_PROVIDERS, resource, "$.provider");
+  const status = enumValue(
+    session.providerStatus,
+    PAYMENT_PROVIDER_STATUSES,
+    resource,
+    "$.providerStatus"
+  );
+  const common = [
+    "id",
+    "money",
+    "expiresAt",
+    "sessionRole",
+    "provider",
+    "providerStatus",
+    "presentationStatus",
+    "finalizationStatus",
+    "reconciliation",
+    "order"
+  ];
+  const optional = [];
+  if (status === "requires_payment_method" || status === "requires_action")
+    optional.push("nextAction");
+  else if (status === "captured") common.push("providerEvidence");
+  else if (status === "failed") common.push("failure");
+  else if (status === "canceled") common.push("cancellationReason");
+  exact(session, common, optional, resource, "$");
+  string(session.id, resource, "$.id");
+  validateMoney(session.money, resource, "$.money");
+  if (session.expiresAt !== null)
+    timestamp(session.expiresAt, resource, "$.expiresAt");
+  if (status === "requires_payment_method" || status === "requires_action") {
+    if (session.sessionRole === "active") {
+      if (session.presentationStatus !== "actionable" || session.finalizationStatus !== "not_ready") {
+        fail(resource, "$", "actionable active not-ready state");
+      }
+      if (!("nextAction" in session))
+        fail(resource, "$.nextAction", "required field");
+      validateNextAction(session.nextAction, resource, "$.nextAction");
+    } else if (session.sessionRole === "residual") {
+      if (session.presentationStatus !== "suppressed" || session.finalizationStatus !== "not_ready") {
+        fail(resource, "$", "suppressed residual not-ready state");
+      }
+      if ("nextAction" in session)
+        fail(resource, "$.nextAction", "absent for suppressed state");
+    } else fail(resource, "$.sessionRole", "active | residual");
+    validateNoReconciliation(
+      session.reconciliation,
+      resource,
+      "$.reconciliation"
+    );
+    if (session.order !== null) fail(resource, "$.order", "null");
+  } else if ([
+    "requires_confirmation",
+    "initializing",
+    "processing",
+    "authorized",
+    "canceling"
+  ].includes(status)) {
+    enumValue(
+      session.sessionRole,
+      ["active", "residual"],
+      resource,
+      "$.sessionRole"
+    );
+    if (session.presentationStatus !== "suppressed" || session.finalizationStatus !== "not_ready") {
+      fail(resource, "$", "suppressed not-ready state");
+    }
+    validateNoReconciliation(
+      session.reconciliation,
+      resource,
+      "$.reconciliation"
+    );
+    if (session.order !== null) fail(resource, "$.order", "null");
+  } else if (status === "unknown") {
+    enumValue(
+      session.sessionRole,
+      ["active", "residual"],
+      resource,
+      "$.sessionRole"
+    );
+    if (session.presentationStatus !== "suppressed" || session.finalizationStatus !== "not_ready") {
+      fail(resource, "$", "suppressed not-ready state");
+    }
+    validateRequiredReconciliation(
+      session.reconciliation,
+      ["provider_outcome_unknown"],
+      resource,
+      "$.reconciliation"
+    );
+    if (session.order !== null) fail(resource, "$.order", "null");
+  } else if (status === "captured") {
+    validateCaptureEvidence(
+      session.providerEvidence,
+      resource,
+      "$.providerEvidence"
+    );
+    if (session.presentationStatus !== "suppressed")
+      fail(resource, "$.presentationStatus", "suppressed");
+    if (session.finalizationStatus === "pending") {
+      enumValue(
+        session.sessionRole,
+        ["canonical_candidate", "residual"],
+        resource,
+        "$.sessionRole"
+      );
+      if (session.order !== null)
+        fail(resource, "$.order", "null for pending finalization");
+      const reconciliation = record(
+        session.reconciliation,
+        resource,
+        "$.reconciliation"
+      );
+      if (reconciliation.status === "none")
+        validateNoReconciliation(reconciliation, resource, "$.reconciliation");
+      else
+        validateRequiredReconciliation(
+          reconciliation,
+          [
+            "local_commit_ambiguous",
+            "amount_mismatch",
+            "currency_mismatch",
+            "excess_capture_pending_order"
+          ],
+          resource,
+          "$.reconciliation"
+        );
+    } else if (session.finalizationStatus === "committed") {
+      validateOrderReference(session.order, resource, "$.order");
+      const reconciliation = record(
+        session.reconciliation,
+        resource,
+        "$.reconciliation"
+      );
+      if (reconciliation.status === "none") {
+        enumValue(
+          session.sessionRole,
+          ["canonical", "historical"],
+          resource,
+          "$.sessionRole"
+        );
+        validateNoReconciliation(reconciliation, resource, "$.reconciliation");
+      } else {
+        enumValue(
+          session.sessionRole,
+          ["canonical", "residual"],
+          resource,
+          "$.sessionRole"
+        );
+        validateRequiredReconciliation(
+          reconciliation,
+          [
+            "inventory_unavailable",
+            "admission_unavailable",
+            "amount_mismatch",
+            "currency_mismatch",
+            "excess_capture",
+            "late_capture",
+            "cross_checkout_duplicate"
+          ],
+          resource,
+          "$.reconciliation"
+        );
+      }
+    } else fail(resource, "$.finalizationStatus", "pending | committed");
+  } else if (status === "failed") {
+    if (session.sessionRole !== "historical" || session.presentationStatus !== "suppressed" || session.finalizationStatus !== "not_ready" || session.order !== null) {
+      fail(resource, "$", "historical suppressed failed state");
+    }
+    validateNoReconciliation(
+      session.reconciliation,
+      resource,
+      "$.reconciliation"
+    );
+    const failure = record(session.failure, resource, "$.failure");
+    exact(failure, ["reason"], ["message"], resource, "$.failure");
+    enumValue(
+      failure.reason,
+      PAYMENT_FAILURE_REASONS,
+      resource,
+      "$.failure.reason"
+    );
+    if (failure.message !== void 0)
+      string(failure.message, resource, "$.failure.message");
+  } else {
+    if (session.sessionRole !== "historical" || session.presentationStatus !== "suppressed" || session.finalizationStatus !== "not_ready" || session.order !== null) {
+      fail(resource, "$", "historical suppressed canceled state");
+    }
+    validateNoReconciliation(
+      session.reconciliation,
+      resource,
+      "$.reconciliation"
+    );
+    enumValue(
+      session.cancellationReason,
+      ["expired", "customer", "operator", "provider"],
+      resource,
+      "$.cancellationReason"
+    );
+  }
+  return value;
 }
-var ContentClient = class {
-  constructor(options) {
-    const api = new PublicContentApi("ContentClient", {
-      publishableKey: options.publishableKey,
-      apiUrl: options.apiUrl,
-      onRequestId: options.onRequestId,
-      requiresCredential: false
-    });
-    this.links = {
-      list: (params) => api.get(linksListPath(params))
-    };
-    this.galleryItems = {
-      list: (params) => api.get(
-        galleryItemsListPath(params)
-      )
-    };
-  }
-};
 
 // src/core/customer/customer-auth.ts
 var DEFAULT_TIMEOUT2 = 15e3;
@@ -1424,8 +3332,10 @@ var CustomerAuth = class {
     const persist = options?.persist ?? true;
     if (persist) {
       const key = typeof persist === "string" ? persist : "customer-token";
+      const refreshKey = `${key}:refresh`;
       const isBrowser = typeof window !== "undefined";
       this.token = isBrowser ? safeGetItem(key) : null;
+      this.refreshTokenValue = isBrowser ? safeGetItem(refreshKey) : null;
       this.onTokenChange = isBrowser ? (token) => {
         try {
           if (token) localStorage.setItem(key, token);
@@ -1433,9 +3343,18 @@ var CustomerAuth = class {
         } catch {
         }
       } : void 0;
+      this.onRefreshTokenChange = isBrowser ? (refreshToken) => {
+        try {
+          if (refreshToken) localStorage.setItem(refreshKey, refreshToken);
+          else localStorage.removeItem(refreshKey);
+        } catch {
+        }
+      } : void 0;
     } else {
       this.token = options?.token ?? null;
+      this.refreshTokenValue = options?.refreshToken ?? null;
       this.onTokenChange = options?.onTokenChange;
+      this.onRefreshTokenChange = options?.onRefreshTokenChange;
     }
   }
   /**
@@ -1459,13 +3378,17 @@ var CustomerAuth = class {
       }
     );
     this.setToken(result.token);
+    if (result.refreshToken) this.setRefreshToken(result.refreshToken);
     return result;
   }
   /**
-   * Refresh the current token. Requires a valid (non-expired) token.
+   * Refresh the current token. Uses a refresh token when available, otherwise
+   * falls back to the legacy bearer-token compatibility path.
    */
   async refreshToken() {
-    if (!this.token) throw new ApiError("Not authenticated", 401);
+    if (!this.refreshTokenValue && !this.token) {
+      throw new ApiError("Not authenticated", 401);
+    }
     if (this.refreshPromise) return this.refreshPromise;
     this.refreshPromise = this._doRefreshToken();
     try {
@@ -1475,14 +3398,19 @@ var CustomerAuth = class {
     }
   }
   async _doRefreshToken() {
+    const init = this.refreshTokenValue ? {
+      method: "POST",
+      body: JSON.stringify({ refreshToken: this.refreshTokenValue })
+    } : {
+      method: "POST",
+      headers: { Authorization: `Bearer ${this.token}` }
+    };
     const result = await this.requestJson(
       "/api/customers/refresh",
-      {
-        method: "POST",
-        headers: { Authorization: `Bearer ${this.token}` }
-      }
+      init
     );
     this.setToken(result.token);
+    if (result.refreshToken) this.setRefreshToken(result.refreshToken);
     return result;
   }
   /**
@@ -1490,6 +3418,7 @@ var CustomerAuth = class {
    */
   logout() {
     this.setToken(null);
+    this.setRefreshToken(null);
   }
   /**
    * Get the current authenticated customer's profile
@@ -1565,25 +3494,28 @@ var CustomerAuth = class {
     const params = new URLSearchParams();
     if (options?.page) params.set("page", String(options.page));
     if (options?.limit) params.set("limit", String(options.limit));
-    if (options?.displayFinancialStatus) {
-      params.set("displayFinancialStatus", options.displayFinancialStatus);
+    if (options?.financialStatus) {
+      params.set("financialStatus", options.financialStatus);
     }
-    if (options?.displayFulfillmentStatus) {
-      params.set("displayFulfillmentStatus", options.displayFulfillmentStatus);
+    if (options?.fulfillmentStatus) {
+      params.set("fulfillmentStatus", options.fulfillmentStatus);
     }
     if (options?.returnStatus) params.set("returnStatus", options.returnStatus);
+    if (options?.confirmationStatus) {
+      params.set("confirmationStatus", options.confirmationStatus);
+    }
     if (options?.primaryDisplayStatus) {
       params.set("primaryDisplayStatus", options.primaryDisplayStatus);
     }
-    if (options?.returnDisplayStatus) {
-      params.set("returnDisplayStatus", options.returnDisplayStatus);
-    }
-    if (options?.status) params.set("status", options.status);
     const qs = params.toString();
-    return this.requestJson(`/api/customers/me/orders${qs ? `?${qs}` : ""}`, {
-      method: "GET",
-      headers: { Authorization: `Bearer ${this.token}` }
-    });
+    const result = await this.requestJson(
+      `/api/customers/me/orders${qs ? `?${qs}` : ""}`,
+      {
+        method: "GET",
+        headers: { Authorization: `Bearer ${this.token}` }
+      }
+    );
+    return validatePublicOrderList(result);
   }
   /**
    * Get the current token (or null if not authenticated)
@@ -1591,6 +3523,12 @@ var CustomerAuth = class {
   getToken() {
     return this.token;
   }
+  /**
+   * Get the current refresh token (or null if unavailable)
+   */
+  getRefreshToken() {
+    return this.refreshTokenValue;
+  }
   /**
    * Set the token manually (e.g. from SSR)
    */
@@ -1598,6 +3536,13 @@ var CustomerAuth = class {
     this.token = token;
     this.onTokenChange?.(token);
   }
+  /**
+   * Set the refresh token manually (e.g. from SSR cookie)
+   */
+  setRefreshToken(refreshToken) {
+    this.refreshTokenValue = refreshToken;
+    this.onRefreshTokenChange?.(refreshToken);
+  }
   /**
    * Check if the customer is currently authenticated
    */
@@ -1626,91 +3571,358 @@ var CustomerAuth = class {
   }
 };
 
+// src/core/customer/customer-oauth.ts
+var DEFAULT_SCOPES = ["openid", "profile", "email"];
+var DEFAULT_TIMEOUT3 = 15e3;
+function issuerUrl(issuer, path) {
+  const base = resolveApiUrl(issuer);
+  return new URL(path, base.endsWith("/") ? base : `${base}/`).toString();
+}
+function randomBase64Url(bytes) {
+  const buffer = new Uint8Array(bytes);
+  crypto.getRandomValues(buffer);
+  let binary = "";
+  for (const value of buffer) {
+    binary += String.fromCharCode(value);
+  }
+  return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
+}
+async function sha256Base64Url(value) {
+  const data = new TextEncoder().encode(value);
+  const digest = await crypto.subtle.digest("SHA-256", data);
+  let binary = "";
+  for (const byte of new Uint8Array(digest)) {
+    binary += String.fromCharCode(byte);
+  }
+  return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
+}
+function normalizeToken(body) {
+  if (body.token_type !== "Bearer") {
+    throw new Error("Unsupported customer OAuth token type");
+  }
+  return {
+    accessToken: body.access_token,
+    expiresAt: Date.now() + body.expires_in * 1e3,
+    expiresIn: body.expires_in,
+    ...body.id_token ? { idToken: body.id_token } : {},
+    refreshToken: body.refresh_token,
+    ...body.scope ? { scope: body.scope } : {},
+    tokenType: "Bearer"
+  };
+}
+var CustomerOAuth = class {
+  constructor(config) {
+    if (!config.clientId) throw new Error("customer OAuth clientId is required");
+    if (!config.issuer) throw new Error("customer OAuth issuer is required");
+    this.clientId = config.clientId;
+    this.issuer = config.issuer;
+    this.timeout = config.timeout ?? DEFAULT_TIMEOUT3;
+  }
+  async createAuthorizationUrl(input) {
+    const codeVerifier = randomBase64Url(48);
+    const codeChallenge = await sha256Base64Url(codeVerifier);
+    const state = randomBase64Url(32);
+    const nonce = randomBase64Url(32);
+    const scopes = input.scopes ?? DEFAULT_SCOPES;
+    const url = new URL(issuerUrl(this.issuer, "customer-oauth/authorize"));
+    url.searchParams.set("response_type", "code");
+    url.searchParams.set("client_id", this.clientId);
+    url.searchParams.set("redirect_uri", input.redirectUri);
+    url.searchParams.set("scope", scopes.join(" "));
+    url.searchParams.set("state", state);
+    url.searchParams.set("nonce", nonce);
+    url.searchParams.set("code_challenge", codeChallenge);
+    url.searchParams.set("code_challenge_method", "S256");
+    return {
+      authorizationUrl: url.toString(),
+      codeChallenge,
+      codeVerifier,
+      nonce,
+      returnTo: input.returnTo ?? null,
+      state
+    };
+  }
+  parseCallback(callbackUrl, options) {
+    const url = new URL(callbackUrl);
+    const error = url.searchParams.get("error");
+    if (error) {
+      throw new Error(
+        url.searchParams.get("error_description") ?? `OAuth error: ${error}`
+      );
+    }
+    const code = url.searchParams.get("code");
+    const state = url.searchParams.get("state");
+    if (!code || !state) throw new Error("OAuth callback is missing code/state");
+    if (state !== options.expectedState) throw new Error("OAuth state mismatch");
+    return { code, state };
+  }
+  async exchangeCode(input) {
+    const body = new URLSearchParams({
+      client_id: this.clientId,
+      code: input.code,
+      code_verifier: input.codeVerifier,
+      grant_type: "authorization_code",
+      redirect_uri: input.redirectUri
+    });
+    return this.tokenRequest(body);
+  }
+  async refresh(input) {
+    const body = new URLSearchParams({
+      client_id: this.clientId,
+      grant_type: "refresh_token",
+      refresh_token: input.refreshToken
+    });
+    return this.tokenRequest(body);
+  }
+  async logout(input) {
+    const body = { client_id: this.clientId };
+    if (input.refreshToken) body.refresh_token = input.refreshToken;
+    if (input.postLogoutRedirectUri) {
+      body.post_logout_redirect_uri = input.postLogoutRedirectUri;
+    }
+    const response = await httpFetch("/customer-oauth/logout", {
+      apiUrl: this.issuer,
+      method: "POST",
+      body: JSON.stringify(body),
+      headers: { "Content-Type": "application/json" },
+      timeout: this.timeout,
+      retry: { maxRetries: 0 }
+    });
+    return parseApiResponse(
+      response,
+      "/customer-oauth/logout"
+    );
+  }
+  verifyIdToken() {
+    throw new Error(
+      "Customer OAuth ID token verification is not implemented; treat idToken as opaque."
+    );
+  }
+  async tokenRequest(body) {
+    const response = await httpFetch("/api/customer-oauth/token", {
+      apiUrl: this.issuer,
+      method: "POST",
+      body,
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded"
+      },
+      timeout: this.timeout,
+      retry: { maxRetries: 0 }
+    });
+    return normalizeToken(
+      await parseApiResponse(
+        response,
+        "/api/customer-oauth/token"
+      )
+    );
+  }
+};
+
 // src/core/customer/customer-namespace.ts
 var CustomerNamespace = class {
   constructor(publishableKey, options, apiUrl) {
     this.auth = new CustomerAuth(publishableKey, options, apiUrl);
+    if (options?.oauth) {
+      this.oauth = new CustomerOAuth(options.oauth);
+    }
   }
 };
 
+// src/core/api/commerce-idempotency.ts
+var UUID_V4_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+var PREFIXED_BASE64URL_PATTERN = /^ik_[A-Za-z0-9_-]{22}$/;
+function isCommerceIdempotencyKey(value) {
+  return typeof value === "string" && value.length <= 255 && (UUID_V4_PATTERN.test(value) || PREFIXED_BASE64URL_PATTERN.test(value));
+}
+function assertCommerceIdempotencyKey(value) {
+  if (isCommerceIdempotencyKey(value)) return;
+  throw createValidationError(
+    "idempotencyKey must be a UUIDv4 or ik_-prefixed 128-bit base64url value.",
+    { field: "idempotencyKey" }
+  );
+}
+
 // src/core/api/cart-api.ts
 var CartApi = class extends CustomerScopedApi {
   constructor(options) {
     super("CartApi", { ...options, requiresCredential: false });
+    this.serverTransport = Boolean(options.secretKey);
   }
-  async execute(endpoint, method, body) {
-    return this.request(endpoint, { method, body });
+  endpoint(key) {
+    return this.serverTransport ? COMMERCE_ENDPOINTS.carts.server[key] : COMMERCE_ENDPOINTS.carts[key];
   }
-  /**
-   * Create a cart and receive its `cartToken`. Store the token and pass it to
-   * every subsequent cart operation.
-   */
-  createCart(params = {}) {
-    return this.execute("/api/carts/create", "POST", params);
+  execute(endpoint2, body, idempotencyKey) {
+    return this.requestEndpoint(endpoint2, body, {
+      ...idempotencyKey && {
+        headers: { "X-Idempotency-Key": idempotencyKey }
+      }
+    });
   }
-  getCart(cartToken) {
-    return this.execute("/api/carts/get", "POST", { cartToken });
+  create(params = {}) {
+    return this.execute(this.endpoint("create"), params).then(
+      (value) => validateCreateCartResult(value)
+    );
   }
-  merge(params) {
-    return this.execute(
-      COMMERCE_ENDPOINTS.carts.merge,
-      "POST",
-      params
+  retrieve(params) {
+    return this.execute(this.endpoint("retrieve"), params).then(
+      (value) => validatePublicCart(value)
     );
   }
-  /**
-   * Resolve the authenticated customer's active cart by JWT (no `cartToken`
-   * required). Returns the cart and its capability handle, or both `null` when
-   * the customer has no active cart. Requires a customer token.
-   */
-  mine() {
-    return this.execute(
-      COMMERCE_ENDPOINTS.carts.mine,
-      "POST",
-      {}
+  mine(params = {}) {
+    const endpoint2 = this.endpoint("mine");
+    return this.execute(endpoint2, params).then(
+      (value) => validateCartMineResult(value)
+    );
+  }
+  merge(params) {
+    const { idempotencyKey, ...body } = params;
+    assertCommerceIdempotencyKey(idempotencyKey);
+    const endpoint2 = this.endpoint("merge");
+    return this.execute(endpoint2, body, idempotencyKey).then(
+      (value) => validateCartMergeResult(value)
     );
   }
   addItem(params) {
-    return this.execute(
-      COMMERCE_ENDPOINTS.carts.addItem,
-      "POST",
-      params
+    return this.mutate(this.endpoint("addItem"), params);
+  }
+  mutate(endpoint2, params) {
+    const { idempotencyKey, ...body } = params;
+    assertCommerceIdempotencyKey(idempotencyKey);
+    return this.execute(endpoint2, body, idempotencyKey).then(
+      (value) => validateCartMutationResult(value)
     );
   }
   updateItem(params) {
-    return this.execute(
-      COMMERCE_ENDPOINTS.carts.updateItem,
-      "POST",
-      params
-    );
+    return this.mutate(this.endpoint("updateItem"), params);
   }
   removeItem(params) {
-    return this.execute(
-      COMMERCE_ENDPOINTS.carts.removeItem,
-      "POST",
-      params
+    return this.mutate(this.endpoint("removeItem"), params);
+  }
+  clear(params) {
+    return this.mutate(this.endpoint("clear"), params);
+  }
+  updateDiscountCodes(params) {
+    return this.mutate(this.endpoint("updateDiscountCodes"), params);
+  }
+  updateAttributes(params) {
+    return this.mutate(this.endpoint("updateAttributes"), params);
+  }
+};
+
+// src/core/api/checkout-api.ts
+var CheckoutApi = class extends CustomerScopedApi {
+  constructor(options) {
+    super("CheckoutApi", { ...options, requiresCredential: false });
+  }
+  post(endpoint2, body, idempotencyKey) {
+    return this.requestEndpoint(endpoint2, body, {
+      ...idempotencyKey && {
+        headers: { "X-Idempotency-Key": idempotencyKey }
+      }
+    });
+  }
+  async publicCheckout(result) {
+    return validatePublicCheckout(await result);
+  }
+  async serverCheckout(result) {
+    return validateServerCheckout(await result);
+  }
+  async createResult(result) {
+    return validateCreateCheckoutResult(
+      await result,
+      false
     );
   }
-  applyDiscount(params) {
-    return this.execute(
-      COMMERCE_ENDPOINTS.carts.applyDiscount,
-      "POST",
-      params
+  async createServerResult(result) {
+    return validateCreateCheckoutResult(
+      await result,
+      true
     );
   }
-  removeDiscount(params) {
-    return this.execute(
-      COMMERCE_ENDPOINTS.carts.removeDiscount,
-      "POST",
-      params
+  create(params) {
+    const { idempotencyKey, ...body } = params;
+    assertCommerceIdempotencyKey(idempotencyKey);
+    return this.createResult(
+      this.post(COMMERCE_ENDPOINTS.checkouts.create, body, idempotencyKey)
     );
   }
-  clearCart(params) {
-    return this.execute(
-      COMMERCE_ENDPOINTS.carts.clear,
-      "POST",
+  createServer(params) {
+    const { idempotencyKey, ...body } = params;
+    assertCommerceIdempotencyKey(idempotencyKey);
+    return this.createServerResult(
+      this.post(
+        COMMERCE_ENDPOINTS.checkouts.server.create,
+        body,
+        idempotencyKey
+      )
+    );
+  }
+  retrieve(params) {
+    return this.publicCheckout(
+      this.post(COMMERCE_ENDPOINTS.checkouts.retrieve, params)
+    );
+  }
+  retrieveServer(params) {
+    return this.serverCheckout(
+      this.post(COMMERCE_ENDPOINTS.checkouts.server.retrieve, params)
+    );
+  }
+  async query(params = {}) {
+    const result = await this.post(
+      COMMERCE_ENDPOINTS.checkouts.server.query,
       params
     );
+    return validateCheckoutQueryResult(result);
+  }
+};
+
+// src/core/api/payment-session-api.ts
+var PaymentSessionApi = class extends CustomerScopedApi {
+  constructor(options) {
+    super("PaymentSessionApi", { ...options, requiresCredential: false });
+    this.serverTransport = Boolean(options.secretKey);
+  }
+  post(endpoint2, body, idempotencyKey) {
+    return this.requestEndpoint(endpoint2, body, {
+      ...idempotencyKey && {
+        headers: { "X-Idempotency-Key": idempotencyKey }
+      }
+    });
+  }
+  async paymentSession(result) {
+    return validatePublicPaymentSession(await result);
+  }
+  create(params) {
+    const { idempotencyKey, ...body } = params;
+    assertCommerceIdempotencyKey(idempotencyKey);
+    return this.paymentSession(
+      this.post(
+        this.serverTransport ? COMMERCE_ENDPOINTS.paymentSessions.server.create : COMMERCE_ENDPOINTS.paymentSessions.create,
+        body,
+        idempotencyKey
+      )
+    );
+  }
+  retrieve(params) {
+    const endpoint2 = this.serverTransport ? COMMERCE_ENDPOINTS.paymentSessions.server.retrieve : COMMERCE_ENDPOINTS.paymentSessions.retrieve;
+    return this.paymentSession(this.post(endpoint2, params));
+  }
+  cancel(params) {
+    const { idempotencyKey, ...body } = params;
+    assertCommerceIdempotencyKey(idempotencyKey);
+    const endpoint2 = this.serverTransport ? COMMERCE_ENDPOINTS.paymentSessions.server.cancel : COMMERCE_ENDPOINTS.paymentSessions.cancel;
+    return this.paymentSession(this.post(endpoint2, body, idempotencyKey));
+  }
+  confirm(params) {
+    const { idempotencyKey, ...body } = params;
+    assertCommerceIdempotencyKey(idempotencyKey);
+    return this.paymentSession(
+      this.post(
+        COMMERCE_ENDPOINTS.paymentSessions.server.confirm,
+        body,
+        idempotencyKey
+      )
+    );
   }
 };
 
@@ -2517,6 +4729,9 @@ function compareVariantOrder(a, b) {
 }
 function getVariantAvailableForSale(variant) {
   if (variant.isActive === false) return false;
+  if (typeof variant.availableForSale === "boolean") {
+    return variant.availableForSale;
+  }
   if (variant.isUnlimited) return true;
   if (variant.inventoryPolicy === "continue") return true;
   return (variant.stock ?? 0) - (variant.reservedStock ?? 0) > 0;
@@ -2626,7 +4841,7 @@ function buildProductListingCard(item, options = {}) {
       { listing: { selectionHintVariant } },
       options
     ),
-    title: product.title,
+    title: product.title ?? "",
     representativeVariant,
     primaryImage: listingPrimaryMedia,
     priceRange,
@@ -2754,6 +4969,11 @@ function productDetailResultFromError(error) {
   if (!reason) return void 0;
   return { found: false, reason };
 }
+var MARKET_PRICE_QUERY_UNSUPPORTED_MESSAGE = "Market listing pages do not support base price filters or price sorts.";
+var BASE_PRICE_RANGE_SORT_FIELDS = /* @__PURE__ */ new Set([
+  "priceRange.minVariantPrice.amount",
+  "priceRange.maxVariantPrice.amount"
+]);
 function nonEmpty(values) {
   return values?.length ? values : void 0;
 }
@@ -2801,14 +5021,34 @@ function buildProductListingPageWhere(params) {
   if (clauses.length === 1) return clauses[0];
   return { and: clauses };
 }
-function buildProductListingPageUrl(params) {
+function productListingPageUsesBasePriceSort(sort) {
+  const values = Array.isArray(sort) ? sort : sort ? [sort] : [];
+  return values.some(
+    (value) => BASE_PRICE_RANGE_SORT_FIELDS.has(String(value).replace(/^-/, ""))
+  );
+}
+function assertMarketListingPageQuerySupported(params) {
+  if (!params.market?.trim()) return;
+  const priceFilter = params.filters?.price;
+  if (priceFilter?.min != null || priceFilter?.max != null || productListingPageUsesBasePriceSort(params.sort)) {
+    throw new TypeError(MARKET_PRICE_QUERY_UNSUPPORTED_MESSAGE);
+  }
+}
+function buildProductListingPageRequest(params) {
+  assertMarketListingPageQuerySupported(params);
   const options = {
+    market: params.market,
+    locale: params.locale,
+    fallbackLocale: params.fallbackLocale,
     page: params.page,
     limit: params.limit,
     sort: params.sort,
     where: buildProductListingPageWhere(params)
   };
-  return params.mode === "full" ? listingGroupsQueryUrl(options) : listingGroupsQueryCatalogUrl(options);
+  return {
+    operation: params.mode === "full" ? COMMERCE_ENDPOINT_OPERATIONS.products.listingGroupsQueryGet : COMMERCE_ENDPOINT_OPERATIONS.products.listingGroupsQueryCatalog,
+    query: listingPageSearchParams(options)
+  };
 }
 function withProductListingCards(response, options) {
   return {
@@ -2817,30 +5057,15 @@ function withProductListingCards(response, options) {
   };
 }
 
-// src/core/api/order-api.ts
-function idempotencyRequestOptions(idempotencyKey) {
-  return idempotencyKey ? { headers: { "X-Idempotency-Key": idempotencyKey } } : void 0;
-}
-function splitIdempotencyKey(params) {
-  const { idempotencyKey, ...body } = params;
-  return { body, idempotencyKey };
-}
-
 // src/core/commerce/commerce-client.ts
 var BrowserCommerceApi = class extends CustomerScopedApi {
-  post(endpoint, body, requestOptions) {
-    return this.request(endpoint, {
-      method: "POST",
-      body,
-      headers: requestOptions?.headers
-    });
-  }
-  get(endpoint) {
-    return this.request(endpoint, { method: "GET" });
+  requestEndpoint(endpoint2, body, options) {
+    return super.requestEndpoint(endpoint2, body, options);
   }
 };
 var CommerceClient = class {
   constructor(options) {
+    this.market = options.market;
     const cartApi = new CartApi({
       publishableKey: options.publishableKey,
       apiUrl: options.apiUrl,
@@ -2848,6 +5073,20 @@ var CommerceClient = class {
       onUnauthorized: options.onUnauthorized,
       onRequestId: options.onRequestId
     });
+    const checkoutApi = new CheckoutApi({
+      publishableKey: options.publishableKey,
+      apiUrl: options.apiUrl,
+      customerToken: options.customerToken,
+      onUnauthorized: options.onUnauthorized,
+      onRequestId: options.onRequestId
+    });
+    const paymentSessionApi = new PaymentSessionApi({
+      publishableKey: options.publishableKey,
+      apiUrl: options.apiUrl,
+      customerToken: options.customerToken,
+      onUnauthorized: options.onUnauthorized,
+      onRequestId: options.onRequestId
+    });
     const api = new BrowserCommerceApi("CommerceClient", {
       publishableKey: options.publishableKey,
       apiUrl: options.apiUrl,
@@ -2856,29 +5095,42 @@ var CommerceClient = class {
       onRequestId: options.onRequestId
     });
     this.product = {
-      stockCheck: (params) => api.post(
-        COMMERCE_ENDPOINTS.products.stockCheck,
+      stockCheck: (params) => api.requestEndpoint(
+        COMMERCE_ENDPOINT_OPERATIONS.products.stockCheck,
         params
       ),
-      stockSnapshot: (params) => api.get(stockSnapshotQuery(params)),
-      listingGroups: (params) => api.get(
-        listingGroupsCatalogQuery(params)
+      stockSnapshot: (params) => api.requestEndpoint(
+        COMMERCE_ENDPOINT_OPERATIONS.products.stockSnapshot,
+        void 0,
+        { query: stockSnapshotSearchParams(params) }
+      ),
+      listingGroups: (params) => api.requestEndpoint(
+        COMMERCE_ENDPOINT_OPERATIONS.products.listingGroupsCatalog,
+        void 0,
+        { query: listingGroupsSearchParams(this.withMarket(params)) }
       ),
-      listingGroupsCatalog: (params) => api.get(
-        listingGroupsCatalogQuery(params)
+      listingGroupsCatalog: (params) => api.requestEndpoint(
+        COMMERCE_ENDPOINT_OPERATIONS.products.listingGroupsCatalog,
+        void 0,
+        { query: listingGroupsSearchParams(this.withMarket(params)) }
       ),
       listingPage: async (params = {}) => {
         const catalogParams = {
           ...params,
           mode: "catalog"
         };
-        const response = await api.get(buildProductListingPageUrl(catalogParams));
-        return withProductListingCards(response, catalogParams);
+        const request = buildProductListingPageRequest(
+          this.withMarket(catalogParams)
+        );
+        const response = await api.requestEndpoint(request.operation, void 0, { query: request.query });
+        return withProductListingCards(response, this.withMarket(catalogParams));
       },
       detail: async (params) => {
         try {
-          const product = await api.get(
-            productDetailQuery(params)
+          const product = await api.requestEndpoint(
+            COMMERCE_ENDPOINT_OPERATIONS.products.detailCatalog,
+            void 0,
+            { query: productDetailSearchParams(this.withMarket(params)) }
           );
           return { found: true, product };
         } catch (err) {
@@ -2889,8 +5141,10 @@ var CommerceClient = class {
       },
       detailCatalog: async (params) => {
         try {
-          const product = await api.get(
-            productDetailCatalogQuery(params)
+          const product = await api.requestEndpoint(
+            COMMERCE_ENDPOINT_OPERATIONS.products.detailCatalog,
+            void 0,
+            { query: productDetailSearchParams(this.withMarket(params)) }
           );
           return { found: true, product };
         } catch (err) {
@@ -2900,39 +5154,51 @@ var CommerceClient = class {
         }
       }
     };
-    this.cart = {
-      create: cartApi.createCart.bind(cartApi),
-      get: cartApi.getCart.bind(cartApi),
+    this.carts = {
+      create: (params) => cartApi.create(this.withMarket(params ?? {})),
+      retrieve: cartApi.retrieve.bind(cartApi),
       addItem: cartApi.addItem.bind(cartApi),
       updateItem: cartApi.updateItem.bind(cartApi),
       removeItem: cartApi.removeItem.bind(cartApi),
-      applyDiscount: cartApi.applyDiscount.bind(cartApi),
-      removeDiscount: cartApi.removeDiscount.bind(cartApi),
-      clear: cartApi.clearCart.bind(cartApi),
+      updateDiscountCodes: cartApi.updateDiscountCodes.bind(cartApi),
+      updateAttributes: cartApi.updateAttributes.bind(cartApi),
+      clear: cartApi.clear.bind(cartApi),
       merge: cartApi.merge.bind(cartApi),
       mine: cartApi.mine.bind(cartApi)
     };
     this.orders = {
-      checkout: (params) => {
-        const { body, idempotencyKey } = splitIdempotencyKey(params);
-        return api.post(
-          "/api/orders/checkout",
-          body,
-          idempotencyRequestOptions(idempotencyKey)
-        );
-      },
       listMine: (params) => options.customerAuth.getMyOrders(params)
     };
+    this.checkouts = {
+      create: checkoutApi.create.bind(checkoutApi),
+      retrieve: checkoutApi.retrieve.bind(checkoutApi)
+    };
+    this.paymentSessions = {
+      create: paymentSessionApi.create.bind(paymentSessionApi),
+      retrieve: (params) => paymentSessionApi.retrieve(params),
+      cancel: (params) => paymentSessionApi.cancel(params)
+    };
     this.discounts = {
-      validate: (params) => api.post("/api/discounts/validate", params)
+      validate: (params) => api.requestEndpoint(
+        COMMERCE_ENDPOINT_OPERATIONS.discounts.validate,
+        params
+      )
     };
     this.shipping = {
-      calculate: (params) => api.post(
-        "/api/shipping-policies/calculate",
+      calculate: (params) => api.requestEndpoint(
+        COMMERCE_ENDPOINT_OPERATIONS.shippingPolicies.calculate,
         params
       )
     };
   }
+  getDefaultMarket() {
+    return this.market;
+  }
+  withMarket(params) {
+    const defaultMarket = this.market?.trim();
+    if (!defaultMarket || params.market?.trim()) return params;
+    return { ...params, market: defaultMarket };
+  }
 };
 
 // src/core/events/events-client.ts
@@ -2952,7 +5218,17 @@ var EventsClient = class {
   getRange(params) {
     return this.execute(
       buildRangeEndpoint(params),
-      "GET",
+      resolveOperationMethod(EVENTS_ENDPOINT_OPERATIONS.occurrences.range),
+      void 0,
+      { useCustomerAuth: false }
+    );
+  }
+  getAdmissionAvailability(params) {
+    return this.execute(
+      buildAdmissionAvailabilityEndpoint(params),
+      resolveOperationMethod(
+        EVENTS_ENDPOINT_OPERATIONS.occurrences.admissionAvailability
+      ),
       void 0,
       { useCustomerAuth: false }
     );
@@ -2981,11 +5257,11 @@ var EventsClient = class {
       { useCustomerAuth: false }
     );
   }
-  async execute(endpoint, method, body, options = {}) {
+  async execute(endpoint2, method, body, options = {}) {
     const useCustomerAuth = options.useCustomerAuth === true;
     const token = useCustomerAuth ? typeof this.customerToken === "function" ? this.customerToken() : this.customerToken : void 0;
     try {
-      const response = await httpFetch(endpoint, {
+      const response = await httpFetch(endpoint2, {
         method,
         apiUrl: this.apiUrl,
         publishableKey: this.publishableKey,
@@ -2994,7 +5270,7 @@ var EventsClient = class {
         ...body !== void 0 && { body: JSON.stringify(body) }
       });
       this.onRequestId?.(response.headers.get("x-request-id") ?? null);
-      return parseApiResponse(response, endpoint);
+      return parseApiResponse(response, endpoint2);
     } catch (err) {
       const id = err instanceof SDKError ? err.requestId ?? null : null;
       this.onRequestId?.(id);
@@ -3033,7 +5309,17 @@ function buildRangeEndpoint(params) {
   appendValues(urlParams, "categorySlug", params.categorySlug);
   appendValues(urlParams, "tag", params.tag);
   appendValues(urlParams, "tagSlug", params.tagSlug);
-  return `/api/event-occurrences/range?${urlParams.toString()}`;
+  return resolveOperationPath(EVENTS_ENDPOINT_OPERATIONS.occurrences.range, {
+    query: urlParams
+  });
+}
+function buildAdmissionAvailabilityEndpoint(params) {
+  const urlParams = new URLSearchParams();
+  urlParams.set("occurrence", params.occurrence);
+  return resolveOperationPath(
+    EVENTS_ENDPOINT_OPERATIONS.occurrences.admissionAvailability,
+    { query: urlParams }
+  );
 }
 function formatDateParam(value) {
   return value instanceof Date ? value.toISOString() : value;
@@ -3046,15 +5332,62 @@ function appendValues(params, key, value) {
   }
 }
 
+// src/core/market/market-discovery.ts
+function toMarketDTO(row) {
+  return {
+    id: row.id,
+    handle: row.handle,
+    name: row.name,
+    countryCode: row.countryCode,
+    targetCountries: (row.targetCountries ?? []).map((c) => c.countryCode),
+    currency: row.currency,
+    isPrimary: row.isPrimary === true,
+    isActive: row.isActive === true
+  };
+}
+var MarketDiscovery = class {
+  constructor(read) {
+    this.read = read;
+  }
+  async list() {
+    const res = await this.read({
+      where: { isActive: { equals: true } },
+      limit: 100
+    });
+    if (res.hasNextPage) {
+      console.warn(
+        "[markets.list] more than 100 active markets; results truncated to 100."
+      );
+    }
+    return res.docs.map(toMarketDTO);
+  }
+  async default() {
+    const res = await this.read({
+      where: { isPrimary: { equals: true }, isActive: { equals: true } },
+      limit: 1
+    });
+    const row = res.docs[0];
+    return row ? toMarketDTO(row) : null;
+  }
+};
+
 // src/core/client/client.ts
 var BrowserMembershipApi = class extends CustomerScopedApi {
   me() {
-    return this.request(MEMBERSHIP_ENDPOINTS.me, {
-      method: "GET"
-    });
+    return this.requestEndpoint(
+      MEMBERSHIP_ENDPOINT_OPERATIONS.me
+    );
+  }
+  cancel(params) {
+    const { id, immediate } = params;
+    return this.requestEndpoint(
+      MEMBERSHIP_ENDPOINT_OPERATIONS.cancel,
+      immediate !== void 0 ? { immediate } : {},
+      { pathParams: { id } }
+    );
   }
 };
-var Client = class {
+var Client = class _Client {
   constructor(options) {
     this.lastRequestId = null;
     const publishableKey = options.publishableKey;
@@ -3086,6 +5419,7 @@ var Client = class {
     this.commerce = new CommerceClient({
       publishableKey: this.config.publishableKey,
       apiUrl: this.config.apiUrl,
+      market: this.config.market,
       customerToken: () => this.customer.auth.getToken(),
       onUnauthorized,
       onRequestId,
@@ -3118,6 +5452,9 @@ var Client = class {
       onRequestId,
       this.config.apiUrl
     );
+    this.markets = new MarketDiscovery(
+      (options2) => this.collections.from("markets").find(options2)
+    );
     const membershipApi = new BrowserMembershipApi("MembershipApi", {
       publishableKey: this.config.publishableKey,
       apiUrl: this.config.apiUrl,
@@ -3126,12 +5463,23 @@ var Client = class {
       onRequestId
     });
     this.memberships = {
-      me: membershipApi.me.bind(membershipApi)
+      me: membershipApi.me.bind(membershipApi),
+      cancel: membershipApi.cancel.bind(membershipApi)
     };
   }
   getState() {
     return { ...this.state };
   }
+  withMarket(market) {
+    return new _Client({
+      ...this.config,
+      customer: this.config.customer?.persist === false ? {
+        ...this.config.customer,
+        token: this.customer.auth.getToken() ?? void 0
+      } : this.config.customer,
+      market
+    });
+  }
   getConfig() {
     return { ...this.config };
   }