@misiki/gocommerce-connector 0.1.0 → 0.2.0

package/dist/services/index.cjs

@@ -1,2352 +1,2571 @@
 'use strict';
 
-// src/services/base.ts
-var API_PROXY_PREFIX = "/proxy/gocommerce";
+// src/errors.ts
 var GoCommerceError = class extends Error {
+  status;
   code;
   details;
-  status;
-  constructor(message, code = "internal_error", status = 0, details) {
+  constructor(message, status, code, details) {
     super(message);
     this.name = "GoCommerceError";
-    this.code = code;
     this.status = status;
+    this.code = code;
     this.details = details;
   }
 };
-var BaseService = class _BaseService {
-  _fetch;
-  static _credentials = {};
-  static _languageCode;
-  constructor(fetchFn) {
-    this._fetch = fetchFn || ((...args) => globalThis.fetch(...args));
+var NotSupportedError = class extends Error {
+  service;
+  method;
+  constructor(service, method, detail) {
+    super(`${service}.${method}() is not supported by GoCommerce${detail ? `: ${detail}` : "."}`);
+    this.name = "NotSupportedError";
+    this.service = service;
+    this.method = method;
   }
-  setFetch(fetchFn) {
-    this._fetch = fetchFn;
-    return this;
+};
+
+// src/rest-guard.ts
+var COLLECTION_SEGMENTS = /* @__PURE__ */ new Set([
+  "all",
+  "list",
+  "list-by-parent",
+  "list-public",
+  "latest",
+  "search",
+  "public",
+  "public-details",
+  "me",
+  "multiple"
+]);
+var emptyResult = () => ({ data: [], count: 0, pageSize: 0, noOfPage: 0, page: 1 });
+var addressesOneRecord = (url) => {
+  const segments = url.split("?")[0].split("/").filter(Boolean);
+  if (segments.length < 3) return false;
+  return !COLLECTION_SEGMENTS.has(segments[segments.length - 1].toLowerCase());
+};
+var reported = /* @__PURE__ */ new Set();
+var report = (method, url) => {
+  const key = `${method} ${url.split("?")[0]}`;
+  if (reported.has(key)) return;
+  reported.add(key);
+  console.warn(
+    `[gocommerce] no native implementation for \`${key}\` \u2014 that is a Litekart REST path, and it was not called.`
+  );
+};
+var localResolver;
+var resolveRestLocally = async (method, url) => {
+  if (method === "get") {
+    const local = await localResolver?.(url);
+    if (local !== void 0) return local;
+  }
+  report(method, url);
+  if (method !== "get" || addressesOneRecord(url)) {
+    throw new Error(`This feature is not available on this store (gocommerce).`);
+  }
+  return emptyResult();
+};
+
+// src/browser.ts
+var inBrowser = () => typeof window !== "undefined" && typeof document !== "undefined";
+function readLocal(key) {
+  if (!inBrowser()) return null;
+  try {
+    return window.localStorage.getItem(key);
+  } catch {
+    return null;
   }
-  getFetch() {
-    return this._fetch;
+}
+function writeLocal(key, value) {
+  if (!inBrowser()) return;
+  try {
+    window.localStorage.setItem(key, value);
+  } catch {
   }
-  /**
-   * The fetch a GoCommerce call actually goes out on.
-   *
-   * In the browser it is whatever was handed in, against this storefront's own origin. On the
-   * server it is deliberately the platform's, not SvelteKit's: a universal `+page.ts` load is
-   * given a `fetch` that simulates a browser's CORS check, and GoCommerce sends no
-   * `Access-Control-Allow-Origin`, so the same product page that renders from a `+page.server.ts`
-   * would throw from a `+page.ts`. Nothing is lost by stepping around it — SvelteKit's fetch adds
-   * cookie forwarding and internal routing, and both are about this storefront's own origin, not
-   * a separate API host.
-   */
-  transport() {
-    return _BaseService.isBrowser() ? this._fetch : (...args) => globalThis.fetch(...args);
+}
+function removeLocal(key) {
+  if (!inBrowser()) return;
+  try {
+    window.localStorage.removeItem(key);
+  } catch {
+  }
+}
+function readJSON(key) {
+  const raw = readLocal(key);
+  if (!raw) return null;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+var YEAR = 60 * 60 * 24 * 365;
+function setCookie(name, value, maxAge = YEAR) {
+  if (!inBrowser()) return;
+  document.cookie = `${name}=${value}; path=/; max-age=${maxAge}; samesite=lax`;
+}
+function clearCookie(name) {
+  if (!inBrowser()) return;
+  document.cookie = `${name}=; path=/; expires=Thu, 01 Jan 1970 00:00:00 GMT`;
+}
+function readCookie(name) {
+  if (!inBrowser()) return null;
+  for (const pair of document.cookie.split(";")) {
+    const at = pair.indexOf("=");
+    if (at < 0) continue;
+    if (pair.slice(0, at).trim() === name) return pair.slice(at + 1).trim();
+  }
+  return null;
+}
+var TOKEN = "gocommerce_token";
+var sessionToken = () => readLocal(TOKEN);
+function toMe(c) {
+  const [firstName, ...rest] = (c.name ?? "").trim().split(/\s+/);
+  return {
+    id: String(c.id),
+    userId: String(c.id),
+    email: c.email,
+    phone: c.phone || null,
+    firstName: firstName || "",
+    lastName: rest.join(" "),
+    name: c.name ?? "",
+    fullName: c.name ?? "",
+    avatar: null,
+    role: "USER",
+    emailVerified: c.email_verified,
+    storeId: null
+  };
+}
+function startSession(auth) {
+  writeLocal(TOKEN, auth.token);
+  const me = toMe(auth.record);
+  const expires = Math.max(60, Math.floor((Date.parse(auth.expires_at) - Date.now()) / 1e3)) || YEAR;
+  setCookie("me", encodeURIComponent(JSON.stringify(me)), expires);
+  setCookie("connect.sid", "gocommerce", expires);
+  return me;
+}
+function updateMe(c) {
+  const me = toMe(c);
+  setCookie("me", encodeURIComponent(JSON.stringify(me)));
+  return me;
+}
+function endSession() {
+  removeLocal(TOKEN);
+  clearCookie("me");
+  clearCookie("connect.sid");
+}
+function currentMe() {
+  const raw = readCookie("me");
+  if (!raw) return null;
+  try {
+    return JSON.parse(decodeURIComponent(raw));
+  } catch {
+    return null;
+  }
+}
+function storedCartId() {
+  const v = readLocal("cart_id");
+  if (!v || v === "undefined" || v === "null") return null;
+  return v;
+}
+var rememberCartId = (id) => writeLocal("cart_id", id);
+var extrasKey = (cartId) => `gocommerce_cart_${cartId}`;
+var cartExtras = (cartId) => readJSON(extrasKey(cartId)) ?? {};
+function saveCartExtras(cartId, patch) {
+  const next = { ...cartExtras(cartId), ...patch };
+  writeLocal(extrasKey(cartId), JSON.stringify(next));
+  return next;
+}
+var forgetCartExtras = (cartId) => removeLocal(extrasKey(cartId));
+var ORDERS = "gocommerce_orders";
+var placedOrders = () => readJSON(ORDERS) ?? [];
+function rememberOrder(o) {
+  const kept = placedOrders().filter((p) => p.number !== o.number);
+  writeLocal(ORDERS, JSON.stringify([o, ...kept].slice(0, 50)));
+}
+var placedOrder = (number) => placedOrders().find((p) => p.number === number);
+var placedOrderForCart = (cartId) => placedOrders().find((p) => p.cartId === cartId);
+var placedOrderByReference = (reference) => placedOrders().find((p) => p.reference === reference);
+var WISHLIST = "gocommerce_wishlist";
+var wishlistToken = () => readLocal(WISHLIST);
+var rememberWishlistToken = (token) => writeLocal(WISHLIST, token);
+var forgetWishlistToken = () => removeLocal(WISHLIST);
+
+// src/services/base.service.ts
+var BaseService = class _BaseService {
+  static _credentials = { apiUrl: "" };
+  _fetch;
+  constructor(fetchFn) {
+    this._fetch = fetchFn ?? ((input, init) => globalThis.fetch(input, init));
   }
-  /**
-   * The hook the storefront's `src/lib/core/connectors/init.ts` calls with `PUBLIC_GOCOMMERCE_*`. Merges, so a
-   * later call with a subset never erases the base url an earlier one established.
-   */
   static setCredentials(creds) {
     _BaseService._credentials = { ..._BaseService._credentials, ...creds };
   }
   static getCredentials() {
     return _BaseService._credentials;
   }
-  static setBaseUrl(url) {
-    if (url) _BaseService._credentials.apiUrl = url;
-  }
-  /** Trailing slashes stripped so `${base}/api/products` never doubles up. */
-  static getBaseUrl() {
-    return (_BaseService._credentials.apiUrl || "").replace(/\/+$/, "");
-  }
-  static setLanguageCode(code) {
-    _BaseService._languageCode = code;
-  }
-  static getLanguageCode() {
-    return _BaseService._languageCode;
-  }
-  setBaseUrl(url) {
-    _BaseService.setBaseUrl(url);
-    return this;
-  }
-  getBaseUrl() {
-    return _BaseService.getBaseUrl();
+  get creds() {
+    return _BaseService._credentials;
   }
   /**
-   * Where a request for `path` actually goes.
-   *
-   * GoCommerce sends no CORS headers and answers a preflight with 405, so a browser cannot reach
-   * it cross-origin at all — and neither can a universal `+page.ts` load, because SvelteKit
-   * simulates the same CORS check server-side for consistency. So anything the browser issues goes
-   * through this storefront's own origin (`src/routes/proxy/gocommerce/[...path]`), which is
-   * same-origin and needs no headers from the API.
-   *
-   * On the server there is no such rule, and the extra hop through the storefront's own handler
-   * would be a request the process makes to itself, so it calls the API directly.
+   * The engine's base URL from wherever this code runs. In the browser a
+   * configured proxy path wins, because the engine answers no CORS preflight.
    */
-  static apiUrl(path) {
-    if (/^https?:\/\//i.test(path)) return path;
-    const suffix = path.startsWith("/") ? path : `/${path}`;
-    if (_BaseService.isBrowser()) return `${API_PROXY_PREFIX}${suffix}`;
-    const base = _BaseService.getBaseUrl();
-    if (!base) {
-      throw new GoCommerceError("PUBLIC_GOCOMMERCE_API_URL is not configured \u2014 add it to .env (see docs/GOCOMMERCE.md).", "not_ready");
+  engineBase() {
+    const { apiUrl, proxyPath } = this.creds;
+    if (proxyPath && typeof window !== "undefined" && window.location) {
+      return new URL(proxyPath, window.location.origin).href.replace(/\/+$/, "");
     }
-    return `${base}${suffix}`;
-  }
-  /**
-   * Where an `<img>` points.
-   *
-   * Media urls come back site-relative for files this store holds (`/media/42.jpg`). Unlike an API
-   * call, the consumer is always the browser — a server-rendered `<img src>` is still fetched by
-   * it — so this always resolves through the proxy, and the picture loads wherever the API happens
-   * to be reachable from. A url that is already absolute belongs to someone else's host and is
-   * left exactly as it is.
-   */
-  static mediaUrl(path) {
-    if (/^https?:\/\//i.test(path)) return path;
-    return `${API_PROXY_PREFIX}${path.startsWith("/") ? path : `/${path}`}`;
+    const url = (apiUrl ?? "").trim();
+    if (!url) {
+      throw new GoCommerceError(
+        "PUBLIC_GOCOMMERCE_API_URL is not set, so this storefront does not know where its commerce engine is. Point it at a running GoCommerce, e.g. http://127.0.0.1:8080.",
+        0
+      );
+    }
+    return url.replace(/\/+$/, "");
   }
-  static isBrowser() {
-    return typeof window !== "undefined" && typeof window.document !== "undefined";
+  /** An absolute engine URL for a path and query, without sending anything. */
+  engineURL(path, query) {
+    return this.engineBase() + path + qs(query);
   }
   /**
-   * One request against the GoCommerce API.
+   * One request to the engine, envelope and all.
    *
-   * Unwraps `{ data, meta }` and turns `{ error: { code, message } }` into a thrown
-   * GoCommerceError carrying the server's own wording — a 409 at checkout says which line went
-   * stale, and that sentence is what the shopper needs to see.
+   * The body is read as text first, so a proxy's HTML error page is reported
+   * as what it is rather than as a JSON parse error three frames away.
    */
-  async api(method, path, body, headers = {}) {
-    const url = _BaseService.apiUrl(path);
-    const lang = _BaseService.getLanguageCode();
+  async engine(path, req = {}) {
+    const url = this.engineURL(path, req.query);
+    const headers = { Accept: "application/json", ...req.headers };
+    if (req.body !== void 0) headers["Content-Type"] = "application/json";
+    if (this.creds.store) headers["X-Store"] = this.creds.store;
+    if (req.auth) {
+      const token = sessionToken();
+      if (!token) throw new GoCommerceError("Please sign in to continue.", 401, "unauthorized");
+      headers.Authorization = `Bearer ${token}`;
+    }
+    const init = {
+      method: req.method ?? "GET",
+      headers,
+      body: req.body === void 0 ? void 0 : JSON.stringify(req.body)
+    };
     let res;
     try {
-      res = await this.transport()(url, {
-        method,
-        headers: {
-          Accept: "application/json",
-          ...body === void 0 ? {} : { "Content-Type": "application/json" },
-          ...lang ? { "Accept-Language": lang } : {},
-          ...headers
-        },
-        ...body === void 0 ? {} : { body: JSON.stringify(body) }
-      });
+      res = await this._fetch.call(globalThis, url, init);
     } catch (cause) {
-      const reason = cause?.cause?.code ?? cause?.message ?? "unknown error";
-      throw new GoCommerceError(
-        `Could not reach the GoCommerce server at ${_BaseService.getBaseUrl() || url} \u2014 ${reason}. Is it running?`,
-        "not_ready",
-        0,
-        cause
-      );
+      if (typeof window === "undefined" && /CORS/i.test(String(cause?.message))) {
+        try {
+          res = await globalThis.fetch(url, init);
+        } catch (again) {
+          throw unreachable(this.engineBase(), again);
+        }
+      } else {
+        throw unreachable(this.engineBase(), cause);
+      }
     }
+    return this.unwrap(res);
+  }
+  /** The envelope opened: the payload, or the engine's error as a GoCommerceError. */
+  async unwrap(res) {
     const text = await res.text();
-    let parsed = void 0;
+    let parsed = null;
     if (text) {
       try {
         parsed = JSON.parse(text);
       } catch {
-        throw new GoCommerceError(`GoCommerce returned a non-JSON response for ${method} ${path} (${res.status}).`, "internal_error", res.status);
+        throw new GoCommerceError(
+          `The commerce engine answered ${res.status} with something that is not JSON: ${text.slice(0, 120)}`,
+          res.status
+        );
       }
     }
-    const envelope = parsed ?? {};
-    if (!res.ok || envelope.error) {
-      const error = envelope.error;
+    if (!res.ok) {
+      const err = parsed?.error ?? {};
       throw new GoCommerceError(
-        error?.message || envelope.message || `GoCommerce request failed: ${method} ${path} (${res.status}).`,
-        error?.code || "internal_error",
+        err.message ?? `The commerce engine answered ${res.status}.`,
         res.status,
-        error?.details
+        err.code,
+        err.details
       );
     }
-    return { data: envelope.data, meta: envelope.meta };
+    return parsed ?? { data: null };
+  }
+  /** The bare payload, for the many callers that never look at `meta`. */
+  async data(path, req = {}) {
+    return (await this.engine(path, req)).data;
   }
   /**
-   * Litekart-era raw-url reads. Deliberately not routed to GoCommerce: a bare `/api/...` here means
-   * a path from the storefront's own REST API, which rest-guard.ts answers from local data or
-   * reports. Absolute urls pass straight through.
+   * Prices a cart at the signed-in shopper's customer-group prices. The
+   * engine does this only for an account whose email is confirmed (403
+   * otherwise), and the cart stays the shopper's either way — so a refusal
+   * is not an error, and neither is a build without ext/identity.
    */
-  async get(url) {
-    const res = await this._fetch(url, { headers: { Accept: "application/json" } });
-    return await res.json();
+  async claimCartForAccount(cartId) {
+    try {
+      await this.engine("/x/identity/me/carts", { method: "POST", body: { cart_id: cartId }, auth: true });
+    } catch {
+    }
   }
-  async post(url, data) {
-    const res = await this._fetch(url, {
-      method: "POST",
-      headers: { "Content-Type": "application/json", Accept: "application/json" },
-      body: JSON.stringify(data)
-    });
-    return await res.json();
+  // ------------------------------------------------------------ Litekart verbs
+  /**
+   * The family's path-addressed verbs. An absolute URL is fetched as-is; a
+   * relative one is a Litekart REST path, answered from the storefront's own
+   * data where it has some and refused otherwise (rest-guard.ts).
+   */
+  get(path) {
+    return this.raw("get", path);
   }
-  async put(url, data) {
-    const res = await this._fetch(url, {
-      method: "PUT",
-      headers: { "Content-Type": "application/json", Accept: "application/json" },
-      body: JSON.stringify(data)
-    });
-    return await res.json();
+  post(path, data) {
+    return this.raw("post", path, data);
   }
-  async patch(url, data) {
-    const res = await this._fetch(url, {
-      method: "PATCH",
-      headers: { "Content-Type": "application/json", Accept: "application/json" },
-      body: JSON.stringify(data)
-    });
-    return await res.json();
+  put(path, data) {
+    return this.raw("put", path, data);
   }
-  async delete(url) {
-    const res = await this._fetch(url, { method: "DELETE", headers: { Accept: "application/json" } });
-    return await res.json();
+  patch(path, data) {
+    return this.raw("patch", path, data);
   }
-};
-
-// src/services/static-store.ts
-var provider;
-var setStaticStore = (fn) => {
-  provider = fn;
-};
-var hasStaticStore = () => Boolean(provider);
-var IMPOSSIBLE_FEATURES = {
-  accounts: { active: false },
-  isDiscountCoupons: { active: false },
-  isWishlist: { active: false },
-  isProductReviewsAndRatings: { active: false },
-  isMultiVendor: { active: false }
-};
-var readStaticStore = async () => {
-  if (!provider) return void 0;
-  const store = await provider();
-  if (!store) return store;
+  delete(path) {
+    return this.raw("delete", path);
+  }
+  async raw(method, path, data) {
+    if (!/^https?:\/\//i.test(path)) return await resolveRestLocally(method, path);
+    const res = await this._fetch.call(globalThis, path, {
+      method: method.toUpperCase(),
+      headers: { Accept: "application/json", ...data === void 0 ? {} : { "Content-Type": "application/json" } },
+      body: data === void 0 ? void 0 : JSON.stringify(data)
+    });
+    const body = await res.json().catch(() => ({}));
+    if (!res.ok)
+      throw new GoCommerceError(body?.error?.message ?? `Request failed with status ${res.status}`, res.status);
+    return body;
+  }
+};
+var unreachable = (base, cause) => new GoCommerceError(`Could not reach the commerce engine at ${base}: ${cause?.message ?? cause}`, 0);
+function qs(query) {
+  if (!query) return "";
+  const sp = new URLSearchParams();
+  for (const [key, value] of Object.entries(query)) {
+    if (value === void 0 || value === null || value === "") continue;
+    if (Array.isArray(value)) for (const v of value) sp.append(key, String(v));
+    else sp.append(key, String(value));
+  }
+  const s = sp.toString();
+  return s ? `?${s}` : "";
+}
+function toPage(env, map) {
+  const rows = env.data ?? [];
+  const meta = env.meta;
   return {
-    ...store,
-    plugins: { ...store.plugins ?? {}, ...IMPOSSIBLE_FEATURES }
+    data: rows.map(map),
+    count: meta?.total ?? rows.length,
+    pageSize: meta?.limit ?? rows.length,
+    noOfPage: meta?.total_pages ?? 1,
+    page: meta?.page ?? 1
   };
-};
-var readStaticStoreDetails = readStaticStore;
+}
+var emptyPage = () => ({ data: [], count: 0, pageSize: 0, noOfPage: 0, page: 1 });
 
-// src/services/money.ts
-var DEFAULT_FRACTION_DIGITS = 2;
-var fractionDigitsCache = /* @__PURE__ */ new Map();
-var currencyFractionDigits = (currencyCode) => {
-  if (!currencyCode) return DEFAULT_FRACTION_DIGITS;
-  const code = currencyCode.toUpperCase();
-  const cached = fractionDigitsCache.get(code);
-  if (cached !== void 0) return cached;
-  let digits = DEFAULT_FRACTION_DIGITS;
-  try {
-    const resolved = new Intl.NumberFormat("en", { style: "currency", currency: code }).resolvedOptions().maximumFractionDigits;
-    if (typeof resolved === "number") digits = resolved;
-  } catch {
-  }
-  fractionDigitsCache.set(code, digits);
-  return digits;
-};
-var fromMoney = (money) => {
-  if (!money || typeof money.amount_minor !== "number" || !Number.isFinite(money.amount_minor)) return 0;
-  const digits = currencyFractionDigits(money.currency);
-  return digits === 0 ? money.amount_minor : money.amount_minor / 10 ** digits;
-};
+// src/money.ts
+var ZERO_DECIMAL = /* @__PURE__ */ new Set([
+  "BIF",
+  "CLP",
+  "DJF",
+  "GNF",
+  "ISK",
+  "JPY",
+  "KMF",
+  "KRW",
+  "PYG",
+  "RWF",
+  "UGX",
+  "VND",
+  "VUV",
+  "XAF",
+  "XOF",
+  "XPF"
+]);
+var THREE_DECIMAL = /* @__PURE__ */ new Set(["BHD", "IQD", "JOD", "KWD", "LYD", "OMR", "TND"]);
+function currencyExponent(code) {
+  const c = (code ?? "").toUpperCase();
+  if (ZERO_DECIMAL.has(c)) return 0;
+  if (THREE_DECIMAL.has(c)) return 3;
+  return 2;
+}
+function toMajor(money) {
+  if (!money) return 0;
+  return minorToMajor(money.amount_minor, money.currency);
+}
+function minorToMajor(minor, currency) {
+  if (minor === null || minor === void 0 || !Number.isFinite(minor)) return 0;
+  const exp = currencyExponent(currency);
+  if (exp === 0) return minor;
+  return Number((minor / 10 ** exp).toFixed(exp));
+}
+function toMinor(amount, currency) {
+  const exp = currencyExponent(currency);
+  return Math.round(amount * 10 ** exp);
+}
 
-// src/services/mappers.ts
-var PAGE_SIZE = 20;
-var MAX_LIMIT = 200;
-var UNTRACKED_STOCK = 999;
-var paginated = (data, count, page = 1, pageSize = PAGE_SIZE) => ({
-  data,
-  count,
-  pageSize,
-  noOfPage: Math.ceil(count / pageSize) || (count ? 1 : 0),
-  page
-});
-var emptyPage = (page = 1, pageSize = PAGE_SIZE) => ({
-  data: [],
-  count: 0,
-  pageSize,
-  noOfPage: 0,
-  page
-});
-var fromListMeta = (data, meta, fallbackPage = 1) => {
-  const count = meta?.total ?? data.length;
-  const pageSize = meta?.limit || data.length || PAGE_SIZE;
-  return {
-    data,
-    count,
-    pageSize,
-    noOfPage: meta?.total_pages ?? (Math.ceil(count / pageSize) || (count ? 1 : 0)),
-    page: meta?.page ?? fallbackPage
+// src/map.ts
+var str = (v) => v === null || v === void 0 ? "" : String(v);
+var arr = (v) => v ?? [];
+var liveVariants = (p) => arr(p.variants).filter((v) => v.active);
+function variantImages(v) {
+  const out = [];
+  for (const img of [v.image, ...arr(v.images)]) {
+    if (img?.url && (img.kind ?? "image") === "image" && !out.includes(img.url)) out.push(img.url);
+  }
+  return out;
+}
+function productImages(p) {
+  const out = [];
+  const push = (url) => {
+    if (url && !out.includes(url)) out.push(url);
   };
-};
-var absoluteMedia = (url) => url ? BaseService.mediaUrl(url) : null;
-var activeVariants = (product) => (product?.variants || []).filter((v) => v?.active !== false);
-var primaryVariant = (product) => activeVariants(product)[0] || (product?.variants || [])[0];
-var variantStock = (variant) => {
-  if (!variant) return 0;
-  if (variant.track_inventory === false) return UNTRACKED_STOCK;
-  const available = Math.max(0, variant.available ?? 0);
-  return available === 0 && variant.continue_selling ? UNTRACKED_STOCK : available;
-};
-var productImages = (product) => {
-  const seen = /* @__PURE__ */ new Set();
-  const featured = absoluteMedia(product?.image_url);
-  if (featured) seen.add(featured);
-  for (const variant of product?.variants || []) {
-    const url = absoluteMedia(variant?.image?.url);
-    if (url) seen.add(url);
-  }
-  return [...seen];
-};
-var flattenMetadata = (metadata) => {
-  if (!metadata || typeof metadata !== "object") return null;
-  const out = {};
-  const printable = (value) => {
-    if (value === null || value === void 0 || value === "") return void 0;
-    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") return String(value);
-    if (Array.isArray(value)) {
-      const items = value.map(printable).filter(Boolean);
-      return items.length ? items.join(", ") : void 0;
-    }
-    return void 0;
-  };
-  const walk = (node, namespace = "") => {
-    for (const [key, value] of Object.entries(node)) {
-      const text = printable(value);
-      if (text !== void 0) {
-        out[key in out && namespace ? `${namespace} ${key}` : key] = text;
-        continue;
-      }
-      if (value && typeof value === "object" && !Array.isArray(value)) walk(value, key);
-    }
-  };
-  walk(metadata);
-  return Object.keys(out).length ? out : null;
-};
-var optionValueId = (product, optionIndex, value) => product?.options?.[optionIndex]?.values?.find((v) => v.value === value)?.id ?? `${optionIndex}-${value}`;
-var mapVariant = (product, variant) => {
-  const price = fromMoney(variant.price);
-  const compareAt = fromMoney(variant.compare_at_price);
-  const image = absoluteMedia(variant.image?.url) || absoluteMedia(product.image_url);
+  push(p.image_url);
+  for (const v of arr(p.variants)) for (const url of variantImages(v)) push(url);
+  return out;
+}
+function toVariant(v, p, optionless) {
+  const images = variantImages(v);
+  const options = arr(p.options);
   return {
-    id: variant.id,
-    // The PDP prints this as the heading whenever it is not 'default'. GoCommerce labels a variant
-    // by its options ("M / Black") and leaves that empty for a product that has none — where the
-    // product's own title is the right heading, and the SKU would be a code shown to a shopper.
-    title: variant.label || (variant.options || []).join(" / ") || product.title || "default",
-    productId: product.id,
-    sku: variant.sku || null,
-    barcode: variant.barcode || null,
-    batchNo: null,
-    stock: variantStock(variant),
-    allowBackorder: Boolean(variant.continue_selling),
-    manageInventory: variant.track_inventory !== false,
-    hsCode: variant.hs_code || null,
-    originCountry: variant.origin_country || null,
-    midCode: null,
-    material: null,
-    weight: variant.weight ?? null,
-    length: null,
-    height: null,
-    width: null,
-    price,
-    costPerItem: 0,
-    mfgDate: null,
-    expiryDate: null,
-    returnAllowed: false,
-    replaceAllowed: false,
-    // No compare-at price recorded means nothing is on sale; mrp equals price so the components
-    // print one number instead of a struck-through duplicate.
-    mrp: compareAt > price ? compareAt : price,
-    img: image,
-    description: null,
-    storeId: null,
-    len: null,
-    rank: variant.position ?? 0,
-    shippingWeight: null,
-    shippingHeight: null,
-    shippingLen: null,
-    shippingWidth: null,
-    shippingCost: null,
-    metadata: variant.metadata ?? null,
-    variantRank: variant.position ?? 0,
-    // A variant's `options` are the VALUES, positionally aligned with the product's option list.
-    options: (variant.options || []).map((value, index) => ({
-      id: optionValueId(product, index, value),
-      optionId: product.options?.[index]?.id ?? index,
-      value,
-      variantId: variant.id
-    }))
+    id: str(v.id),
+    productId: str(v.product_id),
+    // The storefront picks the default variant of an optionless product by
+    // this exact title, and hides the variant name when it sees it.
+    title: optionless ? "default" : v.label || v.sku,
+    sku: v.sku,
+    barcode: v.barcode ?? null,
+    price: toMajor(v.price),
+    mrp: toMajor(v.compare_at_price ?? v.price),
+    // The engine's own vocabulary, unchanged: `available` is on hand minus
+    // reserved; an untracked variant is never managed, so its count is moot.
+    stock: v.active ? v.available : 0,
+    manageInventory: v.active ? v.track_inventory : true,
+    allowBackorder: v.active && v.continue_selling,
+    active: v.active,
+    weight: v.weight_grams ?? null,
+    length: v.dimensions?.length_mm ?? null,
+    width: v.dimensions?.width_mm ?? null,
+    height: v.dimensions?.height_mm ?? null,
+    images: images.join(","),
+    img: images[0] ?? null,
+    image: images[0] ?? null,
+    thumbnail: images[0] ?? null,
+    // Values in option order — `options[i]` answers `p.options[i]`.
+    options: arr(v.options).map((value, i) => ({ optionId: str(options[i]?.id), value })),
+    metadata: v.metadata ?? null
   };
-};
-var mapProduct = (product) => {
-  if (!product) return null;
-  const variants = activeVariants(product);
-  const priced = variants.length ? variants : product.variants || [];
-  const prices = priced.map((v) => fromMoney(v.price)).filter((n) => Number.isFinite(n));
-  const price = prices.length ? Math.min(...prices) : 0;
-  const compareAtPrices = priced.map((v) => fromMoney(v.compare_at_price)).filter((n) => n > 0);
-  const mrp = compareAtPrices.length ? Math.max(...compareAtPrices) : price;
-  const images = productImages(product);
-  const featured = images[0] || null;
-  const first = primaryVariant(product);
+}
+function toProduct(p, extra = {}) {
+  const live = liveVariants(p);
+  const lead = live[0] ?? arr(p.variants)[0];
+  const optionless = arr(p.options).length === 0;
+  const images = productImages(p);
+  const prices = live.map((v) => toMajor(v.price));
+  const tracked = live.filter((v) => v.track_inventory);
+  const category = p.category;
+  const tags = arr(p.tags);
   return {
-    id: product.id,
-    title: product.title,
-    slug: product.slug,
-    description: product.description || "",
-    price,
-    mrp,
-    featuredImage: featured,
-    active: product.status === "active",
-    status: product.status === "active" ? "published" : product.status || "draft",
-    type: "physical",
-    vendorId: product.vendor || "",
-    categoryId: product.category?.id ?? null,
-    currency: product.currency || null,
-    instructions: null,
-    hsnCode: first?.hs_code || null,
-    // The components read this as a comma-joined list, the way Litekart serves it.
+    id: str(p.id),
+    slug: p.slug,
+    title: p.title,
+    name: p.title,
+    subtitle: null,
+    description: p.description ?? "",
+    status: p.status === "active" ? "published" : p.status,
+    active: p.status === "active",
+    type: p.product_type ?? "",
+    currency: p.currency,
+    currencyCode: p.currency,
+    price: lead ? toMajor(lead.price) : 0,
+    mrp: lead ? toMajor(lead.compare_at_price ?? lead.price) : 0,
+    minPrice: prices.length ? Math.min(...prices) : 0,
+    maxPrice: prices.length ? Math.max(...prices) : 0,
+    sku: lead?.sku ?? null,
+    barcode: lead?.barcode ?? null,
+    weight: lead?.weight_grams ?? null,
+    originCountry: lead?.origin_country ?? null,
+    thumbnail: images[0] ?? null,
+    image_url: images[0] ?? null,
     images: images.join(","),
-    thumbnail: featured,
-    keywords: (product.tags || []).join(",") || null,
-    link: null,
-    metaTitle: product.seo_title || null,
-    metaDescription: product.seo_description || null,
-    subtitle: product.product_type || null,
-    popularity: 0,
-    rank: 0,
-    expiryDate: null,
-    weight: first?.weight ?? null,
-    mfgDate: null,
-    costPerItem: 0,
-    sku: first?.sku || null,
-    stock: priced.reduce((sum, v) => sum + variantStock(v), 0),
-    allowBackorder: Boolean(first?.continue_selling),
-    manageInventory: first?.track_inventory !== false,
-    shippingWeight: null,
-    shippingHeight: null,
-    shippingLen: null,
-    shippingWidth: null,
-    height: null,
-    width: null,
-    len: null,
-    barcode: first?.barcode || null,
-    shippingCost: null,
-    returnAllowed: false,
-    replaceAllowed: false,
-    originCountry: first?.origin_country || null,
-    weightUnit: first?.weight_unit || "g",
-    dimensionUnit: "cm",
-    metadata: flattenMetadata(product.metadata),
-    collectionId: product.collections?.[0]?.id ?? null,
-    tags: product.tags || [],
-    vendor: product.vendor || null,
-    categories: product.category ? [{ category: { id: product.category.id, name: product.category.title, slug: product.category.slug } }] : [],
-    createdAt: product.created_at || null,
-    updatedAt: product.updated_at || null,
-    options: (product.options || []).map((option) => ({
-      id: option.id,
-      title: option.name,
-      type: "radio",
-      values: (option.values || []).map((v) => ({ id: v.id, value: v.value }))
+    imageList: images,
+    // Product-level stock is what a card shows before a variant is picked:
+    // buyable when any live variant is, counted only where counting means
+    // something.
+    manageInventory: live.length > 0 && tracked.length === live.length,
+    allowBackorder: live.some((v) => v.continue_selling),
+    stock: tracked.reduce((n, v) => n + Math.max(0, v.available), 0),
+    hasStock: live.some((v) => !v.track_inventory || v.continue_selling || v.available > 0),
+    categoryId: category ? str(category.id) : null,
+    category: category ? { id: str(category.id), name: category.title, slug: category.slug } : null,
+    categories: category ? [{ category: { id: str(category.id), name: category.title, slug: category.slug } }] : [],
+    categoryHierarchy: extra.categoryHierarchy ?? (category ? [{ name: category.title, slug: category.slug }] : []),
+    collections: arr(p.collections).map((c) => ({ id: str(c.id), name: c.title, slug: c.slug })),
+    // Free text on the engine's product, not a vendor record.
+    vendor: p.vendor ? { businessName: p.vendor } : null,
+    productTags: tags.join(","),
+    keywords: tags.join(","),
+    metaTitle: p.seo_title || p.title,
+    metaDescription: p.seo_description || null,
+    link: `/products/${p.slug}`,
+    options: arr(p.options).map((o) => ({
+      id: str(o.id),
+      title: o.name,
+      name: o.name,
+      type: "text",
+      values: arr(o.values).map((val) => ({ id: str(val.id), value: val.value }))
     })),
-    variants: priced.map((variant) => mapVariant(product, variant))
+    variants: live.map((v) => toVariant(v, p, optionless)),
+    // Filled by the product page from ext/reviews when it is installed.
+    ratings: [],
+    rating: null,
+    ratingCount: 0,
+    reviewCount: 0,
+    attributes: [],
+    metadata: p.metadata ?? null,
+    createdAt: p.created_at,
+    updatedAt: p.updated_at
   };
-};
-var mapCategory = (category) => {
-  if (!category) return null;
+}
+function fromSearchDoc(d) {
+  const price = minorToMajor(d.price_minor, d.currency);
+  return {
+    id: str(d.id),
+    slug: d.slug,
+    title: d.title,
+    name: d.title,
+    description: d.description,
+    currency: d.currency,
+    price,
+    mrp: price,
+    minPrice: price,
+    maxPrice: minorToMajor(d.price_max_minor, d.currency),
+    thumbnail: d.image ?? null,
+    image_url: d.image ?? null,
+    images: d.image ?? "",
+    stock: d.in_stock ? 1 : 0,
+    hasStock: d.in_stock,
+    // The index cannot say how much is left, only whether any is; a card
+    // built from it must not claim to count.
+    manageInventory: false,
+    allowBackorder: false,
+    productTags: arr(d.tags).join(","),
+    category: d.category ? { name: d.category.split(" / ").pop() ?? d.category, slug: "" } : null,
+    vendor: d.vendor ? { businessName: d.vendor } : null,
+    variants: [],
+    options: [],
+    ratings: [],
+    link: `/products/${d.slug}`,
+    updatedAt: new Date(d.updated_at * 1e3).toISOString()
+  };
+}
+function toCategory(c) {
   return {
-    id: category.id,
+    id: str(c.id),
+    name: c.title,
+    title: c.title,
+    slug: c.slug,
+    link: `/${c.slug}`,
+    parentCategoryId: c.parent_id === null || c.parent_id === void 0 ? null : str(c.parent_id),
+    path: c.full_name,
+    level: c.depth,
+    rank: c.position,
+    childCount: c.child_count,
+    thumbnail: c.metadata?.image ?? null,
+    description: c.metadata?.description ?? null,
     isActive: true,
-    isInternal: false,
-    isMegamenu: false,
-    thumbnail: null,
-    path: category.full_name || null,
-    level: category.depth ?? 0,
-    description: null,
     isFeatured: false,
-    keywords: null,
-    rank: category.position ?? 0,
-    link: null,
-    metaDescription: null,
-    metaKeywords: null,
-    metaTitle: null,
-    name: category.title,
-    // The storefront's filter composable rebuilds the tree from this field.
-    parentCategoryId: category.parent_id ?? null,
-    store: null,
-    slug: category.slug,
-    userId: "",
-    activeProducts: 0,
-    inactiveProducts: 0,
-    createdAt: category.created_at || null,
-    updatedAt: category.updated_at || null
+    isMegamenu: false,
+    metaTitle: c.title,
+    children: arr(c.children).map(toCategory),
+    createdAt: c.created_at,
+    updatedAt: c.updated_at
   };
-};
-var mapCollection = (collection) => {
-  if (!collection) return null;
-  const products = collection.products || [];
+}
+function toCollection(c) {
   return {
-    id: collection.id,
-    name: collection.title,
-    slug: collection.slug,
-    description: collection.description || null,
+    id: str(c.id),
+    name: c.title,
+    title: c.title,
+    slug: c.slug,
+    description: c.description || null,
+    subTitle: null,
+    rank: str(c.position),
+    thumbnail: c.metadata?.image ?? null,
     isActive: true,
-    isFeatured: false,
-    userId: "",
-    thumbnail: productImages(products[0])[0] || null,
-    metaTitle: null,
-    metaDescription: null,
-    rank: collection.position ?? 0,
-    collectionvalues: products.map((product) => {
-      const mapped = mapProduct(product);
-      return {
-        products: {
-          id: product.id,
-          name: product.title,
-          title: product.title,
-          slug: product.slug,
-          thumbnail: mapped?.thumbnail || null,
-          price: mapped?.price ?? 0,
-          mrp: mapped?.mrp ?? 0
-        }
-      };
-    }),
-    productCount: products.length,
-    createdAt: collection.created_at || null,
-    updatedAt: collection.updated_at || null
+    metaTitle: c.title,
+    metaDescription: c.description || null,
+    createdAt: c.created_at,
+    updatedAt: c.updated_at
   };
-};
-var lineProduct = (index, productId) => productId == null ? void 0 : index?.get(productId);
-var mapCartLine = (line, index) => {
-  const product = lineProduct(index, line.product_id);
-  const mapped = product ? mapProduct(product) : null;
-  const variant = product?.variants?.find((v) => v.id === line.variant_id);
-  const price = fromMoney(line.unit_price);
-  const compareAt = fromMoney(variant?.compare_at_price);
-  const thumbnail = absoluteMedia(variant?.image?.url) || mapped?.thumbnail || null;
+}
+function fromEngineAddress(a, email) {
+  if (!a) return null;
+  const [firstName, ...rest] = (a.name ?? "").trim().split(/\s+/);
   return {
-    id: line.id,
-    productId: line.product_id,
-    variantId: line.variant_id,
-    qty: line.quantity,
-    subtotal: fromMoney(line.total),
-    discount: 0,
-    tax: 0,
-    shippingCharges: 0,
-    total: fromMoney(line.total),
-    price,
-    mrp: compareAt > price ? compareAt : price,
-    title: line.title || mapped?.title || "",
-    slug: mapped?.slug || "",
-    sku: line.sku || "",
-    description: null,
-    thumbnail,
-    metadata: null,
-    vendorId: null,
-    weight: null,
-    dimensionUnit: "cm",
-    height: null,
-    width: null,
-    len: null,
-    shippingWeight: null,
-    shippingHeight: null,
-    shippingLen: null,
-    shippingWidth: null,
+    firstName: firstName || "",
+    lastName: rest.join(" "),
+    email: email ?? null,
+    phone: a.phone ?? null,
+    address_1: a.line1,
+    address_2: a.line2 ?? "",
+    city: a.city,
+    state: a.state ?? "",
+    zip: a.postal_code,
+    country: a.country,
+    countryCode: a.country
+  };
+}
+function toEngineAddress(a) {
+  const name = [a.firstName, a.lastName].filter(Boolean).join(" ").trim();
+  return {
+    ...name ? { name } : {},
+    ...a.phone ? { phone: String(a.phone) } : {},
+    line1: String(a.address_1 ?? "").trim(),
+    ...a.address_2 || a.locality ? { line2: [a.address_2, a.locality].filter(Boolean).join(", ") } : {},
+    city: String(a.city ?? "").trim(),
+    ...a.state ? { state: String(a.state) } : {},
+    postal_code: String(a.zip ?? "").trim(),
+    country: String(a.countryCode || a.country || "").trim().toUpperCase()
+  };
+}
+function fromIdentityAddress(a, email) {
+  const [firstName, ...rest] = (a.name ?? "").trim().split(/\s+/);
+  return {
+    id: str(a.id),
+    firstName: firstName || "",
+    lastName: rest.join(" "),
+    email: email ?? null,
+    phone: a.phone || null,
+    address_1: a.line1,
+    address_2: a.line2,
+    city: a.city,
+    state: a.state,
+    zip: a.postal_code,
+    country: a.country,
+    countryCode: a.country,
+    label: a.label,
+    isPrimary: a.is_default,
+    createdAt: a.created_at,
+    updatedAt: a.updated_at
+  };
+}
+function toIdentityAddress(a) {
+  const e = toEngineAddress(a);
+  return {
+    name: e.name ?? "",
+    phone: e.phone ?? "",
+    line1: e.line1,
+    line2: e.line2 ?? "",
+    city: e.city,
+    state: e.state ?? "",
+    postal_code: e.postal_code,
+    country: e.country,
+    ...a.label ? { label: String(a.label) } : {},
+    ...a.isPrimary ? { is_default: true } : {}
+  };
+}
+function toCartLine(l, extra = {}) {
+  return {
+    id: str(l.id),
+    productId: str(l.product_id),
+    variantId: str(l.variant_id),
+    sku: l.sku,
+    title: l.title,
+    name: l.title,
+    slug: extra.slug ?? "",
+    thumbnail: extra.thumbnail ?? null,
+    variantTitle: l.variant_label ?? "",
+    qty: l.quantity,
+    price: toMajor(l.unit_price),
+    mrp: toMajor(l.unit_price),
+    subtotal: toMajor(l.total),
+    total: toMajor(l.total),
+    inStock: l.in_stock,
+    priceChanged: l.price_changed,
+    currentPrice: toMajor(l.current_price),
+    // The storefront's review step lists only lines marked for checkout. The
+    // engine checks a cart out whole, so every line is.
     isSelectedForCheckout: true,
-    // Surfaced so the cart can warn, instead of letting checkout refuse the whole order later.
-    priceChanged: Boolean(line.price_changed),
-    inStock: line.in_stock !== false,
-    createdAt: null,
-    product: {
-      id: line.product_id,
-      title: line.title || mapped?.title || "",
-      thumbnail,
-      slug: mapped?.slug || "",
-      sku: line.sku || "",
-      categories: mapped?.categories || []
-    },
     variant: {
-      id: line.variant_id,
-      price,
-      mrp: compareAt > price ? compareAt : price,
-      weight: null,
-      height: null,
-      width: null,
-      len: null,
-      shippingWeight: null,
-      shippingHeight: null,
-      shippingLen: null,
-      shippingWidth: null,
-      sku: line.sku || "",
-      title: line.variant_label || variant?.label || "default",
-      options: variant && product ? mapVariant(product, variant).options : []
-    }
+      id: str(l.variant_id),
+      options: l.variant_label ? l.variant_label.split(" / ").map((value) => ({ option: { title: "" }, value })) : []
+    },
+    product: { id: str(l.product_id), categories: [] }
   };
-};
-var mapCart = (cart, details = {}, index, store) => {
-  if (!cart) return {};
-  const currency = cart.currency || store?.currency?.code || "USD";
-  const lines = cart.line_items || [];
-  const subtotal = fromMoney(cart.subtotal);
-  const shippingAddress = details.shippingAddress || null;
-  const billingAddress = details.billingAddress || shippingAddress;
+}
+function toCart(c, extras = {}, lineExtra = () => ({})) {
+  const lines = c.status === "converted" ? [] : arr(c.line_items);
+  const currency = c.currency;
+  const subtotalMinor = lines.reduce((n, l) => n + l.total.amount_minor, 0);
+  const discountMinor = extras.discount && !extras.discount.free_shipping ? extras.discount.amount_minor : 0;
+  const shippingMinor = extras.discount?.free_shipping ? 0 : extras.shippingRate?.minor ?? 0;
+  const totalMinor = Math.max(0, subtotalMinor - discountMinor) + shippingMinor;
+  const money = (minor) => minorToMajor(minor, currency);
+  const ship = extras.shippingAddress ?? null;
   return {
-    id: cart.id,
-    email: cart.email || details.email || null,
-    phone: details.phone || shippingAddress?.phone || null,
-    name: details.name || null,
-    // The payment step gates on an id as well as the address itself. There is no address record
-    // in GoCommerce to have an id of its own, so the cart it belongs to names it.
-    billingAddressId: billingAddress ? `${cart.id}-billing` : null,
-    shippingAddressId: shippingAddress ? `${cart.id}-shipping` : null,
-    regionId: null,
-    userId: null,
-    couponCode: null,
+    id: c.id,
+    status: c.status,
+    email: c.email ?? ship?.email ?? null,
+    phone: extras.phone ?? ship?.phone ?? null,
+    name: ship ? [ship.firstName, ship.lastName].filter(Boolean).join(" ") : null,
+    lineItems: lines.map((l) => toCartLine(l, lineExtra(l))),
+    qty: lines.reduce((n, l) => n + l.quantity, 0),
+    currencyCode: currency,
+    currency,
+    subtotal: money(subtotalMinor),
+    discountAmount: money(discountMinor),
+    savingAmount: money(discountMinor),
+    couponCode: extras.discount?.code ?? null,
+    discount: extras.discount ?? null,
+    shippingCharges: money(shippingMinor),
+    shippingRateId: extras.shippingRateId ?? null,
+    shippingMethod: extras.shippingRate?.name ?? null,
+    tax: 0,
+    taxIncluded: false,
+    codCharges: 0,
+    total: money(totalMinor),
+    shippingAddress: ship,
+    shippingAddressId: ship ? ship.id && ship.id !== "new" ? String(ship.id) : "cart" : null,
+    billingAddress: extras.billingAddress ?? ship,
+    billingAddressId: extras.billingAddress ? extras.billingAddress.id && extras.billingAddress.id !== "new" ? String(extras.billingAddress.id) : "cart-billing" : ship ? ship.id && ship.id !== "new" ? String(ship.id) : "cart" : null,
+    paymentMethod: null,
+    needAddress: lines.length > 0,
+    completedAt: c.status === "converted" ? c.updated_at : null,
+    createdAt: c.created_at,
+    updatedAt: c.updated_at,
+    expiresAt: c.expires_at
+  };
+}
+function emptyCart(currency = "USD") {
+  return {
+    id: "",
+    status: "open",
+    email: null,
+    phone: null,
+    lineItems: [],
+    qty: 0,
+    currencyCode: currency,
+    subtotal: 0,
     discountAmount: 0,
-    couponAppliedDate: null,
-    needAddress: !shippingAddress,
-    isCodAvailable: true,
-    paymentId: null,
-    type: null,
-    completedAt: cart.status === "converted" ? cart.updated_at || null : null,
-    paymentAuthorizedAt: null,
-    idempotencyKey: null,
-    salesChannelId: null,
-    qty: cart.item_count ?? lines.reduce((sum, l) => sum + (l.quantity || 0), 0),
-    // GoCommerce prices shipping at checkout, not on the cart, so there is nothing honest to put
-    // here yet — and a fabricated number is the one the shopper would check the total against.
+    savingAmount: 0,
+    couponCode: null,
     shippingCharges: 0,
-    paymentMethod: null,
-    shippingMethod: null,
-    subtotal,
-    codCharges: 0,
     tax: 0,
-    total: subtotal,
-    savingAmount: 0,
-    userAuthToken: null,
+    total: 0,
+    shippingAddress: null,
+    shippingAddressId: null,
+    billingAddress: null,
+    billingAddressId: null
+  };
+}
+var STATUS = {
+  pending: "Pending",
+  confirmed: "Confirmed",
+  partial: "Partially shipped",
+  shipped: "Shipped",
+  delivered: "Delivered",
+  cancelled: "Cancelled"
+};
+var PAYMENT_STATUS = {
+  pending: "Pending",
+  paid: "Paid",
+  failed: "Failed",
+  refunded: "Refunded"
+};
+function toOrderLine(l, currency) {
+  return {
+    id: str(l.id),
+    productId: str(l.product_id),
+    variantId: str(l.variant_id),
+    sku: l.sku,
+    title: l.title,
+    name: l.title,
+    slug: "",
+    thumbnail: l.image_url ?? null,
+    img: l.image_url ?? null,
+    variantTitle: l.variant_label ?? "",
+    qty: l.quantity,
+    shippedQty: l.shipped_quantity,
+    price: toMajor(l.unit_price),
+    mrp: toMajor(l.unit_price),
+    subtotal: toMajor(l.total),
+    total: toMajor(l.total),
     currencyCode: currency,
-    currencySymbol: store?.currency?.symbol || "",
-    shippingRateId: null,
-    currencyDecimalDigits: currencyFractionDigits(currency),
-    storeId: store?.id ?? null,
-    status: cart.status || "open",
-    createdAt: cart.created_at || null,
-    updatedAt: cart.updated_at || null,
-    deletedAt: null,
-    lineItems: lines.map((line) => mapCartLine(line, index)),
-    shippingAddress,
-    billingAddress
+    status: l.shipped_quantity >= l.quantity ? "Shipped" : "Pending",
+    files: [],
+    usedOptions: []
   };
-};
-var splitName = (name) => {
-  const parts = (name || "").trim().split(/\s+/).filter(Boolean);
-  return { firstName: parts[0] || "", lastName: parts.slice(1).join(" ") };
-};
-var toStorefrontAddress = (address, email, phone) => {
-  if (!address) return null;
-  const { firstName, lastName } = splitName(address.name);
+}
+function toOrder(o) {
+  const address = fromEngineAddress(o.address, o.email);
+  const code = (o.discounts ?? []).find((d) => d.code)?.code;
   return {
-    id: null,
-    firstName,
-    lastName,
-    email: email || null,
-    phone: address.phone || phone || "",
-    address_1: address.line1 || "",
-    address_2: address.line2 || "",
-    city: address.city || "",
-    state: address.state || "",
-    zip: address.postal_code || "",
-    country: address.country || "",
-    countryCode: address.country || "",
-    isPrimary: false,
-    isResidential: true,
-    deliveryInstructions: null
+    id: str(o.id),
+    orderNo: o.number,
+    orderNumber: o.number,
+    number: o.number,
+    // The storefront links an order by this; the engine has no sub-orders,
+    // so an order is its own parent.
+    parentOrderNo: o.number,
+    status: STATUS[o.status] ?? o.status,
+    engineStatus: o.status,
+    paymentStatus: PAYMENT_STATUS[o.payment_status] ?? o.payment_status,
+    paymentMethod: o.payment_provider.toUpperCase(),
+    currencyCode: o.currency,
+    subtotal: toMajor(o.subtotal),
+    shippingCharges: toMajor(o.shipping),
+    discount: toMajor(o.discount),
+    tax: toMajor(o.tax),
+    taxIncluded: o.tax_inclusive,
+    total: toMajor(o.total),
+    refunded: toMajor(o.refunded),
+    codCharges: 0,
+    coupon: code ? { code } : null,
+    userEmail: o.email,
+    email: o.email,
+    phone: o.phone ?? null,
+    shippingAddress: address,
+    billingAddress: address,
+    shippingMethod: o.shipping_method ?? null,
+    shippingRate: o.shipping_method ? { name: o.shipping_method } : null,
+    lineItems: arr(o.line_items).map((l) => toOrderLine(l, o.currency)),
+    fulfillments: arr(o.fulfillments).map((f) => ({
+      id: str(f.id),
+      status: f.status,
+      carrier: f.carrier_name || f.carrier || f.provider,
+      trackingNumber: f.tracking ?? null,
+      trackingUrl: f.tracking_url ?? null,
+      lineItems: arr(f.lines).map((l) => ({ id: str(l.order_line_id), title: l.title, qty: l.quantity })),
+      createdAt: f.created_at
+    })),
+    tracking: [],
+    orderHistory: [],
+    isReplaceOrReturn: false,
+    createdAt: o.created_at,
+    updatedAt: o.updated_at
   };
-};
-var toGoCommerceAddress = (address, fallbackPhone) => {
-  if (!address) return null;
-  const name = [address.firstName, address.lastName].filter(Boolean).join(" ").trim() || address.name || "";
-  const line1 = address.address_1 || address.line1 || "";
-  const city = address.city || "";
-  const postal = address.zip || address.postal_code || "";
-  const country = address.countryCode || address.country_code || address.country || "";
-  if (!line1 || !city || !postal || !country) return null;
+}
+function toRating(r) {
   return {
-    name,
-    phone: address.phone || fallbackPhone || "",
-    line1,
-    line2: address.address_2 || address.line2 || "",
-    city,
-    state: address.state || "",
-    postal_code: postal,
-    // GoCommerce wants ISO 3166-1 alpha-2; the form may hold a full country name alongside it.
-    country: String(country).length === 2 ? String(country).toUpperCase() : String(country)
+    id: str(r.id),
+    rating: r.rating,
+    name: r.name,
+    title: r.title ?? "",
+    review: r.body,
+    message: r.body,
+    reply: r.reply ?? null,
+    verified: r.verified,
+    img: "",
+    createdAt: r.created_at
   };
-};
-var mapOrder = (order, index) => {
-  if (!order) return null;
-  const shippingAddress = toStorefrontAddress(order.address, order.email, order.phone);
+}
+function toCmsPage(p) {
   return {
-    id: order.id,
-    orderNo: order.number,
-    order_no: order.number,
-    // The orders list links a detail page by parentOrderNo; the number is the handle here.
-    parentOrderNo: order.number,
-    status: order.status || "pending",
-    paymentStatus: order.payment_status || "pending",
-    paymentMethod: order.payment_provider || null,
-    createdAt: order.created_at || null,
-    updatedAt: order.updated_at || null,
-    userEmail: order.email || "",
-    phone: order.phone || "",
-    subtotal: fromMoney(order.subtotal),
-    shippingCharges: fromMoney(order.shipping),
-    discount: fromMoney(order.discount),
-    total: fromMoney(order.total),
-    currencyCode: order.currency,
-    currencyDecimalDigits: currencyFractionDigits(order.currency),
-    shippingRate: null,
-    fulfillments: (order.fulfillments || []).map((f) => ({
-      id: f.id,
-      status: f.status || "",
-      provider: f.provider || "",
-      trackingNumber: f.tracking || "",
-      labelUrl: f.label_url || "",
-      createdAt: f.created_at || null
-    })),
-    shippingAddress,
-    billingAddress: shippingAddress,
-    lineItems: (order.line_items || []).map((line) => {
-      const product = lineProduct(index, line.product_id);
-      const mapped = product ? mapProduct(product) : null;
-      const variant = product?.variants?.find((v) => v.id === line.variant_id);
-      return {
-        id: line.id,
-        productId: line.product_id,
-        variantId: line.variant_id,
-        title: line.title || mapped?.title || "",
-        variantTitle: line.variant_label || line.sku || "",
-        slug: mapped?.slug || "",
-        sku: line.sku || "",
-        thumbnail: absoluteMedia(variant?.image?.url) || mapped?.thumbnail || null,
-        qty: line.quantity,
-        price: fromMoney(line.unit_price),
-        // The orders list prints `total`; the confirmation page prints `subtotal`.
-        subtotal: fromMoney(line.total),
-        total: fromMoney(line.total)
-      };
-    })
+    id: str(p.id),
+    slug: p.slug,
+    name: p.title,
+    title: p.title,
+    content: p.body,
+    excerpt: p.excerpt ?? null,
+    layouts: [],
+    language: p.language,
+    metaTitle: p.seo?.title || p.title,
+    metaDescription: p.seo?.description || p.excerpt || null,
+    metaKeywords: p.seo?.keywords || null,
+    publishedAt: p.published_at ?? null,
+    createdAt: p.created_at,
+    updatedAt: p.updated_at
   };
-};
-
-// src/services/checkout-details.ts
-var DETAILS_PREFIX = "gocommerce_checkout_";
-var ORDER_TOKENS_KEY = "gocommerce_order_tokens";
-var storage = () => {
-  try {
-    return typeof window !== "undefined" && window.localStorage ? window.localStorage : void 0;
-  } catch {
-    return void 0;
-  }
-};
-var readJson = (key) => {
-  const store = storage();
-  if (!store) return void 0;
-  try {
-    const raw = store.getItem(key);
-    return raw ? JSON.parse(raw) : void 0;
-  } catch {
-    return void 0;
-  }
-};
-var writeJson = (key, value) => {
-  const store = storage();
-  if (!store) return;
-  try {
-    store.setItem(key, JSON.stringify(value));
-  } catch {
-  }
-};
-var readCheckoutDetails = (cartId) => {
-  if (!cartId) return {};
-  return readJson(`${DETAILS_PREFIX}${cartId}`) ?? {};
-};
-var writeCheckoutDetails = (cartId, patch) => {
-  if (!cartId) return patch;
-  const merged = { ...readCheckoutDetails(cartId), ...patch };
-  writeJson(`${DETAILS_PREFIX}${cartId}`, merged);
-  return merged;
-};
-var clearCheckoutDetails = (cartId) => {
-  const store = storage();
-  if (!store || !cartId) return;
-  try {
-    store.removeItem(`${DETAILS_PREFIX}${cartId}`);
-  } catch {
-  }
-};
-var rememberOrderToken = (orderNumber, token) => {
-  if (!orderNumber || !token) return;
-  const tokens = readJson(ORDER_TOKENS_KEY) ?? {};
-  tokens[orderNumber] = token;
-  writeJson(ORDER_TOKENS_KEY, tokens);
-};
-var readOrderToken = (orderNumber) => {
-  if (!orderNumber) return void 0;
-  return (readJson(ORDER_TOKENS_KEY) ?? {})[orderNumber];
-};
-var readOrderNumbers = () => Object.keys(readJson(ORDER_TOKENS_KEY) ?? {});
+}
+function toVendor(v) {
+  return {
+    id: str(v.id),
+    slug: v.slug,
+    name: v.name,
+    businessName: v.name,
+    about: v.about,
+    description: v.about,
+    website: v.website,
+    address: v.address,
+    banners: [],
+    rating: null
+  };
+}
+function toUser(c) {
+  const [firstName, ...rest] = (c.name ?? "").trim().split(/\s+/);
+  return {
+    id: str(c.id),
+    userId: str(c.id),
+    email: c.email,
+    emailVerified: c.email_verified,
+    phone: c.phone || null,
+    firstName: firstName || "",
+    lastName: rest.join(" "),
+    name: c.name,
+    fullName: c.name,
+    avatar: null,
+    role: "USER",
+    createdAt: c.created_at,
+    updatedAt: c.updated_at
+  };
+}
 
-// src/services/address-book.ts
-var ADDRESSES_KEY = "gocommerce_addresses";
-var storage2 = () => {
-  try {
-    return typeof window !== "undefined" && window.localStorage ? window.localStorage : void 0;
-  } catch {
-    return void 0;
-  }
-};
-var readAll = () => {
-  const store = storage2();
-  if (!store) return [];
-  try {
-    const raw = store.getItem(ADDRESSES_KEY);
-    const parsed = raw ? JSON.parse(raw) : [];
-    return Array.isArray(parsed) ? parsed : [];
-  } catch {
-    return [];
-  }
-};
-var writeAll = (addresses) => {
-  const store = storage2();
-  if (!store) return;
-  try {
-    store.setItem(ADDRESSES_KEY, JSON.stringify(addresses));
-  } catch {
-  }
-};
-var isSavedId = (id) => typeof id === "string" && id.length > 0 && id !== "new";
-var newId = () => `addr_${Math.random().toString(36).slice(2, 10)}${Date.now().toString(36)}`;
-var listAddresses = () => readAll();
-var findAddress = (id) => readAll().find((a) => a.id === id);
-var putAddress = (address) => {
-  const addresses = readAll();
-  const id = isSavedId(address.id) ? address.id : newId();
-  const saved = { ...address, id };
-  const index = addresses.findIndex((a) => a.id === id);
-  if (index >= 0) addresses[index] = saved;
-  else addresses.push(saved);
-  writeAll(addresses);
-  return saved;
-};
-var patchAddress = (id, patch) => {
-  const existing = findAddress(id);
-  if (!existing) return void 0;
-  return putAddress({ ...existing, ...patch, id });
-};
-var removeAddress = (id) => {
-  writeAll(readAll().filter((a) => a.id !== id));
-};
-var SESSION_COOKIES = ["connect.sid", "me"];
-var clearPhantomSession = () => {
-  if (typeof document === "undefined") return;
-  for (const name of SESSION_COOKIES) {
-    document.cookie = `${name}=; Max-Age=0; path=/`;
-    document.cookie = `${name}=; Max-Age=0`;
-  }
-};
-var hasPhantomSession = () => typeof document !== "undefined" && SESSION_COOKIES.some((name) => new RegExp(`(^|;\\s*)${name.replace(".", "\\.")}=`).test(document.cookie));
+// src/cache.ts
+var TTL_MS = 6e4;
+var entries = /* @__PURE__ */ new Map();
+function remember(key, load, ttl = TTL_MS) {
+  const hit = entries.get(key);
+  if (hit && Date.now() - hit.at < ttl) return hit.value;
+  const value = load();
+  entries.set(key, { at: Date.now(), value });
+  value.catch(() => {
+    if (entries.get(key)?.value === value) entries.delete(key);
+  });
+  return value;
+}
 
-// src/services/catalog.ts
-var productCache = /* @__PURE__ */ new Map();
-var categorySlugById = /* @__PURE__ */ new Map();
-var remember = (products) => {
-  for (const product of products) {
-    if (product?.id != null) productCache.set(product.id, product);
-    if (product?.category?.id != null && product.category.slug) categorySlugById.set(product.category.id, product.category.slug);
-  }
-  return products;
-};
-var rememberCategories = (categories) => {
-  for (const category of categories) {
-    if (category?.id != null && category.slug) categorySlugById.set(category.id, category.slug);
-    if (category?.children?.length) rememberCategories(category.children);
+// src/services/facts.ts
+var StoreFacts = class extends BaseService {
+  key(name) {
+    return `${this.engineBase()}|${this.creds.store ?? ""}|${name}`;
+  }
+  /** Enabled plugins by key. A module that is not installed has no key here. */
+  plugins() {
+    return remember(this.key("plugins"), async () => {
+      const list = await this.data("/api/plugins") ?? [];
+      return new Map(list.map((p) => [p.key, p]));
+    });
   }
-  return categories;
-};
-var query = (params) => {
-  const search = new URLSearchParams();
-  for (const [key, value] of Object.entries(params)) {
-    if (value === void 0 || value === "") continue;
-    search.set(key, String(value));
-  }
-  const qs = search.toString();
-  return qs ? `?${qs}` : "";
-};
-var ProductService = class _ProductService extends BaseService {
-  static instance;
-  static getInstance() {
-    if (!_ProductService.instance) _ProductService.instance = new _ProductService();
-    return _ProductService.instance;
-  }
-  /** One window of the catalogue, raw. Everything else in this file is built on it. */
-  async fetchProducts({ q, page = 1, limit = PAGE_SIZE } = {}) {
-    const res = await this.api("GET", `/api/products${query({ q, page, limit })}`);
-    return { products: remember(res.data || []), meta: res.meta };
-  }
-  /** A product by its numeric id — how a cart line names what is in it. */
-  async fetchProductById(id) {
-    const cached = productCache.get(id);
-    if (cached) return cached;
+  async pluginOn(key) {
     try {
-      const res = await this.api("GET", `/api/products/${id}`);
-      if (res.data) remember([res.data]);
-      return res.data ?? null;
+      return (await this.plugins()).has(key);
     } catch {
-      return null;
-    }
-  }
-  async fetchProductBySlug(slug) {
-    const res = await this.api("GET", `/api/products/slug/${encodeURIComponent(slug)}`);
-    if (res.data) remember([res.data]);
-    return res.data ?? null;
-  }
-  async list({ page = 1, search = "", sort = "" } = {}) {
-    if (sortNeedsWholeCatalogue(sort)) {
-      const { products: products2, meta: meta2 } = await this.fetchProducts({ q: search, page: 1, limit: MAX_LIMIT });
-      const sorted = sortProducts(products2, sort);
-      const start = (page - 1) * PAGE_SIZE;
-      return paginated(sorted.slice(start, start + PAGE_SIZE).map(mapProduct), meta2?.total ?? sorted.length, page);
+      return false;
     }
-    const { products, meta } = await this.fetchProducts({ q: search, page, limit: PAGE_SIZE });
-    return fromListMeta(products.map(mapProduct), meta, page);
   }
-  // GoCommerce records no "featured" or "trending" flag, and inventing one would rank the catalogue
-  // by nothing. Newest first is the honest reading of both, and it is what the homepage asks for.
-  async listFeaturedProducts({ page = 1, sort = "-createdAt" } = {}) {
-    return this.list({ page, sort });
+  /** The store's settlement currency and default language. */
+  ready() {
+    return remember(this.key("ready"), () => this.data("/health/ready"));
   }
-  async listTrendingProducts({ page = 1, search = "", sort = "-createdAt" } = {}) {
-    return this.list({ page, search, sort });
+  checkoutOptions() {
+    return remember(this.key("checkout"), () => this.data("/api/checkout"));
   }
-  /** The "you may also like" rail: the rest of the product's own category. */
-  async listRelatedProducts({ page = 1, categoryId = "" } = {}) {
-    const slug = await resolveCategorySlug(categoryId);
-    if (!slug) return emptyPage(page);
-    const { products, meta } = await categoryService.fetchCategoryPage(slug, { limit: MAX_LIMIT });
-    const start = (page - 1) * PAGE_SIZE;
-    return paginated(products.slice(start, start + PAGE_SIZE).map(mapProduct), meta?.total ?? products.length, page);
-  }
-  async getOne(slug) {
-    return mapProduct(await this.fetchProductBySlug(slug));
-  }
-  /** A product's variants, for a PDP that wants them without re-reading the product. */
-  async listVariants(productId) {
-    const res = await this.api("GET", `/api/variants${query({ product_id: productId, limit: MAX_LIMIT })}`);
-    return fromListMeta(res.data || [], res.meta);
-  }
-  // GoCommerce ships no review API, and a silent success would tell the shopper their review was
-  // saved when nothing left the browser.
-  async addReview(_params) {
-    throw new Error("Product reviews are not available on this store.");
+  /**
+   * The whole tree, flat and depth-first. Past 500 categories the engine
+   * answers a truncated list; the tree then serves what it has, and a
+   * breadcrumb for a category outside it falls back to the category alone.
+   */
+  categories() {
+    return remember(
+      this.key("categories"),
+      async () => await this.data("/api/categories", { query: { flat: 1 } }) ?? []
+    );
   }
-  async fetchReels() {
-    return { data: [], count: 0 };
+  /** Root → `slug`, by walking parents in the flat tree. */
+  async hierarchy(slug) {
+    const all = await this.categories().catch(() => []);
+    const byId = new Map(all.map((c2) => [c2.id, c2]));
+    const out = [];
+    let c = all.find((x) => x.slug === slug);
+    while (c) {
+      out.unshift({ name: c.title, slug: c.slug });
+      c = c.parent_id === null ? void 0 : byId.get(c.parent_id);
+    }
+    return out;
+  }
+  /** `slug` and every category under it — what a category page sells. */
+  async subtree(slug) {
+    const all = await this.categories();
+    const root = all.find((c) => c.slug === slug);
+    if (!root) return [];
+    const ids = /* @__PURE__ */ new Set([root.id]);
+    const out = [root];
+    for (const c of all) {
+      if (c.parent_id !== null && ids.has(c.parent_id) && !ids.has(c.id)) {
+        ids.add(c.id);
+        out.push(c);
+      }
+    }
+    return out;
   }
 };
-var productService = ProductService.getInstance();
-var CategoryService = class _CategoryService extends BaseService {
-  static instance;
-  static getInstance() {
-    if (!_CategoryService.instance) _CategoryService.instance = new _CategoryService();
-    return _CategoryService.instance;
-  }
-  /**
-   * `use-category-filters` in @misiki/kitcommerce-core fetches the tree by raw Litekart REST path
-   * rather than a typed method. On a GoCommerce store that url resolves against the storefront's
-   * own origin, so route that one path to the real tree; `fetchAllCategories` already returns the
-   * `{ data }` shape it reads.
-   */
-  async get(url) {
-    if (typeof url === "string" && url.startsWith("/api/categories/all")) {
-      return await this.fetchAllCategories();
+
+// src/services/catalog.ts
+var PAGE_SIZE = 24;
+function indexSort(sort) {
+  if (!sort) return void 0;
+  const s = sort.trim();
+  const [field, dir] = s.startsWith("-") ? [s.slice(1), "desc"] : s.includes(":") ? s.split(":") : [s, "asc"];
+  const d = dir === "desc" ? "desc" : "asc";
+  switch (field) {
+    case "price":
+      return `price_minor:${d}`;
+    case "updatedAt":
+    case "updated_at":
+    case "createdAt":
+    case "created_at":
+      return `updated_at:${d}`;
+    case "title":
+    case "name":
+      return `title:${d}`;
+    default:
+      return void 0;
+  }
+}
+var NATURAL = /* @__PURE__ */ new Set([
+  "-createdAt",
+  "createdAt:desc",
+  "-updatedAt",
+  "updatedAt:desc",
+  "-popularity",
+  "popularity:desc"
+]);
+var quote = (s) => `"${s.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+var CatalogService = class extends BaseService {
+  facts = new StoreFacts(this._fetch);
+  async queryCatalog(q) {
+    const page = Math.max(1, Number(q.page) || 1);
+    const limit = Math.min(100, Math.max(1, Number(q.limit) || PAGE_SIZE));
+    const search = q.search?.trim() || void 0;
+    const wantsRange = Number.isFinite(q.priceFrom) || Number.isFinite(q.priceTo);
+    const sortKey = q.sort && !NATURAL.has(q.sort) ? indexSort(q.sort) : void 0;
+    const hierarchy = q.category ? await this.facts.hierarchy(q.category) : [];
+    if ((sortKey || wantsRange) && await this.facts.pluginOn("meilisearch")) {
+      const filters = [];
+      if (q.category) {
+        const names = (await this.facts.subtree(q.category).catch(() => [])).map(
+          (c) => quote(c.full_name)
+        );
+        if (!names.length) return { ...emptyCatalog(limit), categoryHierarchy: hierarchy, sorted: true };
+        filters.push(`category IN [${names.join(", ")}]`);
+      }
+      if (wantsRange) {
+        const { currency } = await this.facts.ready();
+        if (Number.isFinite(q.priceFrom)) filters.push(`price_minor >= ${toMinor(q.priceFrom, currency)}`);
+        if (Number.isFinite(q.priceTo)) filters.push(`price_minor <= ${toMinor(q.priceTo, currency)}`);
+      }
+      const res = await this.data("/x/meilisearch/search", {
+        query: {
+          q: search ?? "",
+          limit,
+          offset: (page - 1) * limit,
+          filter: filters.join(" AND ") || void 0,
+          sort: sortKey
+        }
+      });
+      const total = res.total ?? 0;
+      return {
+        data: (res.hits ?? []).map(fromSearchDoc),
+        count: total,
+        pageSize: limit,
+        noOfPage: Math.max(1, Math.ceil(total / limit)),
+        page,
+        categoryHierarchy: hierarchy,
+        sorted: true
+      };
+    }
+    const sorted = !sortKey && !wantsRange;
+    if (q.category && !search) {
+      const env2 = await this.engine(
+        `/api/categories/${encodeURIComponent(q.category)}`,
+        { query: { page, limit } }
+      );
+      const products = env2.data?.products ?? [];
+      return {
+        ...toPage({ data: products, meta: env2.meta }, (p) => toProduct(p)),
+        categoryHierarchy: hierarchy,
+        sorted
+      };
     }
-    return super.get(url);
+    const env = await this.engine("/api/products", {
+      query: { q: search, page, limit, channel: this.creds.channel }
+    });
+    return { ...toPage(env, (p) => toProduct(p)), categoryHierarchy: hierarchy, sorted };
   }
+};
+function emptyCatalog(limit = PAGE_SIZE) {
+  return { data: [], count: 0, pageSize: limit, noOfPage: 0, page: 1 };
+}
+
+// src/services/product-service.ts
+var ProductService = class extends CatalogService {
   /**
-   * The taxonomy, flattened.
+   * A product page. `slug` may also be a numeric id or a variant SKU, which is
+   * how an old link or a search hit sometimes arrives.
    *
-   * `GET /api/categories` answers with one fixed window and ignores `limit`/`page`, so this is
-   * every category the storefront can see — roots plus what fits beneath them. A store that has
-   * imported a full retail taxonomy has far more nodes than that; the ones a shopper reaches are
-   * still reachable, because a listing page looks its category up by slug directly.
+   * Reviews ride along when ext/reviews is installed and switched on; a review
+   * failure never costs the shopper the product page.
    */
-  async fetchAllCategories() {
-    const res = await this.api("GET", `/api/categories${query({ flat: "true" })}`);
-    const categories = rememberCategories(res.data || []);
-    return paginated(categories.map(mapCategory), categories.length, 1, categories.length || PAGE_SIZE);
-  }
-  /** A category and the active products filed under it or anything beneath it. */
-  async fetchCategoryPage(slug, { limit = MAX_LIMIT, offset = 0 } = {}) {
-    const res = await this.api("GET", `/api/categories/${encodeURIComponent(slug)}${query({ limit, offset })}`);
-    const category = res.data;
-    if (category) rememberCategories([category]);
-    const products = remember(category?.products || []);
-    return { category, products, meta: res.meta };
-  }
-  async fetchCategory(slugOrId) {
-    const { category } = await this.fetchCategoryPage(String(slugOrId), { limit: 1 });
-    return mapCategory(category);
-  }
-  async fetchFooterCategories({ page = 1, q = "" } = {}) {
-    const all = await this.fetchAllCategories();
-    const filtered = q ? all.data.filter((c) => c?.name?.toLowerCase().includes(q.toLowerCase())) : all.data;
-    const start = (page - 1) * PAGE_SIZE;
-    return paginated(filtered.slice(start, start + PAGE_SIZE), filtered.length, page);
-  }
-  /** The homepage grid: the roots of the taxonomy, which is what a shopper navigates from. */
-  async fetchFeaturedCategories({ limit = 18 } = {}) {
-    const all = await this.fetchAllCategories();
-    const roots = all.data.filter((c) => c && c.parentCategoryId == null);
-    const picked = (roots.length ? roots : all.data).slice(0, limit);
-    return paginated(picked, picked.length, 1, limit);
-  }
-  async fetchAllProductsOfCategories(slugOrId) {
-    const slug = await resolveCategorySlug(slugOrId) || String(slugOrId);
-    const { products, meta } = await this.fetchCategoryPage(slug);
-    return fromListMeta(products.map(mapProduct), meta);
+  async getOne(slug) {
+    const p = await this.findProduct(String(slug));
+    const product = toProduct(p, {
+      categoryHierarchy: p.category ? await this.facts.hierarchy(p.category.slug) : []
+    });
+    if (await this.facts.pluginOn("product-reviews")) {
+      try {
+        const res = await this.data("/x/reviews", { query: { product_id: p.id, limit: 50 } });
+        product.ratings = (res.reviews ?? []).map(toRating);
+        product.rating = res.summary?.count ? res.summary.average : null;
+        product.ratingCount = res.summary?.count ?? 0;
+        product.reviewCount = res.summary?.count ?? 0;
+      } catch {
+      }
+    }
+    return product;
   }
-  async getMegamenu() {
-    return this.fetchFeaturedCategories({ limit: 50 });
+  async findProduct(slug) {
+    try {
+      return await this.data(`/api/products/slug/${encodeURIComponent(slug)}`);
+    } catch (err) {
+      if (!(err instanceof GoCommerceError) || err.status !== 404) throw err;
+      const fallback = /^\d+$/.test(slug) ? `/api/products/${slug}` : `/api/products/sku/${encodeURIComponent(slug)}`;
+      try {
+        return await this.data(fallback);
+      } catch {
+        throw err;
+      }
+    }
   }
-};
-var categoryService = CategoryService.getInstance();
-var resolveCategorySlug = async (categoryId) => {
-  if (categoryId === void 0 || categoryId === null || categoryId === "") return void 0;
-  const asNumber = Number(categoryId);
-  if (!Number.isFinite(asNumber)) return String(categoryId);
-  const known = categorySlugById.get(asNumber);
-  if (known) return known;
-  await categoryService.fetchAllCategories();
-  return categorySlugById.get(asNumber);
-};
-var CollectionService = class _CollectionService extends BaseService {
-  static instance;
-  static getInstance() {
-    if (!_CollectionService.instance) _CollectionService.instance = new _CollectionService();
-    return _CollectionService.instance;
-  }
-  async list({ page = 1, q = "" } = {}) {
-    const res = await this.api("GET", `/api/collections${query({ page, limit: PAGE_SIZE })}`);
-    const items = res.data || [];
-    const filtered = q ? items.filter((c) => c.title?.toLowerCase().includes(q.toLowerCase())) : items;
-    return fromListMeta(
-      filtered.map((c) => mapCollection(c)),
-      res.meta,
-      page
-    );
+  /** The shop's listing: `{ page, search, sort }`, newest first unless the index can reorder it. */
+  async list({
+    page = 1,
+    search,
+    q,
+    sort,
+    limit,
+    categories
+  } = {}) {
+    const res = await this.queryCatalog({ page, search: search ?? q, sort, limit, category: categories || void 0 });
+    return { data: res.data, count: res.count, pageSize: res.pageSize, noOfPage: res.noOfPage, page: res.page };
+  }
+  async listFeaturedProducts({ page = 1, sort, limit } = {}) {
+    return this.shelf("featured", { page, sort, limit });
+  }
+  async listTrendingProducts({ page = 1, limit } = {}) {
+    return this.shelf("trending", { page, limit });
+  }
+  /** More from this product's category. */
+  async listRelatedProducts({
+    page = 1,
+    categoryId,
+    limit
+  } = {}) {
+    if (!categoryId) return this.list({ page, limit });
+    const category = (await this.facts.categories()).find((c) => String(c.id) === String(categoryId));
+    if (!category) return this.list({ page, limit });
+    return this.list({ page, limit, categories: category.slug });
+  }
+  async shelf(slug, { page, sort, limit }) {
+    const size = Math.min(100, Math.max(1, Number(limit) || PAGE_SIZE));
+    try {
+      const env = await this.engine(`/api/collections/${slug}`, {
+        query: { page, limit: size }
+      });
+      const rows = env.data?.products ?? [];
+      return {
+        data: rows.map((p) => toProduct(p)),
+        count: env.meta?.total ?? rows.length,
+        pageSize: env.meta?.limit ?? size,
+        noOfPage: env.meta?.total_pages ?? 1,
+        page: env.meta?.page ?? page
+      };
+    } catch (err) {
+      if (!(err instanceof GoCommerceError) || err.status !== 404) throw err;
+      return this.list({ page, sort, limit: size });
+    }
   }
   /**
-   * A collection with its products. GoCommerce is keyed on slug; the storefront sometimes has only
-   * an id, and there is no id lookup, so that case reads the list and matches there.
+   * A review, through ext/reviews. The engine asks for a name and an email
+   * with every review, so a signed-out shopper is asked to sign in rather
+   * than having one made up for them. Uploaded photos have nowhere to go: the
+   * module stores text.
    */
-  async getOne(idOrSlug) {
-    const looksLikeId = /^[0-9]+$/.test(String(idOrSlug));
-    let slug = String(idOrSlug);
-    if (looksLikeId) {
-      const res2 = await this.api("GET", `/api/collections${query({ limit: MAX_LIMIT })}`);
-      const match = (res2.data || []).find((c) => String(c.id) === String(idOrSlug));
-      if (!match) throw new Error(`Collection ${idOrSlug} not found`);
-      slug = match.slug;
-    }
-    const res = await this.api("GET", `/api/collections/${encodeURIComponent(slug)}${query({ limit: MAX_LIMIT })}`);
-    if (!res.data) throw new Error(`Collection ${idOrSlug} not found`);
-    remember(res.data.products || []);
-    return mapCollection(res.data);
+  async addReview({
+    productId,
+    rating,
+    review,
+    title
+  }) {
+    const me = currentMe();
+    if (!me?.email) throw new GoCommerceError("Please sign in to write a review.", 401, "unauthorized");
+    const name = [me.firstName, me.lastName].filter(Boolean).join(" ") || me.email.split("@")[0];
+    return this.data("/x/reviews", {
+      method: "POST",
+      body: {
+        product_id: Number(productId),
+        name,
+        email: me.email,
+        rating: Math.round(Number(rating)),
+        ...title ? { title } : {},
+        body: String(review ?? "")
+      }
+    });
   }
-  // GoCommerce records no ratings, so there is no "all ratings" collection to serve.
-  async getAllRatings() {
-    return {
-      id: null,
-      name: "All Ratings",
-      slug: "all-ratings",
-      description: null,
-      isActive: true,
-      isFeatured: false,
-      userId: "",
-      productCount: 0,
-      thumbnail: null,
-      metaTitle: null,
-      metaDescription: null,
-      collectionvalues: [],
-      createdAt: null,
-      updatedAt: null
-    };
+  async fetchReels() {
+    throw new NotSupportedError("ProductService", "fetchReels", "the engine has no reels");
   }
 };
-var collectionService = CollectionService.getInstance();
-var sortNeedsWholeCatalogue = (sort) => {
-  if (!sort) return false;
-  const key = sort.replace(/^-/, "").split(":")[0];
-  return key === "price" || key === "updatedAt" || key === "createdAt";
-};
-var sortProducts = (products, sort) => {
-  if (!sortNeedsWholeCatalogue(sort)) return products;
-  const leadingMinus = sort.startsWith("-");
-  const [rawKey, rawDirection] = sort.replace(/^-/, "").split(":");
-  const descending = leadingMinus || rawDirection === "desc";
-  const value = (product) => {
-    if (rawKey === "price") {
-      const prices = (product.variants || []).filter((v) => v.active !== false).map((v) => v.price?.amount_minor ?? 0);
-      return prices.length ? Math.min(...prices) : 0;
-    }
-    const stamp = rawKey === "createdAt" ? product.created_at : product.updated_at;
-    return stamp ? Date.parse(stamp) : 0;
-  };
-  return [...products].sort((a, b) => descending ? value(b) - value(a) : value(a) - value(b));
-};
-var productPrice = (product) => {
-  const prices = (product.variants || []).filter((v) => v.active !== false).map((v) => v.price?.amount_minor ?? 0);
-  return prices.length ? Math.min(...prices) : 0;
-};
-var countBy = (items, key) => {
-  const counts = /* @__PURE__ */ new Map();
-  for (const item of items) {
-    const entry = key(item);
-    if (!entry?.name) continue;
-    const id = entry.slug || entry.name;
-    const existing = counts.get(id);
-    if (existing) existing.count += 1;
-    else counts.set(id, { ...entry, count: 1 });
-  }
-  return [...counts.values()].sort((a, b) => b.count - a.count);
+var productService = new ProductService();
+
+// src/services/search-service.ts
+var num = (v) => {
+  if (v === null || v.trim() === "") return void 0;
+  const n = Number(v);
+  return Number.isFinite(n) ? n : void 0;
 };
-var SearchService = class _SearchService extends BaseService {
-  static instance;
-  static getInstance() {
-    if (!_SearchService.instance) _SearchService.instance = new _SearchService();
-    return _SearchService.instance;
-  }
+var SearchService = class extends CatalogService {
   emptyResult() {
     return {
       data: [],
       count: 0,
       totalPages: 0,
       categoryHierarchy: [],
-      facets: { priceStat: { min: void 0, max: void 0 }, categories: [], tags: [], allFilters: {} }
+      facets: { priceStat: {}, categories: [], tags: [], allFilters: {} }
     };
   }
-  /**
-   * The listing page: `/products`, `/[slug]` for a category, and every filter the sidebar sets.
-   *
-   * Term and category are pushed to the API. Tags, the price range and the sort control are
-   * applied here, because GoCommerce has no parameter for them — so when any of those is active
-   * the request asks for the whole window rather than one page, and the result is paged locally.
-   */
   async searchWithUrl(url, slug) {
     try {
-      const params = new URLSearchParams(url.search);
-      const term = params.get("search") || params.get("q") || "";
-      const page = Math.max(1, Number(params.get("page") || 1) || 1);
-      const sort = params.get("sort") || "";
-      const tags = (params.get("tags") || "").split(",").map((t) => decodeURIComponent(t).trim().toLowerCase()).filter(Boolean);
-      const priceFrom = params.get("priceFrom") ? Number(params.get("priceFrom")) : void 0;
-      const priceTo = params.get("priceTo") ? Number(params.get("priceTo")) : void 0;
-      const categorySlug = slug && slug !== "products" ? slug : params.get("categories") || void 0;
-      const localFilters = tags.length > 0 || priceFrom !== void 0 || priceTo !== void 0;
-      const needsWholeWindow = localFilters || sortNeedsWholeCatalogue(sort) || Boolean(categorySlug);
-      let products = [];
-      let meta;
-      let category;
-      if (categorySlug) {
-        const res = await categoryService.fetchCategoryPage(categorySlug, { limit: MAX_LIMIT });
-        products = res.products;
-        meta = res.meta;
-        category = res.category;
-        if (term) {
-          const needle = term.toLowerCase();
-          products = products.filter((p) => `${p.title} ${p.description || ""}`.toLowerCase().includes(needle));
-        }
-      } else {
-        const res = await productService.fetchProducts({
-          q: term,
-          page: needsWholeWindow ? 1 : page,
-          limit: needsWholeWindow ? MAX_LIMIT : PAGE_SIZE
-        });
-        products = res.products;
-        meta = res.meta;
-      }
-      const facetSource = products;
-      const priceMinor = facetSource.map(productPrice).filter((n) => Number.isFinite(n));
-      const currency = facetSource[0]?.variants?.[0]?.price?.currency || facetSource[0]?.currency;
-      const digits = currency ? 10 ** currencyFractionDigits(currency) : 100;
-      let filtered = products;
-      if (tags.length) {
-        filtered = filtered.filter((p) => (p.tags || []).some((tag) => tags.includes(tag.toLowerCase())));
-      }
-      if (priceFrom !== void 0) filtered = filtered.filter((p) => productPrice(p) / digits >= priceFrom);
-      if (priceTo !== void 0) filtered = filtered.filter((p) => productPrice(p) / digits <= priceTo);
-      filtered = sortProducts(filtered, sort);
-      const paged = needsWholeWindow ? filtered.slice((page - 1) * PAGE_SIZE, page * PAGE_SIZE) : filtered;
-      const count = needsWholeWindow ? filtered.length : meta?.total ?? filtered.length;
+      const u = typeof url === "string" ? new URL(url, "http://localhost") : url;
+      const p = u.searchParams;
+      const [from, to] = (p.get("price") ?? "").split(/[,-]/);
+      const res = await this.queryCatalog({
+        page: num(p.get("page")),
+        search: p.get("search") ?? p.get("q") ?? void 0,
+        sort: p.get("sort") ?? void 0,
+        category: slug || p.get("categories")?.split(",")[0] || void 0,
+        priceFrom: num(p.get("priceFrom")) ?? num(from ?? null),
+        priceTo: num(p.get("priceTo")) ?? num(to ?? null)
+      });
       return {
-        data: paged.map(mapProduct),
-        count,
-        totalPages: Math.ceil(count / PAGE_SIZE) || (count ? 1 : 0),
-        // Only the category itself: its ancestors are named in `full_name` but their slugs are
-        // not served to a storefront, and a breadcrumb link with no destination is worse than
-        // no crumb.
-        categoryHierarchy: category ? [{ name: category.title, slug: category.slug }] : [],
-        facets: {
-          priceStat: priceMinor.length ? { min: Math.min(...priceMinor) / digits, max: Math.max(...priceMinor) / digits } : { min: void 0, max: void 0 },
-          categories: countBy(facetSource, (p) => p.category ? { name: p.category.title, slug: p.category.slug } : void 0),
-          tags: countBy(
-            facetSource.flatMap((p) => (p.tags || []).map((tag) => ({ tag }))),
-            ({ tag }) => ({ name: tag, slug: tag })
-          ),
-          allFilters: {}
-        }
+        data: res.data,
+        count: res.count,
+        totalPages: res.noOfPage,
+        page: res.page,
+        categoryHierarchy: res.categoryHierarchy,
+        facets: { priceStat: {}, categories: [], tags: [], allFilters: {} }
       };
-    } catch (error) {
-      if (error?.code !== "not_found") console.error("[gocommerce] search failed", error);
-      return this.emptyResult();
+    } catch (err) {
+      if (err?.status === 404) return this.emptyResult();
+      throw err;
     }
   }
-  async searchWithQuery(queryString) {
-    const url = new URL("https://storefront.local/products");
-    if (queryString) url.searchParams.set("search", queryString);
-    return this.searchWithUrl(url);
-  }
 };
-var searchService = SearchService.getInstance();
-var MeilisearchService = class _MeilisearchService extends BaseService {
-  static instance;
-  static getInstance() {
-    if (!_MeilisearchService.instance) _MeilisearchService.instance = new _MeilisearchService();
-    return _MeilisearchService.instance;
-  }
-  async search(params = {}) {
-    const page = Math.max(1, Number(params.page || 1) || 1);
-    const { products, meta } = await productService.fetchProducts({
-      q: params.q || "",
-      page,
-      limit: params.limit || PAGE_SIZE
-    });
-    const hits = products.map(mapProduct);
+var searchService = new SearchService();
+
+// src/services/meilisearch-service.ts
+var MeilisearchService = class extends CatalogService {
+  /** `{ query, categories, page }` → a Meilisearch-shaped answer: `hits`, `totalHits`, `totalPages`. */
+  async search({
+    query,
+    search,
+    categories,
+    page = 1,
+    limit
+  } = {}) {
+    const res = await this.queryCatalog({ page, limit, search: query ?? search, category: categories || void 0 });
     return {
-      hits,
-      data: hits,
-      estimatedTotalHits: meta?.total ?? hits.length,
-      count: meta?.total ?? hits.length,
-      page,
-      totalPages: meta?.total_pages ?? 1,
-      hitsPerPage: meta?.limit ?? PAGE_SIZE,
-      facetDistribution: {},
-      processingTimeMs: 0,
-      query: params.q || ""
+      hits: res.data,
+      totalHits: res.count,
+      estimatedTotalHits: res.count,
+      totalPages: res.noOfPage,
+      page: res.page,
+      categories: res.categoryHierarchy,
+      facetDistribution: {}
     };
   }
-  async searchAutoComplete(params = {}) {
-    const { products } = await productService.fetchProducts({ q: params.q || "", page: 1, limit: params.limit || 8 });
-    const hits = products.map((product) => ({
-      id: product.id,
-      name: product.title,
-      title: product.title,
-      slug: product.slug,
-      thumbnail: mapProduct(product)?.thumbnail || null
-    }));
-    return { hits, data: hits, count: hits.length, query: params.q || "" };
-  }
-};
-var meilisearchService = MeilisearchService.getInstance();
-var AutocompleteService = class _AutocompleteService extends BaseService {
-  static instance;
-  static getInstance() {
-    if (!_AutocompleteService.instance) _AutocompleteService.instance = new _AutocompleteService();
-    return _AutocompleteService.instance;
-  }
-  async list({ page = 1, q = "" } = {}) {
-    const { products, meta } = await productService.fetchProducts({ q, page, limit: 10 });
-    return fromListMeta(
-      products.map((product) => ({ id: product.id, name: product.title, slug: product.slug })),
-      meta,
-      page
-    );
+  /** The header's type-ahead: `{ data: [{ slug, title, thumbnail, price }] }`. */
+  async searchAutoComplete({ query, search, limit = 8 } = {}) {
+    const q = (query ?? search ?? "").trim();
+    if (!q) return { data: [] };
+    if (await this.facts.pluginOn("meilisearch")) {
+      const res = await this.data("/x/meilisearch/search", { query: { q, limit } });
+      return { data: (res.hits ?? []).map(fromSearchDoc) };
+    }
+    const rows = await this.data("/api/products", { query: { q, limit, channel: this.creds.channel } }) ?? [];
+    return { data: rows.map((p) => toProduct(p)) };
   }
 };
-var autocompleteService = AutocompleteService.getInstance();
-var resolveProductIndex = async (ids, fetchFn) => {
-  const wanted = [...new Set(ids.filter((id) => typeof id === "number"))];
-  const service = fetchFn ? new ProductService(fetchFn) : productService;
-  await Promise.all(wanted.filter((id) => !productCache.has(id)).map((id) => service.fetchProductById(id)));
-  const index = /* @__PURE__ */ new Map();
-  for (const id of wanted) {
-    const product = productCache.get(id);
-    if (product) index.set(id, product);
-  }
-  return index;
-};
+var meilisearchService = new MeilisearchService();
 
-// src/services/cart.ts
-var REMOVE_LINE = -9999999;
-var CART_ID_KEY = "cart_id";
-var readStoredCartId = () => {
-  try {
-    return typeof window !== "undefined" ? window.localStorage?.getItem(CART_ID_KEY) || null : null;
-  } catch {
-    return null;
-  }
-};
-var storeCartId = (cartId) => {
-  if (!cartId) return;
-  try {
-    window?.localStorage?.setItem(CART_ID_KEY, cartId);
-  } catch {
+// src/services/category-service.ts
+var asList = (rows) => ({
+  data: rows,
+  count: rows.length,
+  pageSize: rows.length,
+  noOfPage: 1,
+  page: 1
+});
+var CategoryService = class extends BaseService {
+  facts = new StoreFacts(this._fetch);
+  /** Every category, flat, each naming its parent. The storefront builds the tree. */
+  async fetchAllCategories(_args = {}) {
+    const all = await this.facts.categories();
+    return asList(all.map(flat));
   }
-};
-var forgetCartId = () => {
-  try {
-    window?.localStorage?.removeItem(CART_ID_KEY);
-  } catch {
+  async fetchFeaturedCategories({ limit = 18 } = {}) {
+    const roots = (await this.facts.categories()).filter((c) => c.parent_id === null);
+    return asList(roots.slice(0, Math.max(0, Number(limit) || 18)).map(flat));
   }
-};
-var usableId = (cartId) => cartId && cartId !== "undefined" && cartId !== "null" ? cartId : null;
-var CartService = class _CartService extends BaseService {
-  static instance;
-  static getInstance() {
-    if (!_CartService.instance) _CartService.instance = new _CartService();
-    return _CartService.instance;
-  }
-  /** Turns a GoCommerce cart into the shape the storefront's cart, drawer and checkout read. */
-  async present(cart) {
-    if (!cart) return {};
-    storeCartId(cart.id);
-    const [index, store] = await Promise.all([
-      // Cart lines name a product by id only, so slug and image are filled in from the catalogue.
-      resolveProductIndex(
-        (cart.line_items || []).map((line) => line.product_id),
-        this.getFetch()
-      ),
-      readStaticStore()
-    ]);
-    return mapCart(cart, readCheckoutDetails(cart.id), index, store);
+  async fetchFooterCategories(args = {}) {
+    return this.fetchFeaturedCategories(args);
   }
-  /** Opens a cart. The email is optional here and is the only field `POST /api/carts` accepts. */
-  async openCart(email) {
-    const res = await this.api("POST", "/api/carts", email ? { email } : {});
-    storeCartId(res.data?.id);
-    return res.data;
+  /** The nested tree, roots first. */
+  async getMegamenu(_args = {}) {
+    const tree = await this.data("/api/categories") ?? [];
+    return tree.map(toCategory);
   }
-  async readCart(cartId) {
-    let cart = null;
-    try {
-      const res = await this.api("GET", `/api/carts/${encodeURIComponent(cartId)}`);
-      cart = res.data ?? null;
-    } catch {
-      return null;
-    }
-    if (cart && cart.status && cart.status !== "open") {
-      forgetCartId();
-      return null;
-    }
-    return cart;
+  async fetchCategory(slug) {
+    const c = await this.data(`/api/categories/${encodeURIComponent(slug)}`, { query: { limit: 1 } });
+    return toCategory(c);
   }
   /**
-   * Is the cart behind this token gone for good — expired, unknown, or already checked out?
-   *
-   * Asked by re-reading the cart rather than by matching the failure's wording, because the API
-   * reports several unrelated things the same way: a dead cart and an unknown payment code are both
-   * `404 not_found`. The status is the fact; the message is prose.
+   * kitcommerce-core's category filter asks for `/api/categories/all` by path,
+   * through the family's raw `get`. That is a Litekart path the rest-guard
+   * would swallow, so it is answered here, from the engine's tree.
    */
-  async cartIsSpent(cartId) {
-    try {
-      const res = await this.api("GET", `/api/carts/${encodeURIComponent(cartId)}`);
-      return !res.data || Boolean(res.data.status) && res.data.status !== "open";
-    } catch {
-      return true;
-    }
+  async get(path) {
+    if (path.split("?")[0] === "/api/categories/all") return await this.fetchAllCategories();
+    return super.get(path);
   }
-  /** One line-item write against a cart that exists. Returns the cart the write left behind. */
-  async writeLine(cartId, { variantId, qty, lineId, removing }) {
-    const cart = encodeURIComponent(cartId);
-    if (lineId) {
-      const line = encodeURIComponent(String(lineId));
-      const res2 = removing ? await this.api("DELETE", `/api/carts/${cart}/line-items/${line}`) : await this.api("PATCH", `/api/carts/${cart}/line-items/${line}`, { quantity: qty });
-      return res2.data ?? null;
-    }
-    if (removing) return this.readCart(cartId);
-    const res = await this.api("POST", `/api/carts/${cart}/line-items`, {
-      variant_id: Number(variantId),
-      quantity: qty
-    });
-    return res.data ?? null;
+};
+var flat = (c) => ({ ...toCategory(c), children: [] });
+var categoryService = new CategoryService();
+
+// src/services/collection-service.ts
+var CollectionService = class extends BaseService {
+  async list({ page = 1, limit = 24 } = {}) {
+    const env = await this.engine("/api/collections", { query: { page, limit } });
+    return toPage(env, toCollection);
+  }
+  /** A collection page: the collection, and its products in the merchant's order. */
+  async getOne(slug, { page = 1, limit = 48 } = {}) {
+    const env = await this.engine(
+      `/api/collections/${encodeURIComponent(slug)}`,
+      { query: { page, limit } }
+    );
+    const products = (env.data.products ?? []).map((p) => toProduct(p));
+    return {
+      ...toCollection(env.data),
+      products,
+      // The family's shape for a collection's members.
+      collectionvalues: products.map((p) => ({ products: p })),
+      count: env.meta?.total ?? products.length,
+      noOfPage: env.meta?.total_pages ?? 1,
+      page: env.meta?.page ?? page
+    };
+  }
+  /** Collection-level ratings are a Litekart aggregate; the engine has none to report. */
+  async getAllRatings() {
+    return { data: [] };
   }
+};
+var collectionService = new CollectionService();
+
+// src/services/cart-service.ts
+var REMOVE = -9999999;
+var CartService = class extends BaseService {
+  facts = new StoreFacts(this._fetch);
   async getCartByCartId(cartId) {
-    const id = usableId(cartId) || readStoredCartId();
-    if (!id) return {};
-    return this.present(await this.readCart(id));
+    const id = clean(cartId);
+    if (!id) return emptyCart(await this.currency());
+    try {
+      return await this.present(await this.data(`/api/carts/${encodeURIComponent(id)}`));
+    } catch (err) {
+      if (err instanceof GoCommerceError && err.status === 404) return emptyCart(await this.currency());
+      throw err;
+    }
   }
-  async fetchCartData() {
-    const id = readStoredCartId();
-    if (!id) return {};
-    return this.present(await this.readCart(id));
+  async fetchCartData(cartId) {
+    return this.getCartByCartId(cartId ?? storedCartId());
   }
+  /**
+   * The cart after an order: the engine marks it `converted` and keeps its
+   * lines, and this answers it with none — which is how the storefront knows
+   * to clear the bag on the success page.
+   */
   async refereshCart() {
-    return this.fetchCartData();
+    const id = storedCartId();
+    const cart = await this.getCartByCartId(id);
+    if (id && cart.status === "converted") forgetCartExtras(id);
+    return cart;
   }
   /**
-   * Add, change or remove a line.
-   *
-   * `qty` is the line's new quantity, not a delta — which is how the shared cart store calls it
-   * (its stepper sends `qty ± 1`), and what `PATCH .../line-items/{lineId}` takes. A quantity of
-   * zero removes the line, and so does the store's `REMOVE_LINE` sentinel.
-   *
-   * A cart token in this browser can be dead — expired, wiped server-side, or already checked out —
-   * and the API then answers "cart not found", which is what the shopper was shown when they
-   * clicked Add to bag. That is a token this storefront is holding, not anything they did, so a
-   * dead one is dropped and the item is added to a fresh cart instead of reporting it.
+   * `qty` is a change, not a total: +1 from a product page, −1 from a card's
+   * minus button. With no cart yet, one is opened and remembered.
    */
   async addToCart({
-    variantId,
-    qty,
     cartId,
-    lineId
+    lineId,
+    qty = 1,
+    variantId
   }) {
-    const removing = qty === REMOVE_LINE || qty <= 0;
-    if (!removing && !variantId) throw new Error("A variant is required to add an item to the cart.");
-    let id = usableId(cartId) || readStoredCartId();
-    if (id) {
-      let cart = null;
-      let spent = false;
-      try {
-        cart = await this.writeLine(id, { variantId, qty, lineId, removing });
-      } catch (error) {
-        if (!await this.cartIsSpent(id)) throw error;
-        spent = true;
+    let id = clean(cartId) ?? storedCartId();
+    if (lineId && id) {
+      const cart = await this.data(`/api/carts/${encodeURIComponent(id)}`);
+      const line = (cart.line_items ?? []).find((l) => String(l.id) === String(lineId));
+      if (line) {
+        const next = qty === REMOVE ? 0 : line.quantity + Number(qty);
+        return this.setQuantity(id, line.id, next);
       }
-      if (!spent) return this.present(cart);
-      forgetCartId();
-      id = null;
     }
-    if (removing) return {};
-    const opened = await this.openCart(readCheckoutDetails(null).email);
-    if (!opened?.id) throw new Error("Could not open a cart on this store.");
-    return this.present(await this.writeLine(opened.id, { variantId, qty, lineId: null, removing: false }));
+    if (qty === REMOVE || Number(qty) <= 0) return this.getCartByCartId(id);
+    if (!variantId) throw new GoCommerceError("Please choose an option before adding this to your bag.", 400);
+    if (!id) id = await this.open();
+    try {
+      return await this.present(
+        await this.data(`/api/carts/${encodeURIComponent(id)}/line-items`, {
+          method: "POST",
+          body: { variant_id: Number(variantId), quantity: Number(qty) }
+        })
+      );
+    } catch (err) {
+      if (err instanceof GoCommerceError && (err.status === 404 || /checked out/.test(err.message))) {
+        const fresh = await this.open();
+        return this.present(
+          await this.data(`/api/carts/${encodeURIComponent(fresh)}/line-items`, {
+            method: "POST",
+            body: { variant_id: Number(variantId), quantity: Number(qty) }
+          })
+        );
+      }
+      throw err;
+    }
   }
+  /** `qty` is the new total; 0 takes the line out. */
   async updateCart({
-    qty,
     cartId,
-    lineId = null,
-    productId,
-    variantId
+    lineId,
+    qty
   }) {
-    return this.addToCart({ productId, variantId, qty, cartId, lineId });
-  }
-  async removeCart({ cartId, lineId = null }) {
-    return this.addToCart({ qty: REMOVE_LINE, cartId, lineId });
+    const id = clean(cartId) ?? storedCartId();
+    if (!id) return emptyCart(await this.currency());
+    return this.setQuantity(id, lineId, Number(qty));
+  }
+  async removeCart({ cartId, lineId }) {
+    const id = clean(cartId) ?? storedCartId();
+    if (!id) return emptyCart(await this.currency());
+    return this.present(
+      await this.data(`/api/carts/${encodeURIComponent(id)}/line-items/${encodeURIComponent(String(lineId))}`, {
+        method: "DELETE"
+      })
+    );
   }
   /**
-   * The address step's write.
-   *
-   * GoCommerce has no endpoint that changes a cart after it is opened, and no address on it: these
-   * fields are arguments to checkout. They are kept against this cart id in the browser and sent
-   * when the order is placed — see checkout-details.ts. The email additionally seeds a cart that
-   * has not been opened yet, which is the one moment GoCommerce does accept it.
+   * Contact details and addresses, from the checkout's address step. The
+   * email goes to the engine — it is how an abandoned cart is followed up —
+   * and the rest is kept for the checkout request.
    */
-  async updateCart2({
-    cartId,
-    email,
-    phone,
-    billingAddress,
-    shippingAddress,
-    isBillingAddressSameAsShipping
-  }) {
-    let id = usableId(cartId) || readStoredCartId();
-    let cart = id ? await this.readCart(id) : null;
-    if (!cart) {
-      cart = await this.openCart(email);
-      id = cart?.id ?? null;
+  async updateCart2(args) {
+    const id = clean(args.cartId) ?? storedCartId();
+    if (!id) return emptyCart(await this.currency());
+    const patch = {};
+    if (args.phone !== void 0) patch.phone = args.phone || void 0;
+    if (args.shippingAddress !== void 0) {
+      patch.shippingAddress = args.shippingAddress;
+      if (args.shippingAddress?.phone && !patch.phone) patch.phone = String(args.shippingAddress.phone);
     }
-    if (!id) throw new Error("Could not open a cart on this store.");
-    const name = [shippingAddress?.firstName, shippingAddress?.lastName].filter(Boolean).join(" ").trim() || [billingAddress?.firstName, billingAddress?.lastName].filter(Boolean).join(" ").trim() || void 0;
-    writeCheckoutDetails(id, {
-      ...email ? { email } : {},
-      ...phone || shippingAddress?.phone ? { phone: phone || shippingAddress?.phone } : {},
-      ...name ? { name } : {},
-      ...shippingAddress ? { shippingAddress } : {},
-      ...billingAddress && !isBillingAddressSameAsShipping ? { billingAddress } : shippingAddress ? { billingAddress: shippingAddress } : {}
+    if (args.billingAddress !== void 0 || args.isBillingAddressSameAsShipping) {
+      patch.billingAddress = args.isBillingAddressSameAsShipping ? null : args.billingAddress ?? null;
+    }
+    const before = cartExtras(id);
+    const country = (a) => String(a?.countryCode || a?.country || "").toUpperCase();
+    if (args.shippingAddress !== void 0 && country(args.shippingAddress) !== country(before.shippingAddress)) {
+      patch.shippingRateId = null;
+      patch.shippingRate = null;
+    }
+    saveCartExtras(id, patch);
+    const email = args.email ?? (args.shippingAddress?.email ? String(args.shippingAddress.email) : void 0);
+    if (email !== void 0) {
+      return this.present(
+        await this.data(`/api/carts/${encodeURIComponent(id)}/email`, { method: "PUT", body: { email } })
+      );
+    }
+    return this.getCartByCartId(id);
+  }
+  /**
+   * A discount code. The engine prices it against the basket now and decides
+   * it again at checkout; what it answers is kept so the bag can show it,
+   * because the cart itself does not carry the code.
+   */
+  async applyCoupon({ cartId, couponCode }) {
+    const id = clean(cartId) ?? storedCartId();
+    if (!id) throw new GoCommerceError("Add something to your bag before applying a code.", 400);
+    const cart = await this.data(`/api/carts/${encodeURIComponent(id)}`);
+    const discount = await this.data(`/api/carts/${encodeURIComponent(id)}/discount`, {
+      method: "PUT",
+      body: { code: String(couponCode ?? "").trim(), ...cart.email ? { email: cart.email } : {} }
     });
+    saveCartExtras(id, { discount: { ...discount, code: discount.code || String(couponCode).trim() } });
     return this.present(cart);
   }
-  /** Nothing to reserve ahead of payment: `POST /api/checkout/{code}` is one transaction. */
-  async completeCart(cartId) {
-    return this.getCartByCartId(cartId);
-  }
-  /** Remembered so the payment step can re-select it; GoCommerce takes the code at checkout. */
-  async updateCartPaymentMethod({ cartId, paymentMethod }) {
-    const id = usableId(cartId) || readStoredCartId();
-    if (!id) return {};
-    const cart = await this.readCart(id);
-    const presented = await this.present(cart);
-    if (presented && paymentMethod) presented.paymentMethod = paymentMethod;
-    return presented;
-  }
-  // GoCommerce has no discount engine, so there is no code to accept. Saying so beats a silent
-  // no-op that leaves the shopper waiting for a discount that is never coming.
-  async applyCoupon(_params) {
-    throw new Error("Discount codes are not available on this store.");
+  async removeCoupon(cartId) {
+    const id = clean(cartId) ?? storedCartId();
+    if (!id) return emptyCart(await this.currency());
+    await this.engine(`/api/carts/${encodeURIComponent(id)}/discount`, { method: "DELETE" });
+    saveCartExtras(id, { discount: null });
+    return this.getCartByCartId(id);
+  }
+  /** The delivery option the shopper picked, priced from the engine's own quote. */
+  async updateShippingRate({ cartId, shippingRateId }) {
+    const id = clean(cartId) ?? storedCartId();
+    if (!id) return emptyCart(await this.currency());
+    const ship = cartExtras(id).shippingAddress;
+    const country = String(ship?.countryCode || ship?.country || "").toUpperCase();
+    if (!country) throw new GoCommerceError("Add a delivery address first.", 400);
+    const quote2 = await this.data("/api/checkout/rates", { query: { cart: id, country, state: ship?.state ? String(ship.state) : void 0 } });
+    const rate = (quote2.rates ?? []).find((r) => String(r.rate_id) === String(shippingRateId));
+    if (!rate) throw new GoCommerceError("That delivery option is not available for this address any more.", 409);
+    saveCartExtras(id, {
+      shippingRateId: String(rate.rate_id),
+      shippingRate: {
+        id: String(rate.rate_id),
+        name: rate.name,
+        minor: rate.price.amount_minor,
+        currency: rate.price.currency
+      }
+    });
+    return this.getCartByCartId(id);
+  }
+  /** The payment method is chosen at checkout, by which checkout route is called. */
+  async updateCartPaymentMethod({ cartId }) {
+    return this.getCartByCartId(clean(cartId) ?? storedCartId());
+  }
+  async completeCart() {
+    throw new NotSupportedError("CartService", "completeCart", "an order is placed through checkoutService");
+  }
+  // ------------------------------------------------------------ internals
+  async setQuantity(cartId, lineId, qty) {
+    const path = `/api/carts/${encodeURIComponent(cartId)}/line-items/${encodeURIComponent(String(lineId))}`;
+    if (qty <= 0) return this.present(await this.data(path, { method: "DELETE" }));
+    return this.present(await this.data(path, { method: "PATCH", body: { quantity: qty } }));
+  }
+  /** A new cart, remembered — and priced for the signed-in shopper's group when the engine allows it. */
+  async open() {
+    const channel = this.creds.channel;
+    const cart = await this.data("/api/carts", { method: "POST", ...channel ? { body: { channel } } : {} });
+    rememberCartId(cart.id);
+    if (sessionToken()) await this.claimCartForAccount(cart.id);
+    return cart.id;
+  }
+  async currency() {
+    try {
+      return (await this.facts.ready()).currency;
+    } catch {
+      return "USD";
+    }
   }
-  async removeCoupon() {
-    return this.fetchCartData();
+  /** The engine's cart with the browser-held extras and each line's picture and link. */
+  async present(cart) {
+    const ids = [...new Set((cart.line_items ?? []).map((l) => l.product_id))];
+    const products = /* @__PURE__ */ new Map();
+    await Promise.all(
+      ids.map(async (pid) => {
+        products.set(pid, await this.productFor(pid));
+      })
+    );
+    return toCart(cart, cartExtras(cart.id), (l) => {
+      const p = products.get(l.product_id);
+      if (!p) return {};
+      const v = (p.variants ?? []).find((x) => x.id === l.variant_id);
+      return { slug: p.slug, thumbnail: v?.image?.url ?? p.image_url ?? null };
+    });
   }
-  /** Shipping is priced by the store at checkout; there are no rates for a shopper to choose. */
-  async updateShippingRate({ cartId }) {
-    return this.getCartByCartId(cartId || "");
+  productFor(id) {
+    return remember(
+      `${this.engineBase()}|product|${id}`,
+      () => this.data(`/api/products/${id}`).catch(() => null)
+    );
   }
 };
-var cartService = CartService.getInstance();
+var clean = (id) => id && id !== "undefined" && id !== "null" ? id : null;
+var cartService = new CartService();
 
-// src/services/checkout.ts
-var CART_ID_KEY2 = "cart_id";
-var readStoredCartId2 = () => {
-  try {
-    return typeof window !== "undefined" ? window.localStorage?.getItem(CART_ID_KEY2) || null : null;
-  } catch {
-    return null;
-  }
-};
-var METHOD_NAMES = {
-  cod: "Cash on delivery",
-  stripe: "Card",
-  razorpay: "Razorpay",
-  cashfree: "Cashfree",
-  paypal: "PayPal",
-  phonepe: "PhonePe",
-  manual: "Manual payment"
-};
-var installedCodes = [];
-var goCommerceCode = (storefrontCode) => {
-  const match = installedCodes.find((code) => code.toLowerCase() === storefrontCode.toLowerCase());
-  return match || storefrontCode.toLowerCase();
-};
-var titleCase = (code) => code.charAt(0).toUpperCase() + code.slice(1);
-var PaymentMethodService = class _PaymentMethodService extends BaseService {
-  static instance;
-  static getInstance() {
-    if (!_PaymentMethodService.instance) _PaymentMethodService.instance = new _PaymentMethodService();
-    return _PaymentMethodService.instance;
-  }
-  /**
-   * What this store accepts, from `GET /api/checkout`.
-   *
-   * The storefront branches on an uppercase code (`COD`, `STRIPE`, …) while GoCommerce installs
-   * them lowercase, so the code is uppercased for the UI and the original kept for the API call.
-   */
-  async list(_params = {}) {
-    const res = await this.api("GET", "/api/checkout");
-    const codes = res.data?.payment_methods || [];
-    installedCodes = codes;
-    const data = codes.map((code, index) => ({
-      id: code,
-      code: code.toUpperCase(),
-      name: METHOD_NAMES[code.toLowerCase()] || titleCase(code),
-      description: "",
-      active: true,
-      isTest: false,
-      img: null,
-      rank: index,
-      currency: res.data?.currency || null
-    }));
-    return { data, count: data.length, pageSize: data.length, noOfPage: data.length ? 1 : 0, page: 1 };
+// src/services/checkout-service.ts
+var CheckoutService = class extends BaseService {
+  /** Delivery options for the address on the cart: `{ data: [{ id, name, base_rate }] }`. */
+  async getShippingRates({ cartId } = {}) {
+    const id = cartId || storedCartId();
+    const ship = id ? cartExtras(id).shippingAddress : null;
+    const country = String(ship?.countryCode || ship?.country || "").toUpperCase();
+    if (!id || !country) return { data: [] };
+    const quote2 = await this.data("/api/checkout/rates", { query: { cart: id, country, state: ship?.state ? String(ship.state) : void 0 } });
+    return {
+      data: (quote2.rates ?? []).map((r) => ({
+        id: String(r.rate_id),
+        name: r.name,
+        description: null,
+        base_rate: minorToMajor(r.price.amount_minor, r.price.currency),
+        price: minorToMajor(r.price.amount_minor, r.price.currency),
+        currencyCode: r.price.currency,
+        // The engine's rates carry no delivery estimate; none is made up.
+        estimated_min_days: null,
+        estimated_max_days: null
+      }))
+    };
   }
-};
-var paymentMethodService = PaymentMethodService.getInstance();
-var CheckoutService = class _CheckoutService extends BaseService {
-  static instance;
-  static getInstance() {
-    if (!_CheckoutService.instance) _CheckoutService.instance = new _CheckoutService();
-    return _CheckoutService.instance;
+  /** Cash on delivery: the order is confirmed at once and paid on the doorstep. */
+  async checkoutCOD({ cartId } = {}) {
+    const result = await this.place("cod", cartId);
+    return {
+      order_no: result.order.number,
+      orderNo: result.order.number,
+      id: String(result.order.id),
+      status: result.order.status
+    };
   }
   /**
-   * Places the order.
-   *
-   * Everything the API requires and the cart cannot hold — email, name, phone, delivery address —
-   * comes from what the address step recorded against this cart. Missing pieces are named in the
-   * error rather than sent as blanks, because GoCommerce's own validation message ("address.line1
-   * is required") does not tell a shopper which screen to go back to.
+   * Razorpay's modal. The engine has already created the Razorpay order; this
+   * hands the storefront what the modal needs. A store running Razorpay's
+   * hosted (redirect) mode cannot be driven from this storefront's modal flow,
+   * and says so rather than opening a modal on an order it cannot pay.
    */
-  async place(storefrontCode, { cartId, origin, returnUrl }) {
-    const id = cartId && cartId !== "undefined" ? cartId : readStoredCartId2();
-    if (!id) throw new Error("There is no cart to check out.");
-    const details = readCheckoutDetails(id);
-    const address = toGoCommerceAddress(details.shippingAddress, details.phone);
-    if (!details.email) throw new Error("An email address is required to place this order \u2014 add one at the address step.");
-    if (!address) throw new Error("A complete delivery address is required to place this order \u2014 add one at the address step.");
-    const code = goCommerceCode(storefrontCode);
-    let res;
-    try {
-      res = await this.api(
-        "POST",
-        `/api/checkout/${encodeURIComponent(code)}`,
-        {
-          cart_id: id,
-          email: details.email,
-          ...details.name ? { name: details.name } : {},
-          ...details.phone ? { phone: details.phone } : {},
-          address,
-          ...returnUrl || origin ? { return_url: returnUrl || `${origin}/checkout/process` } : {}
-        },
-        // A double-submitted Place Order must not become two orders and two inventory holds.
-        { "Idempotency-Key": `${id}:${code}` }
+  async checkoutRazorpay({ cartId } = {}) {
+    const result = await this.place("razorpay", cartId);
+    const data = result.payment.client_data ?? {};
+    if (result.payment.kind !== "client_action" || !data.razorpay_order_id) {
+      throw new GoCommerceError(
+        "This store takes Razorpay payments on Razorpay\u2019s own page, which this storefront does not support yet.",
+        0
       );
-    } catch (error) {
-      if (await cartService.cartIsSpent(id)) {
-        throw new Error("This cart is no longer available \u2014 it has expired or was already checked out. Add the items to a new bag and try again.");
-      }
-      throw error;
     }
-    const order = res.data?.order;
-    const payment = res.data?.payment;
-    rememberOrderToken(order?.number, order?.access_token);
-    clearCheckoutDetails(id);
-    const index = await resolveProductIndex(
-      (order?.line_items || []).map((line) => line.product_id),
-      this.getFetch()
-    );
     return {
-      ...mapOrder(order, index) ?? {},
-      // The order number, under every name the storefront's payment step reads it by.
-      order_no: order?.number,
-      orderNo: order?.number,
-      code: order?.number,
-      payment: payment ?? null,
-      paymentKind: payment?.kind ?? "none",
-      // A gateway's own fields (a Razorpay order id, a Stripe client secret, a redirect url)
-      // ride on `client_data`; spreading them is what lets the storefront's per-gateway
-      // branches find what they look for without this connector naming each gateway.
-      ...payment?.client_data ?? {}
+      order_no: result.order.number,
+      id: data.razorpay_order_id,
+      key_id: data.key_id,
+      amount: Number(data.amount),
+      currency: data.currency
     };
   }
-  async checkoutCOD({ cartId, origin }) {
-    return this.place("cod", { cartId, origin });
-  }
-  async checkoutPOS({ cartId, origin }) {
-    return this.place("pos", { cartId, origin });
-  }
-  async checkoutRazorpay({ cartId, origin }) {
-    return this.place("razorpay", { cartId, origin });
-  }
-  async checkoutStripe({ cartId, origin }) {
-    return this.place("stripe", { cartId, origin });
-  }
-  async checkoutCashfree({ cartId, origin }) {
-    return this.place("cashfree", { cartId, origin });
+  /** The modal closed with a payment. The engine learns of it from Razorpay itself. */
+  async captureRazorpayPayment({ razorpay_order_id }) {
+    const order = placedOrderByReference(razorpay_order_id);
+    if (!order) throw new GoCommerceError("That payment does not belong to an order placed from this browser.", 404);
+    return { order_no: order.number, status: "processing" };
+  }
+  // The family's other gateways. GoCommerce's Stripe is a Payment Element
+  // (a client secret, not a hosted page), and PayPal, Cashfree, PhonePe and
+  // Affirm are not engine gateways at all; paymentMethodService never lists
+  // them, so these are reached only by a storefront that hard-codes one.
+  async checkoutStripe() {
+    throw unsupported(
+      "checkoutStripe",
+      "GoCommerce\u2019s Stripe gateway uses the Payment Element, not a hosted checkout page"
+    );
   }
-  async checkoutPaypal({ cartId, origin, return_url }) {
-    return this.place("paypal", { cartId, origin, returnUrl: return_url });
+  async checkoutStripeCapture() {
+    throw unsupported("checkoutStripeCapture", "Stripe confirms payments to the engine by webhook");
   }
-  async checkoutPhonepe({ cartId, origin }) {
-    return this.place("phonepe", { cartId, origin });
+  async checkoutPaypal() {
+    throw unsupported("checkoutPaypal", "the engine has no PayPal gateway");
   }
-  async createAffirmPayOrder({
-    cartId,
-    origin
-  }) {
-    return this.place("affirm", { cartId, origin });
+  async capturePaypalPayment() {
+    throw unsupported("capturePaypalPayment", "the engine has no PayPal gateway");
   }
-  // GoCommerce reconciles a payment through `POST /api/checkout/{code}/webhook`, which the gateway
-  // calls server to server. There is nothing for the browser to capture afterwards, so these keep
-  // the storefront's redirect moving with the order number it already has rather than pretending
-  // to perform a capture that this API does not offer.
-  settled(orderNo) {
-    return { order_no: orderNo || "", orderNo: orderNo || "", captured: false };
+  async checkoutCashfree() {
+    throw unsupported("checkoutCashfree", "the engine has no Cashfree gateway");
   }
-  async captureRazorpayPayment({ razorpay_order_id }) {
-    return this.settled(razorpay_order_id);
+  async captureCashfreePayment() {
+    throw unsupported("captureCashfreePayment", "the engine has no Cashfree gateway");
   }
-  async capturePhonepePayment({ phonepe_order_id }) {
-    return this.settled(phonepe_order_id);
+  async checkoutPhonepe() {
+    throw unsupported("checkoutPhonepe", "the engine has no PhonePe gateway");
   }
-  async captureCashfreePayment({ order_no }) {
-    return this.settled(order_no);
+  async createAffirmPayOrder() {
+    throw unsupported("createAffirmPayOrder", "the engine has no Affirm gateway");
   }
-  async checkoutStripeCapture({ order_no }) {
-    return this.settled(order_no);
+  async confirmAffirmOrder() {
+    throw unsupported("confirmAffirmOrder", "the engine has no Affirm gateway");
   }
-  async confirmAffirmOrder({ orderId }) {
-    return this.settled(orderId);
+  async cancelAffirmOrder() {
+    throw unsupported("cancelAffirmOrder", "the engine has no Affirm gateway");
   }
-  async cancelAffirmOrder({ orderId }) {
-    throw new Error(`Cancelling order ${orderId || ""} is not available on this store.`);
+  async checkoutPOS() {
+    throw unsupported("checkoutPOS", "point-of-sale orders are placed from the admin panel");
   }
   /**
-   * GoCommerce prices shipping when it creates the order — there is no rate list for a shopper to
-   * choose from. An empty list is the accurate answer, and the payment step renders no rate picker
-   * for it rather than an empty one.
+   * One checkout attempt.
+   *
+   * The Idempotency-Key is kept with the cart and reused while the request is
+   * the same, because a payment gateway that fails after the engine has
+   * created the order leaves the cart converted: only a retry under the same
+   * key resumes that order, and without one the shopper is stuck. A changed
+   * request — a different address, a different method — gets a new key, since
+   * the engine refuses a key replayed with a different body.
    */
-  async getShippingRates(_params) {
-    return { message: "This store does not offer selectable shipping rates", success: true, error: null, data: [] };
+  async place(code, cartId) {
+    const id = cartId || storedCartId();
+    if (!id) throw new GoCommerceError("Your bag is empty.", 400);
+    const extras = cartExtras(id);
+    const ship = extras.shippingAddress;
+    if (!ship) throw new GoCommerceError("Add a delivery address first.", 400);
+    const cart = await this.data(`/api/carts/${encodeURIComponent(id)}`);
+    const email = cart.email || (ship.email ? String(ship.email) : "");
+    if (!email) throw new GoCommerceError("Add an email address so we can send your receipt.", 400);
+    const address = toEngineAddress(ship);
+    const body = {
+      cart_id: id,
+      email,
+      ...extras.phone || address.phone ? { phone: String(extras.phone || address.phone) } : {},
+      ...address.name ? { name: address.name } : {},
+      address,
+      ...extras.shippingRateId ? { shipping_rate_id: Number(extras.shippingRateId) } : {}
+    };
+    const serialised = JSON.stringify(body);
+    const key = extras.attempt?.body === `${code}:${serialised}` ? extras.attempt.key : newKey();
+    saveCartExtras(id, { attempt: { key, body: `${code}:${serialised}` } });
+    const result = await this.data(`/api/checkout/${encodeURIComponent(code)}`, {
+      method: "POST",
+      body,
+      headers: { "Idempotency-Key": key }
+    });
+    if (result.order.access_token) {
+      rememberOrder({
+        number: result.order.number,
+        token: result.order.access_token,
+        cartId: id,
+        reference: result.payment.client_data?.razorpay_order_id ?? result.payment.reference
+      });
+      if (sessionToken()) {
+        await this.engine("/x/identity/me/orders", {
+          method: "POST",
+          body: { number: result.order.number, token: result.order.access_token },
+          auth: true
+        }).catch(() => void 0);
+      }
+    }
+    saveCartExtras(id, { attempt: null });
+    return result;
   }
 };
-var checkoutService = CheckoutService.getInstance();
+var unsupported = (method, why) => new NotSupportedError("CheckoutService", method, why);
+function newKey() {
+  const c = globalThis.crypto;
+  if (c?.randomUUID) return c.randomUUID();
+  return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}-${Math.random().toString(36).slice(2)}`;
+}
+var checkoutService = new CheckoutService();
 
-// src/services/orders.ts
-var usable = (value) => value && value !== "undefined" && value !== "null" ? value : null;
-var OrderService = class _OrderService extends BaseService {
-  static instance;
-  static getInstance() {
-    if (!_OrderService.instance) _OrderService.instance = new _OrderService();
-    return _OrderService.instance;
-  }
-  async readOrder(orderNumber, token) {
-    try {
-      const res = await this.api("GET", `/api/orders/${encodeURIComponent(orderNumber)}?token=${encodeURIComponent(token)}`);
-      return res.data ?? null;
-    } catch {
-      return null;
-    }
+// src/services/payment-method-service.ts
+var DRIVABLE = {
+  cod: { code: "COD", img: "/payment/cod.svg" },
+  razorpay: { code: "RAZORPAY" }
+};
+var reported2 = /* @__PURE__ */ new Set();
+var PaymentMethodService = class extends BaseService {
+  facts = new StoreFacts(this._fetch);
+  async list(_args = {}) {
+    const options = await this.facts.checkoutOptions();
+    const methods = options.methods ?? [];
+    const data = methods.filter((m) => {
+      if (DRIVABLE[m.code]) return true;
+      if (!reported2.has(m.code)) {
+        reported2.add(m.code);
+        console.warn(
+          `[gocommerce] payment method "${m.code}" is switched on but this storefront cannot drive its flow, so it is not offered.`
+        );
+      }
+      return false;
+    }).map((m, i) => ({
+      id: m.code,
+      code: DRIVABLE[m.code].code,
+      engineCode: m.code,
+      name: m.name,
+      title: m.name,
+      description: "",
+      img: DRIVABLE[m.code].img ?? null,
+      rank: i,
+      active: true,
+      isActive: true
+    }));
+    return { data, count: data.length, pageSize: data.length, noOfPage: 1, page: 1 };
   }
-  async present(order) {
-    if (!order) return null;
-    const index = await resolveProductIndex(
-      (order.line_items || []).map((line) => line.product_id),
-      this.getFetch()
-    );
-    return mapOrder(order, index);
+};
+var paymentMethodService = new PaymentMethodService();
+
+// src/services/coupon-service.ts
+var CouponService = class extends BaseService {
+  async listCoupons(_args = {}) {
+    return emptyPage();
   }
+};
+var couponService = new CouponService();
+
+// src/services/order-service.ts
+var OrderService = class extends BaseService {
   /**
-   * The confirmation view, rebuilt from the cart that became the order.
+   * The order-success page's lookup, by the number and cart in its URL.
    *
-   * Everything a receipt needs is on the converted cart except the address, which was never stored
-   * on it — so that block is simply absent rather than invented.
+   * It runs on the server, where neither the token nor the session exists —
+   * they live in the shopper's browser — so there it answers nothing and the
+   * page says the details are not available yet. In the browser it answers
+   * the order. Inventing a server-side credential from the cart token in the
+   * URL would make that URL, which lands in history and referrers, a key to
+   * the shopper's address.
    */
-  async orderFromCart(cartId, orderNumber) {
-    let cart = null;
+  async listOrdersByParent({ orderNo, cartId } = {}) {
+    const number = clean2(orderNo) ?? (clean2(cartId) ? placedOrderForCart(clean2(cartId))?.number : void 0);
+    if (!number) return { data: [] };
     try {
-      const res = await this.api("GET", `/api/carts/${encodeURIComponent(cartId)}`);
-      cart = res.data ?? null;
-    } catch {
-      return null;
+      return { data: [await this.getOrder(number)] };
+    } catch (err) {
+      if (err instanceof GoCommerceError && (err.status === 404 || err.status === 401)) return { data: [] };
+      throw err;
     }
-    if (!cart) return null;
-    const lines = cart.line_items || [];
-    const index = await resolveProductIndex(
-      lines.map((line) => line.product_id),
-      this.getFetch()
-    );
-    const subtotal = fromMoney(cart.subtotal);
-    return {
-      id: null,
-      orderNo: orderNumber,
-      order_no: orderNumber,
-      parentOrderNo: orderNumber,
-      status: cart.status === "converted" ? "confirmed" : "pending",
-      paymentStatus: "pending",
-      paymentMethod: null,
-      createdAt: cart.updated_at || cart.created_at || null,
-      updatedAt: cart.updated_at || null,
-      userEmail: cart.email || "",
-      phone: "",
-      subtotal,
-      shippingCharges: 0,
-      discount: 0,
-      total: subtotal,
-      currencyCode: cart.currency,
-      shippingRate: null,
-      fulfillments: [],
-      shippingAddress: null,
-      billingAddress: null,
-      lineItems: lines.map((line) => {
-        const product = line.product_id == null ? void 0 : index.get(line.product_id);
-        const mapped = product ? mapProduct(product) : null;
-        const variant = product?.variants?.find((v) => v.id === line.variant_id);
-        return {
-          id: line.id,
-          productId: line.product_id,
-          variantId: line.variant_id,
-          title: line.title || mapped?.title || "",
-          variantTitle: line.variant_label || line.sku || "",
-          slug: mapped?.slug || "",
-          sku: line.sku || "",
-          thumbnail: absoluteMedia(variant?.image?.url) || mapped?.thumbnail || null,
-          qty: line.quantity,
-          price: fromMoney(line.unit_price),
-          subtotal: fromMoney(line.total),
-          total: fromMoney(line.total)
-        };
-      })
-    };
   }
-  /**
-   * The shopper's orders. Without an account there is no server-side list to ask for, so this is
-   * every order placed from this browser, newest first — which is exactly what it can know.
-   */
-  async list({ page = 1 } = {}) {
-    const numbers = readOrderNumbers().reverse();
-    if (!numbers.length) return emptyPage(page);
-    const start = (page - 1) * PAGE_SIZE;
-    const window2 = numbers.slice(start, start + PAGE_SIZE);
-    const orders = await Promise.all(
-      window2.map(async (number) => {
-        const token = readOrderToken(number);
-        return token ? this.present(await this.readOrder(number, token)) : null;
-      })
-    );
-    return paginated(orders.filter(Boolean), numbers.length, page);
-  }
-  /** What the confirmation page loads with, server-side, straight after checkout. */
-  async listOrdersByParent({ orderNo, cartId }) {
-    const number = usable(orderNo);
-    if (!number) return emptyPage();
-    const token = readOrderToken(number);
-    if (token) {
-      const order = await this.present(await this.readOrder(number, token));
-      if (order) return paginated([order], 1, 1, 1);
+  /** The signed-in shopper's orders, newest claim first. */
+  async list({ page = 1, limit = 20 } = {}) {
+    const env = await this.engine("/x/identity/me/orders", { query: { page, limit }, auth: true });
+    return toPage(env, toOrder);
+  }
+  /** One order by number: the account's when signed in, otherwise one this browser placed. */
+  async getOrder(number) {
+    const kept = placedOrder(number);
+    if (kept) {
+      return toOrder(
+        await this.data(`/api/orders/${encodeURIComponent(number)}`, { query: { token: kept.token } })
+      );
     }
-    const cart = usable(cartId);
-    if (cart) {
-      const reconstructed = await this.orderFromCart(cart, number);
-      if (reconstructed) return paginated([reconstructed], 1, 1, 1);
+    if (sessionToken()) {
+      return toOrder(await this.data(`/x/identity/me/orders/${encodeURIComponent(number)}`, { auth: true }));
     }
-    return emptyPage();
+    throw new GoCommerceError(
+      inBrowser() ? "Sign in to see this order, or open it from the browser that placed it." : "order not found",
+      404,
+      "not_found"
+    );
   }
-  async getOrder(orderNo) {
-    const number = usable(orderNo);
-    if (!number) return {};
-    const token = readOrderToken(number);
-    if (!token) return {};
-    return await this.present(await this.readOrder(number, token)) ?? {};
+  /** Everything the signed-in shopper has bought, once each, most recent first. */
+  async buyAgain() {
+    const orders = await this.data("/x/identity/me/orders", { query: { limit: 20 }, auth: true }) ?? [];
+    const seen = /* @__PURE__ */ new Set();
+    const lines = [];
+    for (const o of orders) {
+      for (const l of o.line_items ?? []) {
+        if (!l.product_id || !l.variant_id || seen.has(l.variant_id)) continue;
+        seen.add(l.variant_id);
+        lines.push({
+          productId: l.product_id,
+          variantId: l.variant_id,
+          title: l.title,
+          img: l.image_url ?? null,
+          price: toMajor(l.unit_price),
+          qty: l.quantity
+        });
+      }
+    }
+    const live = await Promise.all(
+      lines.map((l) => this.data(`/api/products/${l.productId}`).catch(() => null))
+    );
+    return lines.flatMap((l, i) => {
+      const p = live[i];
+      if (!p) return [];
+      return [{ ...l, productId: String(l.productId), variantId: String(l.variantId), slug: p.slug }];
+    });
   }
-  async fetchOrder(id) {
-    return this.getOrder(id);
+  /** The "someone just bought" popup would publish other shoppers' purchases; the engine offers none. */
+  async listPublic(_args = {}) {
+    return emptyPage();
   }
-  async fetchTrackOrder(id) {
-    return this.listOrdersByParent({ orderNo: id, cartId: null });
+  async getOrderByEmailAndOTP() {
+    throw new NotSupportedError(
+      "OrderService",
+      "getOrderByEmailAndOTP",
+      "the engine sends no one-time codes; a guest reads an order with its access token"
+    );
   }
-  async paySuccessPageHit(orderId) {
-    return this.getOrder(orderId);
+};
+var clean2 = (v) => v && v !== "undefined" && v !== "null" ? v : void 0;
+var orderService = new OrderService();
+
+// src/services/user-service.ts
+var UserService = class extends BaseService {
+  /** Email and password. The answer is the user object the storefront keeps in its `me` cookie. */
+  async login({ email, password }) {
+    const auth = await this.account("/x/identity/login", {
+      method: "POST",
+      body: { email: String(email ?? "").trim(), password: String(password ?? "") }
+    });
+    return this.signedIn(auth);
   }
-  // GoCommerce has no email+OTP lookup: an order is reached by its number and access token.
-  async getOrderByEmailAndOTP(_params) {
-    return emptyPage();
+  async signup({
+    email,
+    password,
+    firstName,
+    lastName,
+    phone
+  }) {
+    const name = [firstName, lastName].filter(Boolean).join(" ").trim();
+    const auth = await this.account("/x/identity/register", {
+      method: "POST",
+      body: {
+        email: String(email ?? "").trim(),
+        password: String(password ?? ""),
+        ...name ? { name } : {},
+        ...phone ? { phone: String(phone) } : {}
+      }
+    });
+    return this.signedIn(auth);
   }
-  // No server-side order feed exists to reorder from; `list()` is the shopper's own history.
-  async buyAgain() {
-    return emptyPage();
+  /** Signs out here and on the engine. The storefront assigns the answer to its user: `null`. */
+  async logout() {
+    await this.engine("/x/identity/logout", { method: "POST", auth: true }).catch(() => void 0);
+    endSession();
+    return null;
   }
-  async listPublic() {
-    return emptyPage();
+  async getMe() {
+    return toUser(await this.account("/x/identity/me", { auth: true }));
   }
-  async submitReview(_params) {
-    throw new Error("Product reviews are not available on this store.");
+  async updateProfile(user) {
+    const name = user.name ?? [user.firstName, user.lastName].filter((v) => v !== void 0).join(" ").trim();
+    const c = await this.account("/x/identity/me", {
+      method: "PATCH",
+      auth: true,
+      body: {
+        ...name !== void 0 ? { name } : {},
+        ...user.email ? { email: String(user.email).trim() } : {},
+        ...user.phone !== void 0 && user.phone !== null ? { phone: String(user.phone) } : {}
+      }
+    });
+    updateMe(c);
+    return toUser(c);
   }
-  // Checkout runs through CheckoutService here; these Litekart-era entry points have no equivalent
-  // and must not fall back to an API a GoCommerce store does not run.
-  async codCheckout(_params) {
-    throw new Error("Use checkoutService.checkoutCOD() on GoCommerce.");
+  /**
+   * A password change ends every session the account had, this one included,
+   * and the engine answers a fresh one — which is kept, so the shopper stays
+   * signed in here and nowhere else.
+   */
+  async changePassword({ old, oldPassword, password }) {
+    const auth = await this.account("/x/identity/me/password", {
+      method: "PUT",
+      auth: true,
+      body: { current_password: String(old ?? oldPassword ?? ""), password: String(password ?? "") }
+    });
+    startSession(auth);
+    return toUser(auth.record);
   }
-  async razorpayCheckout(_params) {
-    throw new Error("Use checkoutService.checkoutRazorpay() on GoCommerce.");
+  async deleteUser() {
+    throw new NotSupportedError("UserService", "deleteUser", "an account is closed by the store, on request");
   }
-  async stripeCheckout(_params) {
-    throw new Error("Use checkoutService.checkoutStripe() on GoCommerce.");
+  async checkEmail() {
+    throw new NotSupportedError("UserService", "checkEmail", "the engine does not say which addresses have accounts");
   }
-  async cashfreeCheckout(_params) {
-    throw new Error("Use checkoutService.checkoutCashfree() on GoCommerce.");
+  async joinAsVendor() {
+    throw new NotSupportedError("UserService", "joinAsVendor", "sellers are invited by the store");
   }
-  async razorCapture(_params) {
-    throw new Error("Use checkoutService.captureRazorpayPayment() on GoCommerce.");
+  async signedIn(auth) {
+    const me = startSession(auth);
+    const cartId = storedCartId();
+    if (cartId) await this.claimCartForAccount(cartId);
+    return me;
   }
-};
-var orderService = OrderService.getInstance();
-
-// src/services/store.ts
-var listOf = (items) => paginated(items, items.length, 1, items.length || PAGE_SIZE);
-var StoreService = class _StoreService extends BaseService {
-  static instance;
-  static getInstance() {
-    if (!_StoreService.instance) _StoreService.instance = new _StoreService();
-    return _StoreService.instance;
-  }
-  async getStoreByIdOrDomain(_params = {}) {
-    const store = await readStaticStoreDetails();
-    if (!store) {
-      throw new Error("No store configuration is registered \u2014 check kitcommerce.config.ts (see docs/GOCOMMERCE.md).");
+  /** An identity call, with a 404 from a build without the module said in words. */
+  async account(path, req = {}) {
+    try {
+      return await this.data(path, req);
+    } catch (err) {
+      if (err instanceof GoCommerceError && err.status === 404 && /no route/i.test(err.message)) {
+        throw new GoCommerceError("Accounts are not available on this store.", 404, "not_found");
+      }
+      if (err instanceof GoCommerceError && err.status === 401 && req.auth) endSession();
+      throw err;
     }
-    return store;
-  }
-  /** The settings store asks for the record by id; there is only ever the configured one. */
-  async getStore(_storeId) {
-    return this.getStoreByIdOrDomain({});
   }
 };
-var storeService = StoreService.getInstance();
-var MenuService = class _MenuService extends BaseService {
-  static instance;
-  static getInstance() {
-    if (!_MenuService.instance) _MenuService.instance = new _MenuService();
-    return _MenuService.instance;
-  }
-  /** The nav reads `response.data` and filters it on `menuId`, the way the Litekart API served it. */
-  async list() {
-    const store = await readStaticStore();
-    return { data: store?.menu ?? [] };
+var AuthService = class extends UserService {
+  async forgotPassword({ email }) {
+    return this.account("/x/identity/password-reset", {
+      method: "POST",
+      body: { email: String(email ?? "").trim() }
+    });
   }
-};
-var menuService = MenuService.getInstance();
-var StateService = class _StateService extends BaseService {
-  static instance;
-  static getInstance() {
-    if (!_StateService.instance) _StateService.instance = new _StateService();
-    return _StateService.instance;
+  /** The token arrives in the link the engine emailed (`GOCOMMERCE_IDENTITY_RESET_URL`). */
+  async resetPassword({ token, password }) {
+    const auth = await this.account("/x/identity/password-reset/confirm", {
+      method: "POST",
+      body: { token: String(token ?? ""), password: String(password ?? "") }
+    });
+    return startSession(auth);
   }
-  // No state list ships with the store record, and GoCommerce takes the state as free text.
-  async list() {
-    return listOf([]);
+  /** Answers `{ errorCode, message }` on failure rather than throwing: that is how the page reads it. */
+  async verifyEmail(_email, token) {
+    try {
+      const c = await this.account("/x/identity/email-verification/confirm", {
+        method: "POST",
+        body: { token: String(token ?? "") }
+      });
+      return { ...toUser(c), message: "Your email address is confirmed." };
+    } catch (err) {
+      return { errorCode: err.code ?? "invalid_token", message: err.message };
+    }
   }
-};
-var stateService = StateService.getInstance();
-var CurrencyService = class _CurrencyService extends BaseService {
-  static instance;
-  static getInstance() {
-    if (!_CurrencyService.instance) _CurrencyService.instance = new _CurrencyService();
-    return _CurrencyService.instance;
-  }
-  /** One currency: GoCommerce prices a store in the currency its catalogue is recorded in. */
-  async listCurrencies() {
-    const store = await readStaticStore();
-    return listOf(store?.currency ? [store.currency] : []);
+  async getOtp() {
+    throw new NotSupportedError("AuthService", "getOtp", "sign in with an email and password");
   }
-};
-var currencyService = CurrencyService.getInstance();
-var RegionService = class _RegionService extends BaseService {
-  static instance;
-  static getInstance() {
-    if (!_RegionService.instance) _RegionService.instance = new _RegionService();
-    return _RegionService.instance;
+  async verifyOtp() {
+    throw new NotSupportedError("AuthService", "verifyOtp", "sign in with an email and password");
   }
-  // GoCommerce has no regions; one store, one currency, one price list.
-  async getRegionByRegionId(_id) {
-    return {};
+  async joinAsAdmin() {
+    throw new NotSupportedError("AuthService", "joinAsAdmin", "operators are invited from the admin panel");
   }
 };
-var regionService = RegionService.getInstance();
-var PluginService = class _PluginService extends BaseService {
-  static instance;
-  static getInstance() {
-    if (!_PluginService.instance) _PluginService.instance = new _PluginService();
-    return _PluginService.instance;
+var ProfileService = class extends UserService {
+  async getOne() {
+    return this.getMe();
   }
-  async list(_params = {}) {
-    const store = await readStaticStore();
-    return listOf(store?.plugins ?? []);
+  async save(profile) {
+    return this.updateProfile(profile);
   }
 };
-var pluginService = PluginService.getInstance();
-var pluginsService = pluginService;
-var SettingService = class _SettingService extends BaseService {
-  static instance;
-  static getInstance() {
-    if (!_SettingService.instance) _SettingService.instance = new _SettingService();
-    return _SettingService.instance;
-  }
-  async fetchSetting() {
-    const store = await readStaticStore();
-    return store ? [store] : [];
+var userService = new UserService();
+var authService = new AuthService();
+var profileService = new ProfileService();
+
+// src/services/address-service.ts
+var AddressService = class extends BaseService {
+  async list({
+    page = 1,
+    limit = 20
+  } = {}) {
+    const env = await this.engine("/x/identity/me/addresses", {
+      query: { page, limit },
+      auth: true
+    });
+    const email = currentMe()?.email;
+    const rows = env.data ?? [];
+    return {
+      data: rows.map((a) => fromIdentityAddress(a, email)),
+      count: env.meta?.total ?? rows.length,
+      pageSize: env.meta?.limit ?? limit,
+      noOfPage: env.meta?.total_pages ?? 1,
+      page: env.meta?.page ?? page
+    };
   }
-  // Settings are the storefront's own configuration; a storefront must not write them back.
-  async saveSettings(_setting) {
-    throw new Error("Store settings are configured in kitcommerce.config.ts, not from the storefront.");
+  async fetchAddress(id) {
+    return fromIdentityAddress(
+      await this.data(`/x/identity/me/addresses/${enc(id)}`, { auth: true }),
+      currentMe()?.email
+    );
   }
-  async updateSettings(_id, _setting) {
-    throw new Error("Store settings are configured in kitcommerce.config.ts, not from the storefront.");
+  /** New when it has no id (or the form's `'new'`), an edit when it has one — the storefront saves both here. */
+  async saveAddress(address) {
+    const id = address?.id && address.id !== "new" ? String(address.id) : null;
+    if (id) return this.editAddress(id, address);
+    const a = await this.data("/x/identity/me/addresses", {
+      method: "POST",
+      auth: true,
+      body: toIdentityAddress(address)
+    });
+    return fromIdentityAddress(a, currentMe()?.email);
   }
-};
-var settingService = SettingService.getInstance();
-var settingsService = settingService;
-var InitService = class _InitService extends BaseService {
-  static instance;
-  static getInstance() {
-    if (!_InitService.instance) _InitService.instance = new _InitService();
-    return _InitService.instance;
+  async editAddress(id, address) {
+    const a = await this.data(`/x/identity/me/addresses/${enc(id)}`, {
+      method: "PATCH",
+      auth: true,
+      body: toIdentityAddress(address)
+    });
+    return fromIdentityAddress(a, currentMe()?.email);
   }
-  async fetchInit() {
-    const store = await readStaticStore();
-    return store ? [store] : [];
+  async deleteAddress(id) {
+    await this.engine(`/x/identity/me/addresses/${enc(id)}`, { method: "DELETE", auth: true });
+    return { id: String(id), deleted: true };
   }
 };
-var initService = InitService.getInstance();
-var HomeService = class _HomeService extends BaseService {
-  static instance;
-  static getInstance() {
-    if (!_HomeService.instance) _HomeService.instance = new _HomeService();
-    return _HomeService.instance;
-  }
-  // The homepage is composed from the storefront's own blocks; GoCommerce stores no page layouts.
-  async getHome() {
-    return [];
+var enc = (id) => encodeURIComponent(String(id));
+var addressService = new AddressService();
+
+// src/services/wishlist-service.ts
+var WishlistService = class extends BaseService {
+  async fetchWishlist(_args = {}) {
+    const list = await this.current();
+    if (!list) return { data: [], count: 0 };
+    const items = (list.items ?? []).filter((i) => !i.deleted);
+    const products = await Promise.all(
+      items.map((i) => this.data(`/api/products/${i.product_id}`).catch(() => null))
+    );
+    const data = items.flatMap((item, n) => {
+      const p = products[n];
+      if (!p) return [];
+      return [
+        {
+          id: String(item.id),
+          productId: String(item.product_id),
+          variantId: item.variant_id ? String(item.variant_id) : null,
+          product: toProduct(p),
+          variant: { id: item.variant_id ? String(item.variant_id) : null },
+          createdAt: item.created_at
+        }
+      ];
+    });
+    return { data, count: data.length };
+  }
+  /** Saved → removed, removed → saved. `{ active }` is the state after the click. */
+  async toggleWishlist({ productId, variantId }) {
+    const list = await this.current() ?? await this.create();
+    const item = (list.items ?? []).find((i) => String(i.product_id) === String(productId));
+    if (item) {
+      await this.data(`/x/wishlist/${enc2(list.token)}/items/${item.id}`, { method: "DELETE" });
+      return { active: false, id: String(item.id) };
+    }
+    const next = await this.data(`/x/wishlist/${enc2(list.token)}/items`, {
+      method: "POST",
+      body: { product_id: Number(productId), ...variantId ? { variant_id: Number(variantId) } : {} }
+    });
+    const added = (next.items ?? []).find((i) => String(i.product_id) === String(productId));
+    return { active: true, id: added ? String(added.id) : null };
   }
-};
-var homeService = HomeService.getInstance();
-var PopularSearchService = class _PopularSearchService extends BaseService {
-  static instance;
-  static getInstance() {
-    if (!_PopularSearchService.instance) _PopularSearchService.instance = new _PopularSearchService();
-    return _PopularSearchService.instance;
+  async checkWishlist({ productId }) {
+    const list = await this.current();
+    return !!list && (list.items ?? []).some((i) => String(i.product_id) === String(productId));
   }
-  // GoCommerce records no search analytics, so there are no popular searches to report.
-  async listPopularSearch(_params = {}) {
-    return listOf([]);
+  async checkWishlistInBulk(pairs) {
+    const list = await this.current();
+    const saved = new Set((list?.items ?? []).map((i) => String(i.product_id)));
+    return (pairs ?? []).map((p) => ({ ...p, exists: saved.has(String(p.productId)) }));
   }
-};
-var popularSearchService = PopularSearchService.getInstance();
-var PopularityService = class _PopularityService extends BaseService {
-  static instance;
-  static getInstance() {
-    if (!_PopularityService.instance) _PopularityService.instance = new _PopularityService();
-    return _PopularityService.instance;
+  async current() {
+    const token = wishlistToken();
+    if (!token) return null;
+    try {
+      return { ...await this.data(`/x/wishlist/${enc2(token)}`), token };
+    } catch (err) {
+      if (err instanceof GoCommerceError && err.status === 404 && !/no wishlist|no route/i.test(err.message)) {
+        forgetWishlistToken();
+        return null;
+      }
+      throw err;
+    }
   }
-  /** Nothing to record against: a view counter is not part of this API. Accepted and dropped. */
-  async updatePopularity(_params = {}) {
-    return { success: true };
+  async create() {
+    const email = currentMe()?.email;
+    const list = await this.data("/x/wishlist", { method: "POST", ...email ? { body: { email } } : {} });
+    if (!list.token) throw new GoCommerceError("The store did not return a wishlist token.", 500);
+    rememberWishlistToken(list.token);
+    return { ...list, token: list.token };
   }
 };
-var popularityService = PopularityService.getInstance();
+var enc2 = (s) => encodeURIComponent(s);
+var wishlistService = new WishlistService();
 
-// src/services/unsupported.ts
-var unavailable = (what) => new Error(`${what} is not available on this store.`);
-var singleton = (Ctor) => {
-  let instance;
-  return () => instance ??= new Ctor();
-};
-var NO_ACCOUNTS = "Accounts are not available on this store \u2014 checkout does not need one";
-var UserService = class _UserService extends BaseService {
-  static getInstance = singleton(_UserService);
-  /** No session to report. `null` is what the header and guards check for. */
-  async getMe() {
-    return null;
-  }
-  async getUser(_id) {
-    return null;
-  }
-  async login(_params) {
-    throw new Error(`${NO_ACCOUNTS}.`);
+// src/services/review-service.ts
+var ReviewService = class extends BaseService {
+  async fetchReviews({
+    productId,
+    currentPage = 1,
+    page,
+    limit = 20
+  } = {}) {
+    if (!productId) return { data: [], count: 0, pageSize: limit, noOfPage: 0, page: 1 };
+    const p = Math.max(1, Number(page ?? currentPage) || 1);
+    const res = await this.data("/x/reviews", { query: { product_id: productId, page: p, limit } });
+    const total = res.meta?.total ?? res.summary?.count ?? 0;
+    return {
+      data: (res.reviews ?? []).map(toRating),
+      count: total,
+      pageSize: limit,
+      noOfPage: Math.max(1, Math.ceil(total / limit)),
+      page: p,
+      summary: res.summary ?? null
+    };
   }
-  async signup(_params) {
-    throw new Error(`${NO_ACCOUNTS}.`);
+  async allReviews(args = {}) {
+    return this.fetchReviews(args);
   }
-  async joinAsVendor(_params) {
-    throw unavailable("Vendor signup");
+};
+var reviewService = new ReviewService();
+
+// src/services/menu-service.ts
+function linkFor(item) {
+  const t = item.target ?? "";
+  switch (item.kind) {
+    case "home":
+      return "/";
+    case "product":
+      return t ? `/products/${t}` : item.url;
+    case "collection":
+      return t ? `/collections/${t}` : item.url;
+    case "category":
+      return t ? `/${t}` : item.url;
+    case "page":
+      return t ? `/p/${t}` : item.url;
+    default:
+      return item.url;
+  }
+}
+var toItem = (item, i) => ({
+  id: String(item.id ?? i),
+  name: item.title,
+  link: linkFor(item),
+  items: (item.children ?? []).map(toItem)
+});
+var MenuService = class extends BaseService {
+  facts = new StoreFacts(this._fetch);
+  async list(_args = {}) {
+    const menus = await this.engineMenus();
+    if (menus) return { data: menus };
+    return resolveRestLocally("get", "/api/menu");
+  }
+  /** The header and footer menus, or `null` when the module is not there. Cached: a menu is store-level. */
+  async engineMenus() {
+    if (!await this.facts.pluginOn("navigation")) return null;
+    return remember(`${this.engineBase()}|${this.creds.store ?? ""}|menus`, async () => {
+      const out = [];
+      for (const handle of ["header", "footer"]) {
+        try {
+          const m = await this.data(`/x/navigation/menus/${handle}`);
+          out.push({ menuId: handle, name: m.title, items: (m.items ?? []).map(toItem) });
+        } catch {
+        }
+      }
+      return out;
+    }).catch(() => null);
   }
-  async forgotPassword(_params) {
-    throw new Error(`${NO_ACCOUNTS}.`);
+};
+var menuService = new MenuService();
+var readStaticStore = async () => {
+  return {};
+};
+
+// src/services/store-service.ts
+function symbolFor(code) {
+  try {
+    const part = new Intl.NumberFormat("en", { style: "currency", currency: code }).formatToParts(0).find((p) => p.type === "currency");
+    return part?.value ?? code;
+  } catch {
+    return code;
   }
-  async resetPassword(_params) {
-    throw new Error(`${NO_ACCOUNTS}.`);
+}
+var StoreService = class extends BaseService {
+  facts = new StoreFacts(this._fetch);
+  async getStoreByIdOrDomain(_args = {}) {
+    const base = await readStaticStore();
+    const live = await this.live().catch(() => ({}));
+    return { ...base, ...live, id: base.id || "gocommerce" };
   }
-  async changePassword(_params) {
-    throw new Error(`${NO_ACCOUNTS}.`);
+  async getStore(storeId) {
+    return this.getStoreByIdOrDomain({ storeId });
   }
-  async getOtp(_params) {
-    throw new Error(`${NO_ACCOUNTS}.`);
+  /**
+   * The storefront's sitemap route asks for `/api/stores/<id>` and serves the
+   * `sitemap` path it gets back from `PUBLIC_SITEMAP_URL`. With ext/sitemaps
+   * installed, `/sitemaps/sitemap.xml` under `PUBLIC_SITEMAP_URL=<engine>/x`
+   * is the engine's own sitemap; without it, an empty path is the route's
+   * clean 404 rather than a crash.
+   */
+  async get(path) {
+    if (path.split("?")[0].startsWith("/api/stores/")) {
+      const on = await this.facts.pluginOn("sitemap");
+      return { sitemap: on ? "/sitemaps/sitemap.xml" : "" };
+    }
+    return super.get(path);
   }
-  async verifyOtp(_params) {
-    throw new Error(`${NO_ACCOUNTS}.`);
+  async live() {
+    const [ready, plugins, menus, base] = await Promise.all([
+      this.facts.ready(),
+      this.facts.plugins().catch(() => /* @__PURE__ */ new Map()),
+      new MenuService(this._fetch).engineMenus(),
+      readStaticStore()
+    ]);
+    const code = ready.currency;
+    const sameCurrency = (base.currency?.code ?? base.currencyCode) === code;
+    const flag = (on) => ({ ...on ? { active: true } : { active: false } });
+    const basePlugins = base.plugins ?? {};
+    return {
+      currencyCode: code,
+      currencySymbol: sameCurrency ? base.currencySymbol ?? symbolFor(code) : symbolFor(code),
+      currency: {
+        ...base.currency ?? {},
+        code,
+        symbol: sameCurrency ? base.currency?.symbol ?? symbolFor(code) : symbolFor(code)
+      },
+      language: ready.language,
+      plugins: {
+        ...basePlugins,
+        // Features this connector serves from a module: on exactly when the
+        // module is installed and switched on, whatever the static record says.
+        isWishlist: { ...basePlugins.isWishlist, ...flag(plugins.has("wishlist")) },
+        isProductReviewsAndRatings: {
+          ...basePlugins.isProductReviewsAndRatings,
+          ...flag(plugins.has("product-reviews"))
+        }
+      },
+      ...menus?.length ? { menu: menus } : {}
+    };
   }
-  async updateProfile(_params) {
-    throw new Error(`${NO_ACCOUNTS}.`);
+};
+var storeService = new StoreService();
+
+// src/services/page-service.ts
+var PageService = class extends BaseService {
+  async getOne(slug) {
+    return toCmsPage(await this.data(`/x/cms/pages/${encodeURIComponent(String(slug))}`));
+  }
+  async list({ page = 1, limit = 50 } = {}) {
+    const env = await this.engine("/x/cms/pages", { query: { page, limit } });
+    return toPage(env, toCmsPage);
+  }
+};
+var FaqService = class extends BaseService {
+  async listFaqs(_args = {}) {
+    const faq = await this.data("/x/faq");
+    const data = (faq.sections ?? []).flatMap(
+      (s) => (s.entries ?? []).map((e) => ({
+        id: String(e.id),
+        question: e.question,
+        answer: e.answer,
+        category: s.section || null
+      }))
+    );
+    return { data, count: data.length, heading: faq.heading, blurb: faq.blurb };
   }
-  async checkEmail(_email) {
-    return { exists: false };
+  async list(args = {}) {
+    return this.listFaqs(args);
   }
-  async deleteUser(_id) {
-    throw new Error(`${NO_ACCOUNTS}.`);
+};
+var pageService = new PageService();
+var faqService = new FaqService();
+
+// src/services/vendor-service.ts
+var VendorService = class extends BaseService {
+  async list({
+    page = 1,
+    limit = 24,
+    q,
+    search
+  } = {}) {
+    const env = await this.engine("/api/vendors", { query: { page, limit, q: q ?? search } });
+    return toPage(env, toVendor);
+  }
+  async getVendor(slug) {
+    return toVendor(await this.data(`/api/vendors/${encodeURIComponent(String(slug))}`));
   }
   /**
-   * Clears the session this storefront thinks it has.
-   *
-   * There is no session on GoCommerce to end, so it would be easy to make this a no-op — and that
-   * is a trap. The shared user store decides who is signed in by reading the `connect.sid` and `me`
-   * cookies straight from `document.cookie`, not by asking a service. A pair left behind by running
-   * this storefront against a backend that does have accounts therefore makes GoCommerce look
-   * signed-in, which sends the checkout down the saved-address path instead of the guest one. The
-   * checkout page already knows to call `logout()` and retry when that happens — so this has to
-   * actually clear them, or that recovery does nothing.
+   * A seller's shelf. The engine's vendors sell through offers on the shop's
+   * own variants and the public API lists no products by seller, so the shelf
+   * is empty — the seller's page still renders, with their details.
    */
-  async logout() {
-    clearPhantomSession();
-    return { success: true };
+  async fetchProductsOfVendor(_vendorId) {
+    return emptyPage();
   }
 };
-var userService = UserService.getInstance();
-var AuthService = class _AuthService extends UserService {
-  static getInstance = singleton(_AuthService);
-  async verifyEmail(_email, _token) {
-    throw new Error(`${NO_ACCOUNTS}, so there is no address to verify.`);
-  }
-  async joinAsAdmin(_params) {
-    throw unavailable("Admin signup");
+var vendorService = new VendorService();
+
+// src/services/misc-services.ts
+var refuse = (service, method, why) => new NotSupportedError(service, method, why);
+var ContactService = class extends BaseService {
+  async submitContactUsForm({
+    name,
+    email,
+    phone,
+    message,
+    subject
+  }) {
+    return this.data("/x/contact/messages", {
+      method: "POST",
+      body: {
+        name: String(name ?? ""),
+        email: String(email ?? ""),
+        ...phone ? { phone: String(phone) } : {},
+        ...subject ? { subject: String(subject) } : {},
+        body: String(message ?? "")
+      }
+    });
   }
 };
-var authService = AuthService.getInstance();
-var ProfileService = class _ProfileService extends BaseService {
-  static getInstance = singleton(_ProfileService);
-  async getOne() {
-    return null;
-  }
-  async save(_profile) {
-    throw new Error(`${NO_ACCOUNTS}.`);
+var EnquiryService = class extends ContactService {
+  async create({
+    name,
+    email,
+    phone,
+    message,
+    productId
+  }) {
+    return this.submitContactUsForm({
+      name,
+      email,
+      phone,
+      subject: productId ? `Enquiry about product ${productId}` : "Enquiry",
+      message
+    });
   }
 };
-var profileService = ProfileService.getInstance();
-var AddressService = class _AddressService extends BaseService {
-  static getInstance = singleton(_AddressService);
-  async list(params = {}) {
-    const addresses = listAddresses();
-    const page = Math.max(1, Number(params.page || 1) || 1);
-    const start = (page - 1) * PAGE_SIZE;
-    return paginated(addresses.slice(start, start + PAGE_SIZE), addresses.length, page);
-  }
-  async fetchAddress(id) {
-    const address = findAddress(id);
-    if (!address) throw new Error("That address is no longer saved on this device.");
-    return address;
-  }
-  async saveAddress(address) {
-    return putAddress(address);
-  }
-  async editAddress(id, address) {
-    const saved = patchAddress(id, address);
-    if (!saved) throw new Error("That address is no longer saved on this device.");
-    return saved;
-  }
-  async deleteAddress(id) {
-    removeAddress(id);
+var PluginService = class extends BaseService {
+  facts = new StoreFacts(this._fetch);
+  async list(_args = {}) {
+    const data = [...(await this.facts.plugins()).values()];
+    return { data, count: data.length, pageSize: data.length, noOfPage: 1, page: 1 };
   }
 };
-var addressService = AddressService.getInstance();
-var WishlistService = class _WishlistService extends BaseService {
-  static getInstance = singleton(_WishlistService);
-  async fetchWishlist(_params = {}) {
-    return emptyPage();
-  }
-  async checkWishlist(_params = {}) {
-    return { data: false };
-  }
-  /** The product grid asks about many ids at once; nothing is on a list that cannot exist. */
-  async checkWishlistInBulk(_ids) {
-    return { data: [] };
+var SettingService = class extends BaseService {
+  async fetchSettings(_args = {}) {
+    return new StoreService(this._fetch).getStoreByIdOrDomain();
   }
-  async toggleWishlist(_params) {
-    throw unavailable("Wishlists");
+  async list(args = {}) {
+    return this.fetchSettings(args);
   }
 };
-var wishlistService = WishlistService.getInstance();
-var CouponService = class _CouponService extends BaseService {
-  static getInstance = singleton(_CouponService);
-  // No discount engine, so the payment step renders no coupon box rather than an empty one.
-  async listCoupons(_params = {}) {
-    return emptyPage();
-  }
-  async searchCoupons(_params = {}) {
-    return emptyPage();
+var InitService = class extends SettingService {
+  async fetchInit(_args = {}) {
+    const store = await this.fetchSettings();
+    return { storeOne: store, store, settings: store };
   }
-  async getCoupon(_id) {
-    throw unavailable("Discount codes");
+};
+var HomeService = class extends BaseService {
+  /** A homepage is assembled by the storefront from shelves; the engine has no page of its own for it. */
+  async getHome(_args = {}) {
+    return { banners: [], groupByBanner: [], categories: [], products: [] };
   }
-  async createCoupon(_coupon) {
-    throw unavailable("Discount codes");
+};
+var CountryService = class extends BaseService {
+  async list(_args = {}) {
+    return resolveRestLocally("get", "/api/countries");
   }
-  async patchCoupon(_id, _coupon) {
-    throw unavailable("Discount codes");
+};
+var CurrencyService = class extends BaseService {
+  facts = new StoreFacts(this._fetch);
+  async listCurrencies(_args = {}) {
+    const { currency } = await this.facts.ready();
+    const data = [{ code: currency, name: currency, isDefault: true }];
+    return { data, count: 1, pageSize: 1, noOfPage: 1, page: 1 };
   }
-  async deleteCoupon(_id) {
-    throw unavailable("Discount codes");
+  async list(args = {}) {
+    return this.listCurrencies(args);
   }
 };
-var couponService = CouponService.getInstance();
-var DealService = class _DealService extends BaseService {
-  static getInstance = singleton(_DealService);
-  async fetchDeals() {
+var StateService = class extends BaseService {
+  async list(_args = {}) {
     return emptyPage();
   }
 };
-var dealService = DealService.getInstance();
-var ReviewService = class _ReviewService extends BaseService {
-  static getInstance = singleton(_ReviewService);
-  async fetchReviews(_params = {}) {
-    return emptyPage();
-  }
-  async allReviews(_params = {}) {
-    return emptyPage();
-  }
-  async fetchProducrReviews(_productId) {
+var RegionService = class extends BaseService {
+  async list(_args = {}) {
     return emptyPage();
   }
-  async saveReview(_review) {
-    throw unavailable("Product reviews");
-  }
 };
-var reviewService = ReviewService.getInstance();
-var PageService = class _PageService extends BaseService {
-  static getInstance = singleton(_PageService);
-  async list(_params = {}) {
-    return emptyPage();
+var AutocompleteService = class extends MeilisearchService {
+  async list({ q, search } = {}) {
+    return this.searchAutoComplete({ query: q ?? search });
   }
-  async listLatestPages(_params = {}) {
+};
+var PopularSearchService = class extends BaseService {
+  async list(_args = {}) {
     return emptyPage();
   }
-  /**
-   * Every caller asks for a fixed, optional slug — `products`, `about-us`, `privacy-policy` — to
-   * dress a page the storefront already renders. So an absent page is the normal state, not a dead
-   * link: answer empty and let the route show its own content, rather than log a failure on every
-   * request for something that was never required.
-   */
-  async getOne(_id) {
-    return {};
+};
+var PopularityService = class extends BaseService {
+  async updatePopularity(_args = {}) {
+    return void 0;
   }
 };
-var pageService = PageService.getInstance();
-var BlogService = class _BlogService extends BaseService {
-  static getInstance = singleton(_BlogService);
-  async list(_params = {}) {
+var BlogService = class extends BaseService {
+  async list(_args = {}) {
     return emptyPage();
   }
-  async getOne(id) {
-    throw new Error(`The post "${id}" does not exist on this store.`);
+  async getOne(_slug) {
+    throw refuse("BlogService", "getOne", "the engine has no blog; publish articles as pages");
   }
 };
-var blogService = BlogService.getInstance();
-var BannerService = class _BannerService extends BaseService {
-  static getInstance = singleton(_BannerService);
-  async list() {
+var BannerService = class extends BaseService {
+  async list(_args = {}) {
     return emptyPage();
   }
-  async fetchBannersGroup() {
-    return emptyPage();
+  async listBanners(args = {}) {
+    return this.list(args);
   }
-};
-var bannerService = BannerService.getInstance();
-var GalleryService = class _GalleryService extends BaseService {
-  static getInstance = singleton(_GalleryService);
-  async fetchGallery() {
-    return [];
+  async fetchBanners(args = {}) {
+    return this.list(args);
   }
 };
-var galleryService = GalleryService.getInstance();
-var ReelsService = class _ReelsService extends BaseService {
-  static getInstance = singleton(_ReelsService);
-  async list() {
+var ReelsService = class extends BaseService {
+  async list(_args = {}) {
     return emptyPage();
   }
 };
-var reelsService = ReelsService.getInstance();
-var FaqService = class _FaqService extends BaseService {
-  static getInstance = singleton(_FaqService);
-  async listFaqs(_params = {}) {
+var DealService = class extends BaseService {
+  async fetchDeals(_args = {}) {
     return emptyPage();
   }
 };
-var faqService = FaqService.getInstance();
-var FeedbackService = class _FeedbackService extends BaseService {
-  static getInstance = singleton(_FeedbackService);
-  async listFeedbacks(_params = {}) {
+var GalleryService = class extends BaseService {
+  async list(_args = {}) {
     return emptyPage();
   }
 };
-var feedbackService = FeedbackService.getInstance();
-var ContactService = class _ContactService extends BaseService {
-  static getInstance = singleton(_ContactService);
-  async submitContactUsForm(_params) {
-    throw unavailable("The contact form");
-  }
-};
-var contactService = ContactService.getInstance();
-var EnquiryService = class _EnquiryService extends BaseService {
-  static getInstance = singleton(_EnquiryService);
-  async create(_params) {
-    throw unavailable("Product enquiries");
-  }
-};
-var enquiryService = EnquiryService.getInstance();
-var ChatService = class _ChatService extends BaseService {
-  static getInstance = singleton(_ChatService);
-  async list() {
-    return [];
+var ChatService = class extends BaseService {
+  async list(_args = {}) {
+    return emptyPage();
   }
   async chats() {
-    return [];
+    throw refuse("ChatService", "chats", "the engine has no shopper chat");
   }
-  async save(_message) {
-    throw unavailable("Messaging");
+  async save() {
+    throw refuse("ChatService", "save", "the engine has no shopper chat");
   }
 };
-var chatService = ChatService.getInstance();
-var UploadService = class _UploadService extends BaseService {
-  static getInstance = singleton(_UploadService);
-  // Media in GoCommerce is an operator's, uploaded through the admin API. A storefront holds no
-  // admin credential and must not act as though it does.
-  async uploadToS3(_params) {
-    throw unavailable("File uploads");
-  }
-  async uploadMultipleToS3(_params) {
-    throw unavailable("File uploads");
-  }
-  async deleteFromS3(_params) {
-    throw unavailable("File uploads");
+var FeedbackService = class extends BaseService {
+  async save() {
+    throw refuse("FeedbackService", "save", "use the contact form");
   }
 };
-var uploadService = UploadService.getInstance();
-var VendorService = class _VendorService extends BaseService {
-  static getInstance = singleton(_VendorService);
-  async list(_params = {}) {
-    return emptyPage();
-  }
-  async getVendor(_id) {
-    throw unavailable("Vendor pages");
-  }
-  async fetchMyVendorDetails() {
-    throw unavailable("Vendor accounts");
-  }
-  async fetchDashboard() {
-    throw unavailable("Vendor accounts");
-  }
-  async fetchProductsOfVendor(_vendorId) {
-    return [];
-  }
-  async getAllVendorRatings(_vendorId) {
-    return [];
+var DemoRequestService = class extends BaseService {
+  async save() {
+    throw refuse("DemoRequestService", "save", "use the contact form");
   }
-  async save(_data) {
-    throw unavailable("Vendor accounts");
+};
+var UploadService = class extends BaseService {
+  async uploadMultipleToS3() {
+    throw refuse("UploadService", "uploadMultipleToS3", "shoppers cannot upload files to the engine");
   }
-  async update(_data) {
-    throw unavailable("Vendor accounts");
+  async upload() {
+    throw refuse("UploadService", "upload", "shoppers cannot upload files to the engine");
   }
 };
-var vendorService = VendorService.getInstance();
-var VarniCustomDesignService = class _VarniCustomDesignService extends BaseService {
-  static getInstance = singleton(_VarniCustomDesignService);
-  async submitForm(_formDetails) {
-    throw unavailable("Custom design requests");
+var WarrantyService = class extends BaseService {
+  async submitWarrantyRegistration() {
+    throw refuse("WarrantyService", "submitWarrantyRegistration", "the engine has no warranty registrations");
   }
 };
-var varniCustomDesignService = VarniCustomDesignService.getInstance();
-var VarniCustomProductService = class _VarniCustomProductService extends BaseService {
-  static getInstance = singleton(_VarniCustomProductService);
-  async checkForCombinationWith(_args) {
-    return { data: [], count: 0, pageSize: PAGE_SIZE, noOfPage: 0, page: 1 };
-  }
-  async createCustomOrderChat(_productId) {
-    throw unavailable("Custom product chat");
+var VarniCustomDesignService = class extends BaseService {
+  async submitForm() {
+    throw refuse("VarniCustomDesignService", "submitForm", "custom design requests are a Litekart feature");
   }
-  async sendMessageToCustomOrderChat(_chatId, _vendor, _message) {
-    throw unavailable("Custom product chat");
+};
+var VarniCustomProductService = class extends BaseService {
+  async list(_args = {}) {
+    return emptyPage();
   }
 };
-var varniCustomProductService = VarniCustomProductService.getInstance();
+var staticStore = () => readStaticStore();
+var contactService = new ContactService();
+var enquiryService = new EnquiryService();
+var pluginService = new PluginService();
+var settingService = new SettingService();
+var initService = new InitService();
+var homeService = new HomeService();
+var countryService = new CountryService();
+var currencyService = new CurrencyService();
+var stateService = new StateService();
+var regionService = new RegionService();
+var autocompleteService = new AutocompleteService();
+var popularSearchService = new PopularSearchService();
+var popularityService = new PopularityService();
+var blogService = new BlogService();
+var bannerService = new BannerService();
+var reelsService = new ReelsService();
+var dealService = new DealService();
+var galleryService = new GalleryService();
+var chatService = new ChatService();
+var feedbackService = new FeedbackService();
+var demoRequestService = new DemoRequestService();
+var uploadService = new UploadService();
+var warrantyService = new WarrantyService();
+var varniCustomDesignService = new VarniCustomDesignService();
+var varniCustomProductService = new VarniCustomProductService();
+var pluginsService = pluginService;
+var settingsService = settingService;
 
-exports.API_PROXY_PREFIX = API_PROXY_PREFIX;
 exports.AddressService = AddressService;
 exports.AuthService = AuthService;
 exports.AutocompleteService = AutocompleteService;
@@ -2354,26 +2573,26 @@ exports.BannerService = BannerService;
 exports.BaseService = BaseService;
 exports.BlogService = BlogService;
 exports.CartService = CartService;
+exports.CatalogService = CatalogService;
 exports.CategoryService = CategoryService;
 exports.ChatService = ChatService;
 exports.CheckoutService = CheckoutService;
 exports.CollectionService = CollectionService;
 exports.ContactService = ContactService;
+exports.CountryService = CountryService;
 exports.CouponService = CouponService;
 exports.CurrencyService = CurrencyService;
 exports.DealService = DealService;
+exports.DemoRequestService = DemoRequestService;
 exports.EnquiryService = EnquiryService;
 exports.FaqService = FaqService;
 exports.FeedbackService = FeedbackService;
 exports.GalleryService = GalleryService;
-exports.GoCommerceError = GoCommerceError;
 exports.HomeService = HomeService;
 exports.InitService = InitService;
-exports.MAX_LIMIT = MAX_LIMIT;
 exports.MeilisearchService = MeilisearchService;
 exports.MenuService = MenuService;
 exports.OrderService = OrderService;
-exports.PAGE_SIZE = PAGE_SIZE;
 exports.PageService = PageService;
 exports.PaymentMethodService = PaymentMethodService;
 exports.PluginService = PluginService;
@@ -2395,8 +2614,8 @@ exports.UserService = UserService;
 exports.VarniCustomDesignService = VarniCustomDesignService;
 exports.VarniCustomProductService = VarniCustomProductService;
 exports.VendorService = VendorService;
+exports.WarrantyService = WarrantyService;
 exports.WishlistService = WishlistService;
-exports.absoluteMedia = absoluteMedia;
 exports.addressService = addressService;
 exports.authService = authService;
 exports.autocompleteService = autocompleteService;
@@ -2406,72 +2625,48 @@ exports.cartService = cartService;
 exports.categoryService = categoryService;
 exports.chatService = chatService;
 exports.checkoutService = checkoutService;
-exports.clearCheckoutDetails = clearCheckoutDetails;
-exports.clearPhantomSession = clearPhantomSession;
 exports.collectionService = collectionService;
 exports.contactService = contactService;
+exports.countryService = countryService;
 exports.couponService = couponService;
-exports.currencyFractionDigits = currencyFractionDigits;
 exports.currencyService = currencyService;
 exports.dealService = dealService;
+exports.demoRequestService = demoRequestService;
 exports.emptyPage = emptyPage;
 exports.enquiryService = enquiryService;
 exports.faqService = faqService;
 exports.feedbackService = feedbackService;
-exports.findAddress = findAddress;
-exports.flattenMetadata = flattenMetadata;
-exports.fromMoney = fromMoney;
 exports.galleryService = galleryService;
-exports.hasPhantomSession = hasPhantomSession;
-exports.hasStaticStore = hasStaticStore;
 exports.homeService = homeService;
 exports.initService = initService;
-exports.listAddresses = listAddresses;
-exports.mapCart = mapCart;
-exports.mapCategory = mapCategory;
-exports.mapCollection = mapCollection;
-exports.mapOrder = mapOrder;
-exports.mapProduct = mapProduct;
 exports.meilisearchService = meilisearchService;
 exports.menuService = menuService;
 exports.orderService = orderService;
 exports.pageService = pageService;
-exports.paginated = paginated;
-exports.patchAddress = patchAddress;
 exports.paymentMethodService = paymentMethodService;
 exports.pluginService = pluginService;
 exports.pluginsService = pluginsService;
 exports.popularSearchService = popularSearchService;
 exports.popularityService = popularityService;
-exports.productImages = productImages;
 exports.productService = productService;
 exports.profileService = profileService;
-exports.putAddress = putAddress;
-exports.readCheckoutDetails = readCheckoutDetails;
-exports.readOrderNumbers = readOrderNumbers;
-exports.readOrderToken = readOrderToken;
-exports.readStaticStore = readStaticStore;
-exports.readStaticStoreDetails = readStaticStoreDetails;
+exports.qs = qs;
 exports.reelsService = reelsService;
 exports.regionService = regionService;
-exports.rememberOrderToken = rememberOrderToken;
-exports.removeAddress = removeAddress;
-exports.resolveProductIndex = resolveProductIndex;
 exports.reviewService = reviewService;
 exports.searchService = searchService;
-exports.setStaticStore = setStaticStore;
 exports.settingService = settingService;
 exports.settingsService = settingsService;
 exports.stateService = stateService;
+exports.staticStore = staticStore;
 exports.storeService = storeService;
-exports.toGoCommerceAddress = toGoCommerceAddress;
-exports.toStorefrontAddress = toStorefrontAddress;
+exports.toPage = toPage;
 exports.uploadService = uploadService;
 exports.userService = userService;
 exports.varniCustomDesignService = varniCustomDesignService;
 exports.varniCustomProductService = varniCustomProductService;
 exports.vendorService = vendorService;
+exports.warrantyService = warrantyService;
 exports.wishlistService = wishlistService;
-exports.writeCheckoutDetails = writeCheckoutDetails;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map