@misiki/gocommerce-connector 0.1.0 → 0.2.0

package/dist/services/index.js

@@ -1,2349 +1,2569 @@
-// 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;
 
-export { API_PROXY_PREFIX, AddressService, AuthService, AutocompleteService, BannerService, BaseService, BlogService, CartService, CategoryService, ChatService, CheckoutService, CollectionService, ContactService, CouponService, CurrencyService, DealService, EnquiryService, FaqService, FeedbackService, GalleryService, GoCommerceError, HomeService, InitService, MAX_LIMIT, MeilisearchService, MenuService, OrderService, PAGE_SIZE, PageService, PaymentMethodService, PluginService, PluginService as PluginsService, PopularSearchService, PopularityService, ProductService, ProfileService, ReelsService, RegionService, ReviewService, SearchService, SettingService, SettingService as SettingsService, StateService, StoreService, UploadService, UserService, VarniCustomDesignService, VarniCustomProductService, VendorService, WishlistService, absoluteMedia, addressService, authService, autocompleteService, bannerService, blogService, cartService, categoryService, chatService, checkoutService, clearCheckoutDetails, clearPhantomSession, collectionService, contactService, couponService, currencyFractionDigits, currencyService, dealService, emptyPage, enquiryService, faqService, feedbackService, findAddress, flattenMetadata, fromMoney, galleryService, hasPhantomSession, hasStaticStore, homeService, initService, listAddresses, mapCart, mapCategory, mapCollection, mapOrder, mapProduct, meilisearchService, menuService, orderService, pageService, paginated, patchAddress, paymentMethodService, pluginService, pluginsService, popularSearchService, popularityService, productImages, productService, profileService, putAddress, readCheckoutDetails, readOrderNumbers, readOrderToken, readStaticStore, readStaticStoreDetails, reelsService, regionService, rememberOrderToken, removeAddress, resolveProductIndex, reviewService, searchService, setStaticStore, settingService, settingsService, stateService, storeService, toGoCommerceAddress, toStorefrontAddress, uploadService, userService, varniCustomDesignService, varniCustomProductService, vendorService, wishlistService, writeCheckoutDetails };
+export { AddressService, AuthService, AutocompleteService, BannerService, BaseService, BlogService, CartService, CatalogService, CategoryService, ChatService, CheckoutService, CollectionService, ContactService, CountryService, CouponService, CurrencyService, DealService, DemoRequestService, EnquiryService, FaqService, FeedbackService, GalleryService, HomeService, InitService, MeilisearchService, MenuService, OrderService, PageService, PaymentMethodService, PluginService, PluginService as PluginsService, PopularSearchService, PopularityService, ProductService, ProfileService, ReelsService, RegionService, ReviewService, SearchService, SettingService, SettingService as SettingsService, StateService, StoreService, UploadService, UserService, VarniCustomDesignService, VarniCustomProductService, VendorService, WarrantyService, WishlistService, addressService, authService, autocompleteService, bannerService, blogService, cartService, categoryService, chatService, checkoutService, collectionService, contactService, countryService, couponService, currencyService, dealService, demoRequestService, emptyPage, enquiryService, faqService, feedbackService, galleryService, homeService, initService, meilisearchService, menuService, orderService, pageService, paymentMethodService, pluginService, pluginsService, popularSearchService, popularityService, productService, profileService, qs, reelsService, regionService, reviewService, searchService, settingService, settingsService, stateService, staticStore, storeService, toPage, uploadService, userService, varniCustomDesignService, varniCustomProductService, vendorService, warrantyService, wishlistService };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map