@01.software/sdk 0.12.1 → 0.14.0

package/dist/index.js

@@ -1,6 +1,206 @@
+// src/utils/types.ts
+var resolveRelation = (ref) => {
+  if (typeof ref === "string" || typeof ref === "number" || ref === null || ref === void 0)
+    return null;
+  return ref;
+};
+
+// src/core/metadata/index.ts
+function extractSeo(doc) {
+  const seo = doc.seo ?? {};
+  const og = seo.openGraph ?? {};
+  return {
+    title: seo.title ?? doc.title ?? null,
+    description: seo.description ?? null,
+    noIndex: seo.noIndex ?? null,
+    canonical: seo.canonical ?? null,
+    openGraph: {
+      title: og.title ?? null,
+      description: og.description ?? null,
+      image: og.image ?? null
+    }
+  };
+}
+function generateMetadata(input, options) {
+  const title = input.title ?? void 0;
+  const description = input.description ?? void 0;
+  const ogTitle = input.openGraph?.title ?? title;
+  const ogDescription = input.openGraph?.description ?? description;
+  const image = resolveMetaImage(input.openGraph?.image);
+  return {
+    title,
+    description,
+    ...input.noIndex && { robots: { index: false, follow: false } },
+    ...input.canonical && { alternates: { canonical: input.canonical } },
+    openGraph: {
+      ...ogTitle && { title: ogTitle },
+      ...ogDescription && { description: ogDescription },
+      ...options?.siteName && { siteName: options.siteName },
+      ...image && { images: [image] }
+    },
+    twitter: {
+      card: image ? "summary_large_image" : "summary",
+      ...ogTitle && { title: ogTitle },
+      ...ogDescription && { description: ogDescription },
+      ...image && { images: [image.url] }
+    }
+  };
+}
+function resolveMetaImage(ref) {
+  const image = resolveRelation(ref);
+  if (!image) return null;
+  const sized = image.sizes?.["1536"];
+  const url = sized?.url || image.url;
+  if (!url) return null;
+  const width = sized?.url ? sized.width : image.width;
+  const height = sized?.url ? sized.height : image.height;
+  return {
+    url,
+    ...width && { width },
+    ...height && { height },
+    ...image.alt && { alt: image.alt }
+  };
+}
+
+// src/core/collection/query-builder.ts
+var CollectionQueryBuilder = class {
+  constructor(api, collection) {
+    this.api = api;
+    this.collection = collection;
+  }
+  /**
+   * Find documents (list query)
+   * GET /api/{collection}
+   * @returns Payload CMS find response with docs array and pagination
+   */
+  async find(options) {
+    return this.api.requestFind(
+      `/api/${String(this.collection)}`,
+      options
+    );
+  }
+  /**
+   * Find document by ID
+   * GET /api/{collection}/{id}
+   * @returns Document object directly (no wrapper)
+   */
+  async findById(id, options) {
+    return this.api.requestFindById(
+      `/api/${String(this.collection)}/${String(id)}`,
+      options
+    );
+  }
+  /**
+   * Create a new document
+   * POST /api/{collection}
+   * @returns Payload CMS mutation response with doc and message
+   */
+  async create(data, options) {
+    const endpoint = `/api/${String(this.collection)}`;
+    if (options?.file) {
+      return this.api.requestCreateWithFile(
+        endpoint,
+        data,
+        options.file,
+        options.filename
+      );
+    }
+    return this.api.requestCreate(endpoint, data);
+  }
+  /**
+   * Update a document by ID
+   * PATCH /api/{collection}/{id}
+   * @returns Payload CMS mutation response with doc and message
+   */
+  async update(id, data, options) {
+    const endpoint = `/api/${String(this.collection)}/${String(id)}`;
+    if (options?.file) {
+      return this.api.requestUpdateWithFile(
+        endpoint,
+        data,
+        options.file,
+        options.filename
+      );
+    }
+    return this.api.requestUpdate(endpoint, data);
+  }
+  /**
+   * Count documents
+   * GET /api/{collection}/count
+   * @returns Count response with totalDocs
+   */
+  async count(options) {
+    return this.api.requestCount(
+      `/api/${String(this.collection)}/count`,
+      options
+    );
+  }
+  /**
+   * Find first matching document and return its Next.js Metadata.
+   * Applies depth: 1 (SEO image populate) and limit: 1 automatically.
+   * @returns Metadata or null if no document matches
+   */
+  async findMetadata(options, metadataOptions) {
+    const { docs } = await this.find({ ...options, limit: 1, depth: 1 });
+    const doc = docs[0];
+    if (!doc) return null;
+    return generateMetadata(
+      extractSeo(doc),
+      metadataOptions
+    );
+  }
+  /**
+   * Find document by ID and return its Next.js Metadata.
+   * Applies depth: 1 (SEO image populate) automatically.
+   * @returns Metadata (throws on 404)
+   */
+  async findMetadataById(id, metadataOptions) {
+    const doc = await this.findById(id, { depth: 1 });
+    return generateMetadata(
+      extractSeo(doc),
+      metadataOptions
+    );
+  }
+  /**
+   * Update multiple documents (bulk update)
+   * PATCH /api/{collection}
+   * @returns Payload CMS find response with updated docs
+   */
+  async updateMany(where, data) {
+    return this.api.requestUpdateMany(
+      `/api/${String(this.collection)}`,
+      { where, data }
+    );
+  }
+  /**
+   * Delete a document by ID
+   * DELETE /api/{collection}/{id}
+   * @returns Deleted document object directly (no wrapper)
+   */
+  async remove(id) {
+    return this.api.requestDelete(
+      `/api/${String(this.collection)}/${String(id)}`
+    );
+  }
+  /**
+   * Delete multiple documents (bulk delete)
+   * DELETE /api/{collection}
+   * @returns Payload CMS find response with deleted docs
+   */
+  async removeMany(where) {
+    return this.api.requestDeleteMany(
+      `/api/${String(this.collection)}`,
+      { where }
+    );
+  }
+};
+
+// src/core/collection/http-client.ts
+import { stringify } from "qs-esm";
+
 // src/core/internal/errors/index.ts
 var SDKError = class extends Error {
-  constructor(code, message, status, details, userMessage, suggestion) {
+  constructor(code, message, status, details, userMessage, suggestion, requestId) {
     super(message);
     this.name = "SDKError";
     this.code = code;
@@ -8,6 +208,7 @@ var SDKError = class extends Error {
     this.details = details;
     this.userMessage = userMessage;
     this.suggestion = suggestion;
+    this.requestId = requestId;
     if (Error.captureStackTrace) {
       Error.captureStackTrace(this, new.target);
     }
@@ -23,7 +224,8 @@ var SDKError = class extends Error {
       status: this.status,
       details: this.details,
       userMessage: this.userMessage,
-      suggestion: this.suggestion
+      suggestion: this.suggestion,
+      ...this.requestId !== void 0 && { requestId: this.requestId }
     };
   }
 };
@@ -90,6 +292,37 @@ var UsageLimitError = class extends SDKError {
     };
   }
 };
+var AuthError = class extends SDKError {
+  constructor(message, details, userMessage, suggestion, requestId) {
+    super("auth_error", message, 401, details, userMessage, suggestion, requestId);
+    this.name = "AuthError";
+  }
+};
+var PermissionError = class extends SDKError {
+  constructor(message, details, userMessage, suggestion, requestId) {
+    super("permission_error", message, 403, details, userMessage, suggestion, requestId);
+    this.name = "PermissionError";
+  }
+};
+var NotFoundError = class extends SDKError {
+  constructor(message, details, userMessage, suggestion, requestId) {
+    super("not_found", message, 404, details, userMessage, suggestion, requestId);
+    this.name = "NotFoundError";
+  }
+};
+var ConflictError = class extends SDKError {
+  constructor(message, details, userMessage, suggestion, requestId) {
+    super("conflict", message, 409, details, userMessage, suggestion, requestId);
+    this.name = "ConflictError";
+  }
+};
+var RateLimitError = class extends SDKError {
+  constructor(message, retryAfter, details, userMessage, suggestion, requestId) {
+    super("rate_limit_exceeded", message, 429, details, userMessage, suggestion, requestId);
+    this.name = "RateLimitError";
+    this.retryAfter = retryAfter;
+  }
+};
 function isSDKError(error) {
   return error instanceof SDKError;
 }
@@ -117,11 +350,32 @@ function isServiceUnavailableError(error) {
 function isUsageLimitError(error) {
   return error instanceof UsageLimitError;
 }
+function isAuthError(error) {
+  return error instanceof AuthError;
+}
+function isPermissionError(error) {
+  return error instanceof PermissionError;
+}
+function isNotFoundError(error) {
+  return error instanceof NotFoundError;
+}
+function isConflictError(error) {
+  return error instanceof ConflictError;
+}
+function isRateLimitError(error) {
+  return error instanceof RateLimitError;
+}
 var createNetworkError = (message, status, details, userMessage, suggestion) => new NetworkError(message, status, details, userMessage, suggestion);
+var createValidationError = (message, details, userMessage, suggestion) => new ValidationError(message, details, userMessage, suggestion);
 var createApiError = (message, status, details, userMessage, suggestion) => new ApiError(message, status, details, userMessage, suggestion);
 var createConfigError = (message, details, userMessage, suggestion) => new ConfigError(message, details, userMessage, suggestion);
 var createTimeoutError = (message, details, userMessage, suggestion) => new TimeoutError(message, details, userMessage, suggestion);
 var createUsageLimitError = (message, usage, details, userMessage, suggestion) => new UsageLimitError(message, usage, details, userMessage, suggestion);
+var createAuthError = (message, details, userMessage, suggestion, requestId) => new AuthError(message, details, userMessage, suggestion, requestId);
+var createPermissionError = (message, details, userMessage, suggestion, requestId) => new PermissionError(message, details, userMessage, suggestion, requestId);
+var createNotFoundError = (message, details, userMessage, suggestion, requestId) => new NotFoundError(message, details, userMessage, suggestion, requestId);
+var createConflictError = (message, details, userMessage, suggestion, requestId) => new ConflictError(message, details, userMessage, suggestion, requestId);
+var createRateLimitError = (message, retryAfter, details, userMessage, suggestion, requestId) => new RateLimitError(message, retryAfter, details, userMessage, suggestion, requestId);
 
 // src/core/client/types.ts
 function resolveApiUrl() {
@@ -164,6 +418,7 @@ async function parseErrorBody(response) {
   };
   try {
     const body = await response.json();
+    const reason = typeof body.reason === "string" ? body.reason : void 0;
     if (body.errors && Array.isArray(body.errors)) {
       const fieldErrors = [];
       for (const e of body.errors) {
@@ -185,6 +440,7 @@ async function parseErrorBody(response) {
         return {
           errorMessage: `HTTP ${response.status}: ${details}`,
           userMessage: details,
+          reason,
           errors: fieldErrors.length > 0 ? fieldErrors : body.errors
         };
       }
@@ -192,16 +448,18 @@ async function parseErrorBody(response) {
     if (typeof body.error === "string") {
       return {
         errorMessage: `HTTP ${response.status}: ${body.error}`,
-        userMessage: body.error
+        userMessage: body.error,
+        reason
       };
     }
     if (body.message) {
       return {
         errorMessage: `HTTP ${response.status}: ${body.message}`,
-        userMessage: body.message
+        userMessage: body.message,
+        reason
       };
     }
-    return fallback;
+    return { ...fallback, reason };
   } catch {
     return fallback;
   }
@@ -209,11 +467,16 @@ async function parseErrorBody(response) {
 async function delay(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
+function attachRequestId(err, id) {
+  if (id) err.requestId = id;
+  return err;
+}
 async function httpFetch(url, options) {
   const {
     publishableKey,
     secretKey,
     customerToken,
+    tenantId,
     timeout = DEFAULT_TIMEOUT,
     debug,
     retry,
@@ -243,6 +506,9 @@ async function httpFetch(url, options) {
       if (authToken) {
         headers.set("Authorization", `Bearer ${authToken}`);
       }
+      if (tenantId) {
+        headers.set("X-Tenant-Id", tenantId);
+      }
       if (!headers.has("Content-Type") && requestInit.body && !(requestInit.body instanceof FormData)) {
         headers.set("Content-Type", "application/json");
       }
@@ -264,6 +530,7 @@ async function httpFetch(url, options) {
         signal: controller.signal
       });
       clearTimeout(timeoutId);
+      const requestId = response.headers.get("x-request-id") ?? void 0;
       debugLog(debug, "response", url, {
         status: response.status,
         statusText: response.statusText,
@@ -283,15 +550,19 @@ async function httpFetch(url, options) {
             response.headers.get("X-Usage-Remaining") || "0",
             10
           );
-          throw createUsageLimitError(
-            `Monthly API usage limit exceeded (${current.toLocaleString()}/${limit.toLocaleString()})`,
-            { limit, current, remaining },
-            { url, method: requestInit.method || "GET", attempt: attempt + 1 },
-            "Monthly API call limit exceeded. Please upgrade your plan.",
-            "Upgrade your tenant plan to increase the monthly API call limit."
+          throw attachRequestId(
+            createUsageLimitError(
+              `Monthly API usage limit exceeded (${current.toLocaleString()}/${limit.toLocaleString()})`,
+              { limit, current, remaining },
+              { url, method: requestInit.method || "GET", attempt: attempt + 1 },
+              "Monthly API call limit exceeded. Please upgrade your plan.",
+              "Upgrade your tenant plan to increase the monthly API call limit."
+            ),
+            requestId
           );
         }
-        if (response.status === 401 && onUnauthorized && customerToken && !hasRetried401) {
+        const parsed = await parseErrorBody(response);
+        if (response.status === 401 && onUnauthorized && customerToken && !hasRetried401 && parsed.reason === "token_expired") {
           hasRetried401 = true;
           try {
             const newToken = await onUnauthorized();
@@ -302,29 +573,32 @@ async function httpFetch(url, options) {
           } catch {
           }
         }
+        const details = {
+          url,
+          method: requestInit.method || "GET",
+          attempt: attempt + 1
+        };
         if (NON_RETRYABLE_STATUSES.includes(response.status)) {
-          const parsed2 = await parseErrorBody(response);
-          const details = {
-            url,
-            method: requestInit.method || "GET",
-            attempt: attempt + 1,
-            ...parsed2.errors && { errors: parsed2.errors }
-          };
-          throw createNetworkError(
-            parsed2.errorMessage,
+          throw attachRequestId(
+            createNetworkError(
+              parsed.errorMessage,
+              response.status,
+              { ...details, ...parsed.errors && { errors: parsed.errors } },
+              parsed.userMessage,
+              getErrorSuggestion(response.status)
+            ),
+            requestId
+          );
+        }
+        const error = attachRequestId(
+          createNetworkError(
+            parsed.errorMessage,
             response.status,
             details,
-            parsed2.userMessage,
+            parsed.userMessage,
             getErrorSuggestion(response.status)
-          );
-        }
-        const parsed = await parseErrorBody(response);
-        const error = createNetworkError(
-          parsed.errorMessage,
-          response.status,
-          { url, method: requestInit.method || "GET", attempt: attempt + 1 },
-          parsed.userMessage,
-          getErrorSuggestion(response.status)
+          ),
+          requestId
         );
         const method = (requestInit.method || "GET").toUpperCase();
         if (attempt < retryConfig.maxRetries && SAFE_METHODS.includes(method) && retryConfig.retryableStatuses.includes(response.status)) {
@@ -399,390 +673,24 @@ async function httpFetch(url, options) {
   throw lastError ?? new NetworkError("Request failed after retries");
 }
 
-// src/core/api/parse-response.ts
-async function parseApiResponse(response, endpoint) {
-  let data;
-  try {
-    data = await response.json();
-  } catch {
-    throw createApiError(
-      `Invalid JSON response from ${endpoint}`,
-      response.status,
-      void 0,
-      "Server returned an invalid response.",
-      "Check if the API endpoint is available."
-    );
-  }
-  if (data.error) {
-    const errorMessage = typeof data.error === "string" ? data.error : "Unknown API error";
-    throw createApiError(
-      errorMessage,
-      response.status,
-      data,
-      errorMessage,
-      "An error occurred while processing the request."
-    );
-  }
-  return data;
-}
-
-// src/core/api/base-api.ts
-var BaseApi = class {
-  constructor(apiName, options) {
-    if (!options.secretKey) {
-      throw createConfigError(`secretKey is required for ${apiName}.`);
-    }
-    this.publishableKey = options.publishableKey ?? "";
-    this.secretKey = options.secretKey;
-  }
-  async request(endpoint, body, options) {
-    const method = options?.method ?? "POST";
-    const response = await httpFetch(endpoint, {
-      method,
-      publishableKey: this.publishableKey,
-      secretKey: this.secretKey,
-      ...body !== void 0 && { body: JSON.stringify(body) },
-      ...options?.headers && { headers: options.headers }
-    });
-    return parseApiResponse(response, endpoint);
-  }
-};
-
-// src/core/api/order-api.ts
-var OrderApi = class extends BaseApi {
-  constructor(options) {
-    super("OrderApi", options);
-  }
-  createOrder(params) {
-    return this.request("/api/orders/create", params);
-  }
-  updateOrder(params) {
-    return this.request("/api/orders/update", params);
-  }
-  getOrder(params) {
-    return this.request("/api/orders/get", params);
-  }
-  updateTransaction(params) {
-    return this.request("/api/transactions/update", params);
-  }
-  checkout(params) {
-    return this.request("/api/orders/checkout", params);
-  }
-  createFulfillment(params) {
-    return this.request("/api/orders/create-fulfillment", params);
-  }
-  updateFulfillment(params) {
-    return this.request("/api/orders/update-fulfillment", params);
-  }
-  returnWithRefund(params) {
-    return this.request(
-      "/api/returns/return-refund",
-      params
-    );
-  }
-  createReturn(params) {
-    return this.request("/api/returns/create", params);
-  }
-  updateReturn(params) {
-    return this.request("/api/returns/update", params);
-  }
-  validateDiscount(params) {
-    return this.request(
-      "/api/discounts/validate",
-      params
-    );
-  }
-  calculateShipping(params) {
-    return this.request(
-      "/api/shipping-policies/calculate",
-      params
-    );
-  }
-};
-
-// src/core/api/cart-api.ts
-var CartApi = class {
-  constructor(options) {
-    if (!options.secretKey && !options.customerToken) {
-      throw createConfigError(
-        "Either secretKey or customerToken is required for CartApi."
-      );
-    }
-    this.publishableKey = options.publishableKey ?? "";
-    this.secretKey = options.secretKey;
-    this.customerToken = options.customerToken;
-    this.onUnauthorized = options.onUnauthorized;
-  }
-  async execute(endpoint, method, body) {
-    const token = typeof this.customerToken === "function" ? this.customerToken() : this.customerToken;
-    const response = await httpFetch(endpoint, {
-      method,
-      publishableKey: this.publishableKey,
-      secretKey: this.secretKey,
-      customerToken: token ?? void 0,
-      ...token && this.onUnauthorized && { onUnauthorized: this.onUnauthorized },
-      ...body !== void 0 && { body: JSON.stringify(body) }
-    });
-    return parseApiResponse(response, endpoint);
-  }
-  getCart(cartId) {
-    return this.execute(`/api/carts/${cartId}`, "GET");
-  }
-  addItem(params) {
-    return this.execute("/api/carts/add-item", "POST", params);
-  }
-  updateItem(params) {
-    return this.execute("/api/carts/update-item", "POST", params);
-  }
-  removeItem(params) {
-    return this.execute(
-      "/api/carts/remove-item",
-      "POST",
-      params
-    );
-  }
-  applyDiscount(params) {
-    return this.execute("/api/carts/apply-discount", "POST", params);
-  }
-  removeDiscount(params) {
-    return this.execute("/api/carts/remove-discount", "POST", params);
-  }
-  clearCart(params) {
-    return this.execute(
-      "/api/carts/clear",
-      "POST",
-      params
-    );
-  }
-};
-
-// src/core/api/product-api.ts
-var ProductApi = class extends BaseApi {
-  constructor(options) {
-    super("ProductApi", options);
-  }
-  stockCheck(params) {
-    return this.request("/api/products/stock-check", params);
-  }
-  listingGroups(params) {
-    return this.request(
-      "/api/products/listing-groups",
-      params
-    );
-  }
-};
-
-// src/utils/types.ts
-var resolveRelation = (ref) => {
-  if (typeof ref === "string" || typeof ref === "number" || ref === null || ref === void 0)
-    return null;
-  return ref;
-};
-
-// src/core/metadata/index.ts
-function extractSeo(doc) {
-  const seo = doc.seo ?? {};
-  const og = seo.openGraph ?? {};
-  return {
-    title: seo.title ?? doc.title ?? null,
-    description: seo.description ?? null,
-    noIndex: seo.noIndex ?? null,
-    canonical: seo.canonical ?? null,
-    openGraph: {
-      title: og.title ?? null,
-      description: og.description ?? null,
-      image: og.image ?? null
-    }
-  };
-}
-function generateMetadata(input, options) {
-  const title = input.title ?? void 0;
-  const description = input.description ?? void 0;
-  const ogTitle = input.openGraph?.title ?? title;
-  const ogDescription = input.openGraph?.description ?? description;
-  const image = resolveMetaImage(input.openGraph?.image);
-  return {
-    title,
-    description,
-    ...input.noIndex && { robots: { index: false, follow: false } },
-    ...input.canonical && { alternates: { canonical: input.canonical } },
-    openGraph: {
-      ...ogTitle && { title: ogTitle },
-      ...ogDescription && { description: ogDescription },
-      ...options?.siteName && { siteName: options.siteName },
-      ...image && { images: [image] }
-    },
-    twitter: {
-      card: image ? "summary_large_image" : "summary",
-      ...ogTitle && { title: ogTitle },
-      ...ogDescription && { description: ogDescription },
-      ...image && { images: [image.url] }
-    }
-  };
-}
-function resolveMetaImage(ref) {
-  const image = resolveRelation(ref);
-  if (!image) return null;
-  const sized = image.sizes?.["1536"];
-  const url = sized?.url || image.url;
-  if (!url) return null;
-  const width = sized?.url ? sized.width : image.width;
-  const height = sized?.url ? sized.height : image.height;
-  return {
-    url,
-    ...width && { width },
-    ...height && { height },
-    ...image.alt && { alt: image.alt }
-  };
-}
-
-// src/core/collection/query-builder.ts
-var CollectionQueryBuilder = class {
-  constructor(api, collection) {
-    this.api = api;
-    this.collection = collection;
-  }
-  /**
-   * Find documents (list query)
-   * GET /api/{collection}
-   * @returns Payload CMS find response with docs array and pagination
-   */
-  async find(options) {
-    return this.api.requestFind(
-      `/api/${String(this.collection)}`,
-      options
-    );
-  }
-  /**
-   * Find document by ID
-   * GET /api/{collection}/{id}
-   * @returns Document object directly (no wrapper)
-   */
-  async findById(id, options) {
-    return this.api.requestFindById(
-      `/api/${String(this.collection)}/${String(id)}`,
-      options
-    );
-  }
-  /**
-   * Create a new document
-   * POST /api/{collection}
-   * @returns Payload CMS mutation response with doc and message
-   */
-  async create(data, options) {
-    const endpoint = `/api/${String(this.collection)}`;
-    if (options?.file) {
-      return this.api.requestCreateWithFile(
-        endpoint,
-        data,
-        options.file,
-        options.filename
-      );
-    }
-    return this.api.requestCreate(endpoint, data);
-  }
-  /**
-   * Update a document by ID
-   * PATCH /api/{collection}/{id}
-   * @returns Payload CMS mutation response with doc and message
-   */
-  async update(id, data, options) {
-    const endpoint = `/api/${String(this.collection)}/${String(id)}`;
-    if (options?.file) {
-      return this.api.requestUpdateWithFile(
-        endpoint,
-        data,
-        options.file,
-        options.filename
-      );
-    }
-    return this.api.requestUpdate(endpoint, data);
-  }
-  /**
-   * Count documents
-   * GET /api/{collection}/count
-   * @returns Count response with totalDocs
-   */
-  async count(options) {
-    return this.api.requestCount(
-      `/api/${String(this.collection)}/count`,
-      options
-    );
-  }
-  /**
-   * Find first matching document and return its Next.js Metadata.
-   * Applies depth: 1 (SEO image populate) and limit: 1 automatically.
-   * @returns Metadata or null if no document matches
-   */
-  async findMetadata(options, metadataOptions) {
-    const { docs } = await this.find({ ...options, limit: 1, depth: 1 });
-    const doc = docs[0];
-    if (!doc) return null;
-    return generateMetadata(
-      extractSeo(doc),
-      metadataOptions
-    );
-  }
-  /**
-   * Find document by ID and return its Next.js Metadata.
-   * Applies depth: 1 (SEO image populate) automatically.
-   * @returns Metadata (throws on 404)
-   */
-  async findMetadataById(id, metadataOptions) {
-    const doc = await this.findById(id, { depth: 1 });
-    return generateMetadata(
-      extractSeo(doc),
-      metadataOptions
-    );
-  }
-  /**
-   * Update multiple documents (bulk update)
-   * PATCH /api/{collection}
-   * @returns Payload CMS find response with updated docs
-   */
-  async updateMany(where, data) {
-    return this.api.requestUpdateMany(
-      `/api/${String(this.collection)}`,
-      { where, data }
-    );
-  }
-  /**
-   * Delete a document by ID
-   * DELETE /api/{collection}/{id}
-   * @returns Deleted document object directly (no wrapper)
-   */
-  async remove(id) {
-    return this.api.requestDelete(
-      `/api/${String(this.collection)}/${String(id)}`
-    );
-  }
-  /**
-   * Delete multiple documents (bulk delete)
-   * DELETE /api/{collection}
-   * @returns Payload CMS find response with deleted docs
-   */
-  async removeMany(where) {
-    return this.api.requestDeleteMany(
-      `/api/${String(this.collection)}`,
-      { where }
-    );
-  }
-};
-
-// src/core/collection/http-client.ts
-import { stringify } from "qs-esm";
-var HttpClient = class {
-  constructor(publishableKey, secretKey, getCustomerToken, onUnauthorized) {
-    this.publishableKey = publishableKey;
-    this.secretKey = secretKey;
-    this.getCustomerToken = getCustomerToken;
-    this.onUnauthorized = onUnauthorized;
+// src/core/collection/http-client.ts
+var HttpClient = class {
+  constructor(publishableKey, secretKey, getCustomerToken, onUnauthorized, onRequestId, tenantId) {
+    this.publishableKey = publishableKey;
+    this.secretKey = secretKey;
+    this.tenantId = tenantId;
+    this.getCustomerToken = getCustomerToken;
+    this.onUnauthorized = onUnauthorized;
+    this.onRequestId = onRequestId;
   }
   get defaultOptions() {
     const opts = {
       publishableKey: this.publishableKey,
       secretKey: this.secretKey
     };
+    if (this.secretKey?.startsWith("pat01_") && this.tenantId) {
+      opts.tenantId = this.tenantId;
+    }
     const token = this.getCustomerToken?.();
     if (token) {
       opts.customerToken = token;
@@ -792,6 +700,17 @@ var HttpClient = class {
     }
     return opts;
   }
+  async fetchWithTracking(url, opts) {
+    try {
+      const response = await httpFetch(url, opts);
+      this.onRequestId?.(response.headers.get("x-request-id") ?? null);
+      return response;
+    } catch (err) {
+      const id = err instanceof SDKError ? err.requestId ?? null : null;
+      this.onRequestId?.(id);
+      throw err;
+    }
+  }
   buildUrl(endpoint, options) {
     if (!options) return endpoint;
     const queryString = stringify(options, { addQueryPrefix: true });
@@ -908,7 +827,7 @@ var CollectionClient = class extends HttpClient {
    */
   async requestFind(endpoint, options) {
     const url = this.buildUrl(endpoint, options);
-    const response = await httpFetch(url, {
+    const response = await this.fetchWithTracking(url, {
       ...this.defaultOptions,
       method: "GET"
     });
@@ -919,7 +838,7 @@ var CollectionClient = class extends HttpClient {
    * POST /api/...custom-endpoint
    */
   async requestFindEndpoint(endpoint, data) {
-    const response = await httpFetch(endpoint, {
+    const response = await this.fetchWithTracking(endpoint, {
       ...this.defaultOptions,
       method: "POST",
       body: data ? JSON.stringify(data) : void 0
@@ -932,7 +851,7 @@ var CollectionClient = class extends HttpClient {
    */
   async requestFindById(endpoint, options) {
     const url = this.buildUrl(endpoint, options);
-    const response = await httpFetch(url, {
+    const response = await this.fetchWithTracking(url, {
       ...this.defaultOptions,
       method: "GET"
     });
@@ -943,7 +862,7 @@ var CollectionClient = class extends HttpClient {
    * POST /api/{collection}
    */
   async requestCreate(endpoint, data) {
-    const response = await httpFetch(endpoint, {
+    const response = await this.fetchWithTracking(endpoint, {
       ...this.defaultOptions,
       method: "POST",
       body: data ? JSON.stringify(data) : void 0
@@ -955,7 +874,7 @@ var CollectionClient = class extends HttpClient {
    * PATCH /api/{collection}/{id}
    */
   async requestUpdate(endpoint, data) {
-    const response = await httpFetch(endpoint, {
+    const response = await this.fetchWithTracking(endpoint, {
       ...this.defaultOptions,
       method: "PATCH",
       body: data ? JSON.stringify(data) : void 0
@@ -968,7 +887,7 @@ var CollectionClient = class extends HttpClient {
    */
   async requestCount(endpoint, options) {
     const url = this.buildUrl(endpoint, options);
-    const response = await httpFetch(url, {
+    const response = await this.fetchWithTracking(url, {
       ...this.defaultOptions,
       method: "GET"
     });
@@ -979,7 +898,7 @@ var CollectionClient = class extends HttpClient {
    * PATCH /api/{collection}
    */
   async requestUpdateMany(endpoint, data) {
-    const response = await httpFetch(endpoint, {
+    const response = await this.fetchWithTracking(endpoint, {
       ...this.defaultOptions,
       method: "PATCH",
       body: JSON.stringify(data)
@@ -991,7 +910,7 @@ var CollectionClient = class extends HttpClient {
    * DELETE /api/{collection}/{id}
    */
   async requestDelete(endpoint) {
-    const response = await httpFetch(endpoint, {
+    const response = await this.fetchWithTracking(endpoint, {
       ...this.defaultOptions,
       method: "DELETE"
     });
@@ -1002,7 +921,7 @@ var CollectionClient = class extends HttpClient {
    * DELETE /api/{collection}
    */
   async requestDeleteMany(endpoint, data) {
-    const response = await httpFetch(endpoint, {
+    const response = await this.fetchWithTracking(endpoint, {
       ...this.defaultOptions,
       method: "DELETE",
       body: JSON.stringify(data)
@@ -1014,7 +933,7 @@ var CollectionClient = class extends HttpClient {
    * POST /api/{collection} (multipart/form-data)
    */
   async requestCreateWithFile(endpoint, data, file, filename) {
-    const response = await httpFetch(endpoint, {
+    const response = await this.fetchWithTracking(endpoint, {
       ...this.defaultOptions,
       method: "POST",
       body: buildPayloadFormData(data, file, filename)
@@ -1026,7 +945,7 @@ var CollectionClient = class extends HttpClient {
    * PATCH /api/{collection}/{id} (multipart/form-data)
    */
   async requestUpdateWithFile(endpoint, data, file, filename) {
-    const response = await httpFetch(endpoint, {
+    const response = await this.fetchWithTracking(endpoint, {
       ...this.defaultOptions,
       method: "PATCH",
       body: buildPayloadFormData(data, file, filename)
@@ -1106,49 +1025,101 @@ var COLLECTIONS = [
   "community-bans"
 ];
 
+// src/core/api/parse-response.ts
+async function parseApiResponse(response, endpoint) {
+  let data;
+  try {
+    data = await response.json();
+  } catch {
+    throw createApiError(
+      `Invalid JSON response from ${endpoint}`,
+      response.status,
+      void 0,
+      "Server returned an invalid response.",
+      "Check if the API endpoint is available."
+    );
+  }
+  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;
+    if (reason === "validation_failed") {
+      throw attachRequestId(createValidationError(errorMessage, data, errorMessage), requestId);
+    }
+    if (reason === "token_expired" || reason === "token_invalid" || reason === "key_invalid" || reason === "key_revoked") {
+      throw attachRequestId(createAuthError(errorMessage, data, errorMessage), requestId);
+    }
+    if (reason === "forbidden") {
+      throw attachRequestId(createPermissionError(errorMessage, data, errorMessage), requestId);
+    }
+    if (reason === "rate_limit_exceeded") {
+      throw attachRequestId(createRateLimitError(errorMessage, retryAfter, data, errorMessage), requestId);
+    }
+    if (reason === "not_found") {
+      throw attachRequestId(createNotFoundError(errorMessage, data, errorMessage), requestId);
+    }
+    if (reason === "conflict") {
+      throw attachRequestId(createConflictError(errorMessage, data, errorMessage), requestId);
+    }
+    throw attachRequestId(
+      createApiError(errorMessage, response.status, data, errorMessage, "An error occurred while processing the request."),
+      requestId
+    );
+  }
+  return data;
+}
+
 // src/core/community/community-client.ts
 var CommunityClient = class {
   constructor(options) {
     this.publishableKey = options.publishableKey ?? "";
     this.secretKey = options.secretKey;
+    this.tenantId = options.tenantId;
     this.customerToken = options.customerToken;
     this.onUnauthorized = options.onUnauthorized;
+    this.onRequestId = options.onRequestId;
+  }
+  buildQuery(params) {
+    if (!params) return "";
+    const entries = Object.entries(params).filter((e) => e[1] !== void 0).map(([k, v]) => [k, String(v)]);
+    return entries.length ? `?${new URLSearchParams(entries).toString()}` : "";
   }
   async execute(endpoint, method, body) {
     const token = typeof this.customerToken === "function" ? this.customerToken() : this.customerToken;
-    const response = await httpFetch(endpoint, {
-      method,
-      publishableKey: this.publishableKey,
-      secretKey: this.secretKey,
-      customerToken: token ?? void 0,
-      ...token && this.onUnauthorized && { onUnauthorized: this.onUnauthorized },
-      ...body !== void 0 && { body: JSON.stringify(body) }
-    });
-    return parseApiResponse(response, endpoint);
+    const tenantId = this.secretKey?.startsWith("pat01_") && this.tenantId ? this.tenantId : void 0;
+    try {
+      const response = await httpFetch(endpoint, {
+        method,
+        publishableKey: this.publishableKey,
+        secretKey: this.secretKey,
+        tenantId,
+        customerToken: token ?? void 0,
+        ...token && this.onUnauthorized && { onUnauthorized: this.onUnauthorized },
+        ...body !== void 0 && { body: JSON.stringify(body) }
+      });
+      this.onRequestId?.(response.headers.get("x-request-id") ?? null);
+      return parseApiResponse(response, endpoint);
+    } catch (err) {
+      const id = err instanceof SDKError ? err.requestId ?? null : null;
+      this.onRequestId?.(id);
+      throw err;
+    }
   }
   // Threads
   createThread(params) {
     return this.execute("/api/threads", "POST", params);
   }
   getMyThreads(params) {
-    const query = params ? `?${new URLSearchParams(
-      Object.fromEntries(
-        Object.entries(params).map(([k, v]) => [k, String(v)])
-      )
-    ).toString()}` : "";
     return this.execute(
-      `/api/threads/my${query}`,
+      `/api/threads/my${this.buildQuery(params)}`,
       "GET"
     );
   }
   getTrending(params) {
-    const query = params ? `?${new URLSearchParams(
-      Object.fromEntries(
-        Object.entries(params).map(([k, v]) => [k, String(v)])
-      )
-    ).toString()}` : "";
     return this.execute(
-      `/api/threads/trending${query}`,
+      `/api/threads/trending${this.buildQuery(params)}`,
       "GET"
     );
   }
@@ -1264,26 +1235,56 @@ var CommunityClient = class {
     );
   }
   getMyBookmarks(params) {
-    const query = params ? `?${new URLSearchParams(
-      Object.fromEntries(
-        Object.entries(params).map(([k, v]) => [k, String(v)])
-      )
-    ).toString()}` : "";
     return this.execute(
-      `/api/bookmarks/my${query}`,
+      `/api/bookmarks/my${this.buildQuery(params)}`,
       "GET"
     );
   }
-  // Moderation
+};
+
+// src/core/api/base-api.ts
+var BaseApi = class {
+  constructor(apiName, options) {
+    if (!options.secretKey) {
+      throw createConfigError(`secretKey is required for ${apiName}.`);
+    }
+    this.publishableKey = options.publishableKey ?? "";
+    this.secretKey = options.secretKey;
+    this.tenantId = options.tenantId;
+    this.onRequestId = options.onRequestId;
+  }
+  async request(endpoint, body, options) {
+    const method = options?.method ?? "POST";
+    const tenantId = this.secretKey.startsWith("pat01_") && this.tenantId ? this.tenantId : void 0;
+    try {
+      const response = await httpFetch(endpoint, {
+        method,
+        publishableKey: this.publishableKey,
+        secretKey: this.secretKey,
+        tenantId,
+        ...body !== void 0 && { body: JSON.stringify(body) },
+        ...options?.headers && { headers: options.headers }
+      });
+      this.onRequestId?.(response.headers.get("x-request-id") ?? null);
+      return parseApiResponse(response, endpoint);
+    } catch (err) {
+      const id = err instanceof SDKError ? err.requestId ?? null : null;
+      this.onRequestId?.(id);
+      throw err;
+    }
+  }
+};
+
+// src/core/community/moderation-api.ts
+var ModerationApi = class extends BaseApi {
+  constructor(options) {
+    super("ModerationApi", options);
+  }
   banCustomer(params) {
-    return this.execute("/api/community-bans/ban", "POST", params);
+    return this.request("/api/community-bans/ban", params);
   }
   unbanCustomer(params) {
-    return this.execute(
-      "/api/community-bans/unban",
-      "DELETE",
-      params
-    );
+    return this.request("/api/community-bans/unban", params);
   }
 };
 
@@ -1538,6 +1539,265 @@ var CustomerAuth = class {
   }
 };
 
+// src/core/customer/customer-namespace.ts
+var CustomerNamespace = class {
+  constructor(publishableKey, options) {
+    this.auth = new CustomerAuth(publishableKey, options);
+  }
+};
+
+// src/core/api/cart-api.ts
+var CartApi = class {
+  constructor(options) {
+    if (!options.secretKey && !options.customerToken) {
+      throw createConfigError(
+        "Either secretKey or customerToken is required for CartApi."
+      );
+    }
+    this.publishableKey = options.publishableKey ?? "";
+    this.secretKey = options.secretKey;
+    this.tenantId = options.tenantId;
+    this.customerToken = options.customerToken;
+    this.onUnauthorized = options.onUnauthorized;
+    this.onRequestId = options.onRequestId;
+  }
+  async execute(endpoint, method, body) {
+    const token = typeof this.customerToken === "function" ? this.customerToken() : this.customerToken;
+    const tenantId = this.secretKey?.startsWith("pat01_") && this.tenantId ? this.tenantId : void 0;
+    try {
+      const response = await httpFetch(endpoint, {
+        method,
+        publishableKey: this.publishableKey,
+        secretKey: this.secretKey,
+        tenantId,
+        customerToken: token ?? void 0,
+        ...token && this.onUnauthorized && { onUnauthorized: this.onUnauthorized },
+        ...body !== void 0 && { body: JSON.stringify(body) }
+      });
+      this.onRequestId?.(response.headers.get("x-request-id") ?? null);
+      return parseApiResponse(response, endpoint);
+    } catch (err) {
+      const id = err instanceof SDKError ? err.requestId ?? null : null;
+      this.onRequestId?.(id);
+      throw err;
+    }
+  }
+  getCart(cartId) {
+    return this.execute(`/api/carts/${cartId}`, "GET");
+  }
+  addItem(params) {
+    return this.execute("/api/carts/add-item", "POST", params);
+  }
+  updateItem(params) {
+    return this.execute("/api/carts/update-item", "POST", params);
+  }
+  removeItem(params) {
+    return this.execute(
+      "/api/carts/remove-item",
+      "POST",
+      params
+    );
+  }
+  applyDiscount(params) {
+    return this.execute("/api/carts/apply-discount", "POST", params);
+  }
+  removeDiscount(params) {
+    return this.execute("/api/carts/remove-discount", "POST", params);
+  }
+  clearCart(params) {
+    return this.execute(
+      "/api/carts/clear",
+      "POST",
+      params
+    );
+  }
+};
+
+// src/core/commerce/commerce-client.ts
+var CommerceClient = class {
+  constructor(options) {
+    const cartApi = new CartApi({
+      publishableKey: options.publishableKey,
+      customerToken: options.customerToken,
+      onUnauthorized: options.onUnauthorized,
+      onRequestId: options.onRequestId
+    });
+    const execute = async (endpoint, body) => {
+      const token = options.customerToken();
+      try {
+        const response = await httpFetch(endpoint, {
+          method: "POST",
+          publishableKey: options.publishableKey,
+          customerToken: token ?? void 0,
+          ...token && options.onUnauthorized && { onUnauthorized: options.onUnauthorized },
+          body: JSON.stringify(body)
+        });
+        options.onRequestId?.(response.headers.get("x-request-id") ?? null);
+        return parseApiResponse(response, endpoint);
+      } catch (err) {
+        const id = err instanceof SDKError ? err.requestId ?? null : null;
+        options.onRequestId?.(id);
+        throw err;
+      }
+    };
+    this.product = {
+      stockCheck: (params) => execute("/api/products/stock-check", params),
+      listingGroups: (params) => execute("/api/products/listing-groups", params)
+    };
+    this.cart = {
+      get: cartApi.getCart.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)
+    };
+    this.orders = {
+      checkout: (params) => execute("/api/orders/checkout", params),
+      listMine: (params) => options.customerAuth.getMyOrders(params)
+    };
+    this.discounts = {
+      validate: (params) => execute("/api/discounts/validate", params)
+    };
+    this.shipping = {
+      calculate: (params) => execute("/api/shipping-policies/calculate", params)
+    };
+  }
+};
+
+// src/core/api/product-api.ts
+var ProductApi = class extends BaseApi {
+  constructor(options) {
+    super("ProductApi", options);
+  }
+  /**
+   * Check point-in-time stock availability for one or more product variants.
+   * Results reflect available stock at the moment of the call and are not guaranteed
+   * to remain available by the time an order is placed.
+   */
+  stockCheck(params) {
+    return this.request("/api/products/stock-check", params);
+  }
+  listingGroups(params) {
+    return this.request(
+      "/api/products/listing-groups",
+      params
+    );
+  }
+};
+
+// src/core/api/discount-api.ts
+var DiscountApi = class extends BaseApi {
+  constructor(options) {
+    super("DiscountApi", options);
+  }
+  validate(params) {
+    return this.request("/api/discounts/validate", params);
+  }
+};
+
+// src/core/api/shipping-api.ts
+var ShippingApi = class extends BaseApi {
+  constructor(options) {
+    super("ShippingApi", options);
+  }
+  calculate(params) {
+    return this.request("/api/shipping-policies/calculate", params);
+  }
+};
+
+// src/core/api/order-api.ts
+var OrderApi = class extends BaseApi {
+  constructor(options) {
+    super("OrderApi", options);
+  }
+  createOrder(params) {
+    return this.request("/api/orders/create", params);
+  }
+  updateOrder(params) {
+    return this.request("/api/orders/update", params);
+  }
+  updateTransaction(params) {
+    return this.request("/api/transactions/update", params);
+  }
+  checkout(params) {
+    return this.request("/api/orders/checkout", params);
+  }
+  createFulfillment(params) {
+    return this.request("/api/orders/create-fulfillment", params);
+  }
+  updateFulfillment(params) {
+    return this.request("/api/orders/update-fulfillment", params);
+  }
+  bulkImportFulfillments(params) {
+    return this.request(
+      "/api/orders/bulk-import-fulfillments",
+      params
+    );
+  }
+  returnWithRefund(params) {
+    return this.request(
+      "/api/returns/return-refund",
+      params
+    );
+  }
+  createReturn(params) {
+    return this.request("/api/returns/create", params);
+  }
+  updateReturn(params) {
+    return this.request("/api/returns/update", params);
+  }
+};
+
+// src/core/commerce/server-commerce-client.ts
+var ServerCommerceClient = class {
+  constructor(options) {
+    const serverOptions = {
+      publishableKey: options.publishableKey,
+      secretKey: options.secretKey,
+      tenantId: options.tenantId,
+      onRequestId: options.onRequestId
+    };
+    const productApi = new ProductApi(serverOptions);
+    const cartApi = new CartApi(serverOptions);
+    const discountApi = new DiscountApi(serverOptions);
+    const shippingApi = new ShippingApi(serverOptions);
+    const orderApi = new OrderApi(serverOptions);
+    this.product = {
+      stockCheck: productApi.stockCheck.bind(productApi),
+      listingGroups: productApi.listingGroups.bind(productApi)
+    };
+    this.cart = {
+      get: cartApi.getCart.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)
+    };
+    this.orders = {
+      checkout: orderApi.checkout.bind(orderApi),
+      create: orderApi.createOrder.bind(orderApi),
+      update: orderApi.updateOrder.bind(orderApi),
+      updateTransaction: orderApi.updateTransaction.bind(orderApi),
+      createFulfillment: orderApi.createFulfillment.bind(orderApi),
+      updateFulfillment: orderApi.updateFulfillment.bind(orderApi),
+      bulkImportFulfillments: orderApi.bulkImportFulfillments.bind(orderApi),
+      createReturn: orderApi.createReturn.bind(orderApi),
+      updateReturn: orderApi.updateReturn.bind(orderApi),
+      returnWithRefund: orderApi.returnWithRefund.bind(orderApi)
+    };
+    this.discounts = {
+      validate: discountApi.validate.bind(discountApi)
+    };
+    this.shipping = {
+      calculate: shippingApi.calculate.bind(shippingApi)
+    };
+  }
+};
+
 // src/core/query/get-query-client.ts
 import {
   isServer,
@@ -2083,6 +2343,7 @@ var QueryHooks = class extends CollectionHooks {
 // src/core/client/client.ts
 var Client = class {
   constructor(options) {
+    this.lastRequestId = null;
     const publishableKey = options.publishableKey;
     if (!publishableKey) {
       throw createConfigError("publishableKey is required.");
@@ -2094,43 +2355,47 @@ var Client = class {
     };
     this.state = { metadata };
     this.queryClient = getQueryClient();
-    this.customer = new CustomerAuth(
+    this.customer = new CustomerNamespace(
       this.config.publishableKey,
       options.customer
     );
     const onUnauthorized = async () => {
       try {
-        const result = await this.customer.refreshToken();
+        const result = await this.customer.auth.refreshToken();
         return result.token ?? null;
       } catch {
         return null;
       }
     };
-    this.cart = new CartApi({
+    const onRequestId = (id) => {
+      this.lastRequestId = id;
+    };
+    this.commerce = new CommerceClient({
       publishableKey: this.config.publishableKey,
-      customerToken: () => this.customer.getToken(),
-      onUnauthorized
+      customerToken: () => this.customer.auth.getToken(),
+      onUnauthorized,
+      onRequestId,
+      customerAuth: this.customer.auth
     });
     this.community = new CommunityClient({
       publishableKey: this.config.publishableKey,
-      customerToken: () => this.customer.getToken(),
-      onUnauthorized
+      customerToken: () => this.customer.auth.getToken(),
+      onUnauthorized,
+      onRequestId
     });
     this.collections = new CollectionClient(
       this.config.publishableKey,
       void 0,
-      () => this.customer.getToken(),
-      onUnauthorized
+      () => this.customer.auth.getToken(),
+      onUnauthorized,
+      onRequestId
     );
     this.query = new QueryHooks(
       this.queryClient,
       this.collections,
-      this.customer
+      this.customer.auth
     );
   }
-  from(collection) {
-    return this.collections.from(collection);
-  }
   getState() {
     return { ...this.state };
   }
@@ -2145,6 +2410,7 @@ function createClient(options) {
 // src/core/client/client.server.ts
 var ServerClient = class {
   constructor(options) {
+    this.lastRequestId = null;
     if (typeof window !== "undefined") {
       throw createConfigError(
         "ServerClient must not be used in a browser environment. This risks exposing your secretKey in client bundles. Use createClient() for browser code instead."
@@ -2164,32 +2430,35 @@ var ServerClient = class {
       userAgent: "Node.js"
     };
     this.state = { metadata };
-    this.api = new OrderApi({
-      publishableKey: this.config.publishableKey,
-      secretKey: this.config.secretKey
-    });
-    this.cart = new CartApi({
-      publishableKey: this.config.publishableKey,
-      secretKey: this.config.secretKey
-    });
-    this.community = new CommunityClient({
-      publishableKey: this.config.publishableKey,
-      secretKey: this.config.secretKey
-    });
-    this.product = new ProductApi({
+    const onRequestId = (id) => {
+      this.lastRequestId = id;
+    };
+    const serverOptions = {
       publishableKey: this.config.publishableKey,
-      secretKey: this.config.secretKey
+      secretKey: this.config.secretKey,
+      tenantId: this.config.tenantId,
+      onRequestId
+    };
+    this.commerce = new ServerCommerceClient(serverOptions);
+    const communityClient = new CommunityClient(serverOptions);
+    const moderationApi = new ModerationApi(serverOptions);
+    this.community = Object.assign(communityClient, {
+      moderation: {
+        banCustomer: moderationApi.banCustomer.bind(moderationApi),
+        unbanCustomer: moderationApi.unbanCustomer.bind(moderationApi)
+      }
     });
     this.collections = new CollectionClient(
       this.config.publishableKey,
-      this.config.secretKey
+      this.config.secretKey,
+      void 0,
+      void 0,
+      onRequestId,
+      this.config.tenantId
     );
     this.queryClient = getQueryClient();
     this.query = new QueryHooks(this.queryClient, this.collections);
   }
-  from(collection) {
-    return this.collections.from(collection);
-  }
   getState() {
     return { ...this.state };
   }
@@ -2766,8 +3035,179 @@ function getVideoStreamUrl(playbackId) {
 function getVideoMp4Url(playbackId, resolution = "high") {
   return `${MUX_STREAM_BASE}/${playbackId}/${resolution}.mp4`;
 }
+
+// src/analytics.ts
+function createAnalytics(config) {
+  if (typeof window === "undefined") {
+    return { pageview() {
+    }, track() {
+    }, destroy() {
+    } };
+  }
+  const endpoint = config.endpoint ?? `${resolveApiUrl()}/api/analytics/collect`;
+  const respectDnt = config.respectDnt !== false;
+  function isDntActive() {
+    if (!respectDnt) return false;
+    const nav = navigator;
+    return nav.doNotTrack === "1" || nav.globalPrivacyControl === true;
+  }
+  let lastPath = null;
+  let lastAt = 0;
+  const autoTrack = config.autoTrack !== false;
+  const originalPushState = history.pushState;
+  const originalReplaceState = history.replaceState;
+  let destroyed = false;
+  function newEventId() {
+    return typeof crypto !== "undefined" && typeof crypto.randomUUID === "function" ? crypto.randomUUID() : String(Date.now()) + String(Math.random());
+  }
+  function sendBeaconOrFetch(body) {
+    try {
+      if (typeof navigator.sendBeacon === "function") {
+        const blob = new Blob([body], { type: "text/plain" });
+        const sent = navigator.sendBeacon(endpoint, blob);
+        if (sent) return;
+      }
+      fetch(endpoint, {
+        method: "POST",
+        keepalive: true,
+        headers: { "Content-Type": "application/json" },
+        body
+      }).catch(() => {
+      });
+    } catch {
+    }
+  }
+  function sendPageview(pathname) {
+    if (isDntActive()) return;
+    const doc = document;
+    if (doc.prerendering === true || document.visibilityState === "prerender") return;
+    const now = Date.now();
+    if (pathname === lastPath && now - lastAt < 500) return;
+    lastPath = pathname;
+    lastAt = now;
+    const body = JSON.stringify({
+      publishableKey: config.publishableKey,
+      pathname,
+      referrer: document.referrer || "",
+      eventId: newEventId()
+    });
+    sendBeaconOrFetch(body);
+  }
+  function trackCurrentPath() {
+    if (destroyed) return;
+    sendPageview(location.pathname);
+  }
+  function patchedPushState(data, unused, url) {
+    originalPushState.apply(this, [data, unused, url]);
+    if (!destroyed) setTimeout(trackCurrentPath, 0);
+  }
+  function patchedReplaceState(data, unused, url) {
+    originalReplaceState.apply(this, [data, unused, url]);
+    if (!destroyed) setTimeout(trackCurrentPath, 0);
+  }
+  if (autoTrack) {
+    history.pushState = patchedPushState;
+    history.replaceState = patchedReplaceState;
+    window.addEventListener("popstate", trackCurrentPath);
+    if (document.readyState === "complete") {
+      trackCurrentPath();
+    } else {
+      window.addEventListener("load", trackCurrentPath, { once: true });
+    }
+  }
+  const isProduction = (() => {
+    try {
+      const hostname = location.hostname;
+      return hostname !== "localhost" && hostname !== "127.0.0.1" && !hostname.endsWith(".local");
+    } catch {
+      return true;
+    }
+  })();
+  const warnedReasons = /* @__PURE__ */ new Set();
+  function devWarn(name, reason) {
+    if (isProduction) return;
+    if (warnedReasons.has(reason)) return;
+    warnedReasons.add(reason);
+    console.warn(`[01 analytics] dropped event ${name}: ${reason}`);
+  }
+  const EVENT_NAME_RE = /^[a-zA-Z][a-zA-Z0-9_:-]{0,49}$/;
+  const RESERVED_PREFIXES = ["__", "_pv_"];
+  function validateEventName(name) {
+    if (!name || typeof name !== "string") return "name-empty";
+    for (const prefix of RESERVED_PREFIXES) {
+      if (name.startsWith(prefix)) return "name-reserved";
+    }
+    if (!EVENT_NAME_RE.test(name)) return "name-regex";
+    return null;
+  }
+  const PROP_KEY_RE = /^[a-zA-Z_][a-zA-Z0-9_]{0,31}$/;
+  function validateEventProps(props) {
+    if (props === void 0 || props === null) return null;
+    if (typeof props !== "object" || Array.isArray(props)) return "props-value-type";
+    const keys = Object.keys(props);
+    if (keys.length > 10) return "props-too-many-keys";
+    for (const k of keys) {
+      const v = props[k];
+      if (!PROP_KEY_RE.test(k)) return "props-key-regex";
+      if (typeof v === "string") {
+        if (v.length > 80) return "props-value-too-long";
+      } else if (typeof v === "number") {
+        if (!isFinite(v)) return "props-value-not-finite";
+      } else if (typeof v === "boolean") {
+      } else {
+        return "props-value-type";
+      }
+    }
+    return null;
+  }
+  return {
+    pageview(path) {
+      if (destroyed) return;
+      sendPageview(path ?? location.pathname);
+    },
+    track(name, props) {
+      if (destroyed) return;
+      if (isDntActive()) return;
+      const doc = document;
+      if (doc.prerendering === true || document.visibilityState === "prerender") return;
+      const nameErr = validateEventName(name);
+      if (nameErr) {
+        devWarn(name, nameErr);
+        return;
+      }
+      if (props !== void 0) {
+        const propsErr = validateEventProps(props);
+        if (propsErr) {
+          devWarn(name, propsErr);
+          return;
+        }
+      }
+      const body = JSON.stringify({
+        publishableKey: config.publishableKey,
+        pathname: location.pathname,
+        referrer: document.referrer || "",
+        eventId: newEventId(),
+        eventName: name,
+        eventProps: props
+      });
+      sendBeaconOrFetch(body);
+    },
+    destroy() {
+      if (destroyed) return;
+      destroyed = true;
+      if (autoTrack) {
+        history.pushState = originalPushState;
+        history.replaceState = originalReplaceState;
+        window.removeEventListener("popstate", trackCurrentPath);
+      }
+      lastPath = null;
+      lastAt = 0;
+    }
+  };
+}
 export {
   ApiError,
+  AuthError,
   BaseApi,
   COLLECTIONS,
   CartApi,
@@ -2775,20 +3215,30 @@ export {
   CollectionClient,
   CollectionHooks,
   CollectionQueryBuilder,
+  CommerceClient,
   CommunityClient,
   ConfigError,
+  ConflictError,
   CustomerAuth,
   CustomerHooks,
+  CustomerNamespace,
+  DiscountApi,
   GoneError,
   IMAGE_SIZES,
+  ModerationApi,
   NetworkError,
+  NotFoundError,
   OrderApi,
+  PermissionError,
   ProductApi,
   QueryHooks,
+  RateLimitError,
   RealtimeConnection,
   SDKError,
   ServerClient,
+  ServerCommerceClient,
   ServiceUnavailableError,
+  ShippingApi,
   TimeoutError,
   UsageLimitError,
   ValidationError,
@@ -2796,7 +3246,13 @@ export {
   buildProductListingProjection,
   buildProductOptionMatrix,
   collectionKeys,
+  createAnalytics,
+  createAuthError,
   createClient,
+  createConflictError,
+  createNotFoundError,
+  createPermissionError,
+  createRateLimitError,
   createServerClient,
   createTypedWebhookHandler,
   customerKeys,
@@ -2817,9 +3273,14 @@ export {
   getVideoThumbnail,
   handleWebhook,
   isApiError,
+  isAuthError,
   isConfigError,
+  isConflictError,
   isGoneError,
   isNetworkError,
+  isNotFoundError,
+  isPermissionError,
+  isRateLimitError,
   isSDKError,
   isServiceUnavailableError,
   isTimeoutError,