@misiki/gocommerce-connector 0.1.0

package/dist/index.cjs

@@ -0,0 +1,2477 @@
+'use strict';
+
+// src/services/base.ts
+var API_PROXY_PREFIX = "/proxy/gocommerce";
+var GoCommerceError = class extends Error {
+  code;
+  details;
+  status;
+  constructor(message, code = "internal_error", status = 0, details) {
+    super(message);
+    this.name = "GoCommerceError";
+    this.code = code;
+    this.status = status;
+    this.details = details;
+  }
+};
+var BaseService = class _BaseService {
+  _fetch;
+  static _credentials = {};
+  static _languageCode;
+  constructor(fetchFn) {
+    this._fetch = fetchFn || ((...args) => globalThis.fetch(...args));
+  }
+  setFetch(fetchFn) {
+    this._fetch = fetchFn;
+    return this;
+  }
+  getFetch() {
+    return this._fetch;
+  }
+  /**
+   * 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);
+  }
+  /**
+   * 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();
+  }
+  /**
+   * 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.
+   */
+  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");
+    }
+    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}`}`;
+  }
+  static isBrowser() {
+    return typeof window !== "undefined" && typeof window.document !== "undefined";
+  }
+  /**
+   * One request against the GoCommerce API.
+   *
+   * 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.
+   */
+  async api(method, path, body, headers = {}) {
+    const url = _BaseService.apiUrl(path);
+    const lang = _BaseService.getLanguageCode();
+    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) }
+      });
+    } 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
+      );
+    }
+    const text = await res.text();
+    let parsed = void 0;
+    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);
+      }
+    }
+    const envelope = parsed ?? {};
+    if (!res.ok || envelope.error) {
+      const error = envelope.error;
+      throw new GoCommerceError(
+        error?.message || envelope.message || `GoCommerce request failed: ${method} ${path} (${res.status}).`,
+        error?.code || "internal_error",
+        res.status,
+        error?.details
+      );
+    }
+    return { data: envelope.data, meta: envelope.meta };
+  }
+  /**
+   * 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.
+   */
+  async get(url) {
+    const res = await this._fetch(url, { headers: { Accept: "application/json" } });
+    return await res.json();
+  }
+  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();
+  }
+  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();
+  }
+  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();
+  }
+  async delete(url) {
+    const res = await this._fetch(url, { method: "DELETE", headers: { Accept: "application/json" } });
+    return await res.json();
+  }
+};
+
+// 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;
+  return {
+    ...store,
+    plugins: { ...store.plugins ?? {}, ...IMPOSSIBLE_FEATURES }
+  };
+};
+var readStaticStoreDetails = readStaticStore;
+
+// 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/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
+  };
+};
+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);
+  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
+    }))
+  };
+};
+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);
+  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.
+    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 }))
+    })),
+    variants: priced.map((variant) => mapVariant(product, variant))
+  };
+};
+var mapCategory = (category) => {
+  if (!category) return null;
+  return {
+    id: category.id,
+    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
+  };
+};
+var mapCollection = (collection) => {
+  if (!collection) return null;
+  const products = collection.products || [];
+  return {
+    id: collection.id,
+    name: collection.title,
+    slug: collection.slug,
+    description: collection.description || 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
+  };
+};
+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;
+  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,
+    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 : []
+    }
+  };
+};
+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;
+  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,
+    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.
+    shippingCharges: 0,
+    paymentMethod: null,
+    shippingMethod: null,
+    subtotal,
+    codCharges: 0,
+    tax: 0,
+    total: subtotal,
+    savingAmount: 0,
+    userAuthToken: null,
+    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
+  };
+};
+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);
+  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
+  };
+};
+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;
+  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)
+  };
+};
+var mapOrder = (order, index) => {
+  if (!order) return null;
+  const shippingAddress = toStorefrontAddress(order.address, order.email, order.phone);
+  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)
+      };
+    })
+  };
+};
+
+// 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) ?? {});
+
+// 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/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);
+  }
+  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;
+    try {
+      const res = await this.api("GET", `/api/products/${id}`);
+      if (res.data) remember([res.data]);
+      return res.data ?? null;
+    } 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);
+    }
+    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 });
+  }
+  async listTrendingProducts({ page = 1, search = "", sort = "-createdAt" } = {}) {
+    return this.list({ page, search, sort });
+  }
+  /** 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.");
+  }
+  async fetchReels() {
+    return { data: [], count: 0 };
+  }
+};
+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();
+    }
+    return super.get(url);
+  }
+  /**
+   * The taxonomy, flattened.
+   *
+   * `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.
+   */
+  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 getMegamenu() {
+    return this.fetchFeaturedCategories({ limit: 50 });
+  }
+};
+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
+    );
+  }
+  /**
+   * 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.
+   */
+  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);
+  }
+  // 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
+    };
+  }
+};
+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 SearchService = class _SearchService extends BaseService {
+  static instance;
+  static getInstance() {
+    if (!_SearchService.instance) _SearchService.instance = new _SearchService();
+    return _SearchService.instance;
+  }
+  emptyResult() {
+    return {
+      data: [],
+      count: 0,
+      totalPages: 0,
+      categoryHierarchy: [],
+      facets: { priceStat: { min: void 0, max: void 0 }, 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;
+      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: {}
+        }
+      };
+    } catch (error) {
+      if (error?.code !== "not_found") console.error("[gocommerce] search failed", error);
+      return this.emptyResult();
+    }
+  }
+  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);
+    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 || ""
+    };
+  }
+  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
+    );
+  }
+};
+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;
+};
+
+// 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 {
+  }
+};
+var forgetCartId = () => {
+  try {
+    window?.localStorage?.removeItem(CART_ID_KEY);
+  } catch {
+  }
+};
+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);
+  }
+  /** 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;
+  }
+  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;
+  }
+  /**
+   * 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.
+   */
+  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;
+    }
+  }
+  /** 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;
+  }
+  async getCartByCartId(cartId) {
+    const id = usableId(cartId) || readStoredCartId();
+    if (!id) return {};
+    return this.present(await this.readCart(id));
+  }
+  async fetchCartData() {
+    const id = readStoredCartId();
+    if (!id) return {};
+    return this.present(await this.readCart(id));
+  }
+  async refereshCart() {
+    return this.fetchCartData();
+  }
+  /**
+   * 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.
+   */
+  async addToCart({
+    variantId,
+    qty,
+    cartId,
+    lineId
+  }) {
+    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;
+      }
+      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 }));
+  }
+  async updateCart({
+    qty,
+    cartId,
+    lineId = null,
+    productId,
+    variantId
+  }) {
+    return this.addToCart({ productId, variantId, qty, cartId, lineId });
+  }
+  async removeCart({ cartId, lineId = null }) {
+    return this.addToCart({ qty: REMOVE_LINE, cartId, lineId });
+  }
+  /**
+   * 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.
+   */
+  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;
+    }
+    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 } : {}
+    });
+    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() {
+    return this.fetchCartData();
+  }
+  /** Shipping is priced by the store at checkout; there are no rates for a shopper to choose. */
+  async updateShippingRate({ cartId }) {
+    return this.getCartByCartId(cartId || "");
+  }
+};
+var cartService = CartService.getInstance();
+
+// 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 };
+  }
+};
+var paymentMethodService = PaymentMethodService.getInstance();
+var CheckoutService = class _CheckoutService extends BaseService {
+  static instance;
+  static getInstance() {
+    if (!_CheckoutService.instance) _CheckoutService.instance = new _CheckoutService();
+    return _CheckoutService.instance;
+  }
+  /**
+   * 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.
+   */
+  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}` }
+      );
+    } 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 ?? {}
+    };
+  }
+  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 });
+  }
+  async checkoutPaypal({ cartId, origin, return_url }) {
+    return this.place("paypal", { cartId, origin, returnUrl: return_url });
+  }
+  async checkoutPhonepe({ cartId, origin }) {
+    return this.place("phonepe", { cartId, origin });
+  }
+  async createAffirmPayOrder({
+    cartId,
+    origin
+  }) {
+    return this.place("affirm", { cartId, origin });
+  }
+  // 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 captureRazorpayPayment({ razorpay_order_id }) {
+    return this.settled(razorpay_order_id);
+  }
+  async capturePhonepePayment({ phonepe_order_id }) {
+    return this.settled(phonepe_order_id);
+  }
+  async captureCashfreePayment({ order_no }) {
+    return this.settled(order_no);
+  }
+  async checkoutStripeCapture({ order_no }) {
+    return this.settled(order_no);
+  }
+  async confirmAffirmOrder({ orderId }) {
+    return this.settled(orderId);
+  }
+  async cancelAffirmOrder({ orderId }) {
+    throw new Error(`Cancelling order ${orderId || ""} is not available on this store.`);
+  }
+  /**
+   * 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.
+   */
+  async getShippingRates(_params) {
+    return { message: "This store does not offer selectable shipping rates", success: true, error: null, data: [] };
+  }
+};
+var checkoutService = CheckoutService.getInstance();
+
+// 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;
+    }
+  }
+  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);
+  }
+  /**
+   * The confirmation view, rebuilt from the cart that became the order.
+   *
+   * 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.
+   */
+  async orderFromCart(cartId, orderNumber) {
+    let cart = null;
+    try {
+      const res = await this.api("GET", `/api/carts/${encodeURIComponent(cartId)}`);
+      cart = res.data ?? null;
+    } catch {
+      return null;
+    }
+    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);
+    }
+    const cart = usable(cartId);
+    if (cart) {
+      const reconstructed = await this.orderFromCart(cart, number);
+      if (reconstructed) return paginated([reconstructed], 1, 1, 1);
+    }
+    return emptyPage();
+  }
+  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)) ?? {};
+  }
+  async fetchOrder(id) {
+    return this.getOrder(id);
+  }
+  async fetchTrackOrder(id) {
+    return this.listOrdersByParent({ orderNo: id, cartId: null });
+  }
+  async paySuccessPageHit(orderId) {
+    return this.getOrder(orderId);
+  }
+  // GoCommerce has no email+OTP lookup: an order is reached by its number and access token.
+  async getOrderByEmailAndOTP(_params) {
+    return emptyPage();
+  }
+  // No server-side order feed exists to reorder from; `list()` is the shopper's own history.
+  async buyAgain() {
+    return emptyPage();
+  }
+  async listPublic() {
+    return emptyPage();
+  }
+  async submitReview(_params) {
+    throw new Error("Product reviews are not available on this store.");
+  }
+  // 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.");
+  }
+  async razorpayCheckout(_params) {
+    throw new Error("Use checkoutService.checkoutRazorpay() on GoCommerce.");
+  }
+  async stripeCheckout(_params) {
+    throw new Error("Use checkoutService.checkoutStripe() on GoCommerce.");
+  }
+  async cashfreeCheckout(_params) {
+    throw new Error("Use checkoutService.checkoutCashfree() on GoCommerce.");
+  }
+  async razorCapture(_params) {
+    throw new Error("Use checkoutService.captureRazorpayPayment() on GoCommerce.");
+  }
+};
+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).");
+    }
+    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 menuService = MenuService.getInstance();
+var StateService = class _StateService extends BaseService {
+  static instance;
+  static getInstance() {
+    if (!_StateService.instance) _StateService.instance = new _StateService();
+    return _StateService.instance;
+  }
+  // No state list ships with the store record, and GoCommerce takes the state as free text.
+  async list() {
+    return listOf([]);
+  }
+};
+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] : []);
+  }
+};
+var currencyService = CurrencyService.getInstance();
+var RegionService = class _RegionService extends BaseService {
+  static instance;
+  static getInstance() {
+    if (!_RegionService.instance) _RegionService.instance = new _RegionService();
+    return _RegionService.instance;
+  }
+  // GoCommerce has no regions; one store, one currency, one price list.
+  async getRegionByRegionId(_id) {
+    return {};
+  }
+};
+var regionService = RegionService.getInstance();
+var PluginService = class _PluginService extends BaseService {
+  static instance;
+  static getInstance() {
+    if (!_PluginService.instance) _PluginService.instance = new _PluginService();
+    return _PluginService.instance;
+  }
+  async list(_params = {}) {
+    const store = await readStaticStore();
+    return listOf(store?.plugins ?? []);
+  }
+};
+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] : [];
+  }
+  // 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 updateSettings(_id, _setting) {
+    throw new Error("Store settings are configured in kitcommerce.config.ts, not from the storefront.");
+  }
+};
+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 fetchInit() {
+    const store = await readStaticStore();
+    return store ? [store] : [];
+  }
+};
+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 homeService = HomeService.getInstance();
+var PopularSearchService = class _PopularSearchService extends BaseService {
+  static instance;
+  static getInstance() {
+    if (!_PopularSearchService.instance) _PopularSearchService.instance = new _PopularSearchService();
+    return _PopularSearchService.instance;
+  }
+  // GoCommerce records no search analytics, so there are no popular searches to report.
+  async listPopularSearch(_params = {}) {
+    return listOf([]);
+  }
+};
+var popularSearchService = PopularSearchService.getInstance();
+var PopularityService = class _PopularityService extends BaseService {
+  static instance;
+  static getInstance() {
+    if (!_PopularityService.instance) _PopularityService.instance = new _PopularityService();
+    return _PopularityService.instance;
+  }
+  /** Nothing to record against: a view counter is not part of this API. Accepted and dropped. */
+  async updatePopularity(_params = {}) {
+    return { success: true };
+  }
+};
+var popularityService = PopularityService.getInstance();
+
+// 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}.`);
+  }
+  async signup(_params) {
+    throw new Error(`${NO_ACCOUNTS}.`);
+  }
+  async joinAsVendor(_params) {
+    throw unavailable("Vendor signup");
+  }
+  async forgotPassword(_params) {
+    throw new Error(`${NO_ACCOUNTS}.`);
+  }
+  async resetPassword(_params) {
+    throw new Error(`${NO_ACCOUNTS}.`);
+  }
+  async changePassword(_params) {
+    throw new Error(`${NO_ACCOUNTS}.`);
+  }
+  async getOtp(_params) {
+    throw new Error(`${NO_ACCOUNTS}.`);
+  }
+  async verifyOtp(_params) {
+    throw new Error(`${NO_ACCOUNTS}.`);
+  }
+  async updateProfile(_params) {
+    throw new Error(`${NO_ACCOUNTS}.`);
+  }
+  async checkEmail(_email) {
+    return { exists: false };
+  }
+  async deleteUser(_id) {
+    throw new Error(`${NO_ACCOUNTS}.`);
+  }
+  /**
+   * 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.
+   */
+  async logout() {
+    clearPhantomSession();
+    return { success: true };
+  }
+};
+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 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 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 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: [] };
+  }
+  async toggleWishlist(_params) {
+    throw unavailable("Wishlists");
+  }
+};
+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();
+  }
+  async getCoupon(_id) {
+    throw unavailable("Discount codes");
+  }
+  async createCoupon(_coupon) {
+    throw unavailable("Discount codes");
+  }
+  async patchCoupon(_id, _coupon) {
+    throw unavailable("Discount codes");
+  }
+  async deleteCoupon(_id) {
+    throw unavailable("Discount codes");
+  }
+};
+var couponService = CouponService.getInstance();
+var DealService = class _DealService extends BaseService {
+  static getInstance = singleton(_DealService);
+  async fetchDeals() {
+    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) {
+    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();
+  }
+  async listLatestPages(_params = {}) {
+    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 pageService = PageService.getInstance();
+var BlogService = class _BlogService extends BaseService {
+  static getInstance = singleton(_BlogService);
+  async list(_params = {}) {
+    return emptyPage();
+  }
+  async getOne(id) {
+    throw new Error(`The post "${id}" does not exist on this store.`);
+  }
+};
+var blogService = BlogService.getInstance();
+var BannerService = class _BannerService extends BaseService {
+  static getInstance = singleton(_BannerService);
+  async list() {
+    return emptyPage();
+  }
+  async fetchBannersGroup() {
+    return emptyPage();
+  }
+};
+var bannerService = BannerService.getInstance();
+var GalleryService = class _GalleryService extends BaseService {
+  static getInstance = singleton(_GalleryService);
+  async fetchGallery() {
+    return [];
+  }
+};
+var galleryService = GalleryService.getInstance();
+var ReelsService = class _ReelsService extends BaseService {
+  static getInstance = singleton(_ReelsService);
+  async list() {
+    return emptyPage();
+  }
+};
+var reelsService = ReelsService.getInstance();
+var FaqService = class _FaqService extends BaseService {
+  static getInstance = singleton(_FaqService);
+  async listFaqs(_params = {}) {
+    return emptyPage();
+  }
+};
+var faqService = FaqService.getInstance();
+var FeedbackService = class _FeedbackService extends BaseService {
+  static getInstance = singleton(_FeedbackService);
+  async listFeedbacks(_params = {}) {
+    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 [];
+  }
+  async chats() {
+    return [];
+  }
+  async save(_message) {
+    throw unavailable("Messaging");
+  }
+};
+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 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 [];
+  }
+  async save(_data) {
+    throw unavailable("Vendor accounts");
+  }
+  async update(_data) {
+    throw unavailable("Vendor accounts");
+  }
+};
+var vendorService = VendorService.getInstance();
+var VarniCustomDesignService = class _VarniCustomDesignService extends BaseService {
+  static getInstance = singleton(_VarniCustomDesignService);
+  async submitForm(_formDetails) {
+    throw unavailable("Custom design requests");
+  }
+};
+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");
+  }
+  async sendMessageToCustomOrderChat(_chatId, _vendor, _message) {
+    throw unavailable("Custom product chat");
+  }
+};
+var varniCustomProductService = VarniCustomProductService.getInstance();
+
+exports.API_PROXY_PREFIX = API_PROXY_PREFIX;
+exports.AddressService = AddressService;
+exports.AuthService = AuthService;
+exports.AutocompleteService = AutocompleteService;
+exports.BannerService = BannerService;
+exports.BaseService = BaseService;
+exports.BlogService = BlogService;
+exports.CartService = CartService;
+exports.CategoryService = CategoryService;
+exports.ChatService = ChatService;
+exports.CheckoutService = CheckoutService;
+exports.CollectionService = CollectionService;
+exports.ContactService = ContactService;
+exports.CouponService = CouponService;
+exports.CurrencyService = CurrencyService;
+exports.DealService = DealService;
+exports.EnquiryService = EnquiryService;
+exports.FaqService = FaqService;
+exports.FeedbackService = FeedbackService;
+exports.GalleryService = GalleryService;
+exports.GoCommerceError = GoCommerceError;
+exports.HomeService = HomeService;
+exports.InitService = InitService;
+exports.MAX_LIMIT = MAX_LIMIT;
+exports.MeilisearchService = MeilisearchService;
+exports.MenuService = MenuService;
+exports.OrderService = OrderService;
+exports.PAGE_SIZE = PAGE_SIZE;
+exports.PageService = PageService;
+exports.PaymentMethodService = PaymentMethodService;
+exports.PluginService = PluginService;
+exports.PluginsService = PluginService;
+exports.PopularSearchService = PopularSearchService;
+exports.PopularityService = PopularityService;
+exports.ProductService = ProductService;
+exports.ProfileService = ProfileService;
+exports.ReelsService = ReelsService;
+exports.RegionService = RegionService;
+exports.ReviewService = ReviewService;
+exports.SearchService = SearchService;
+exports.SettingService = SettingService;
+exports.SettingsService = SettingService;
+exports.StateService = StateService;
+exports.StoreService = StoreService;
+exports.UploadService = UploadService;
+exports.UserService = UserService;
+exports.VarniCustomDesignService = VarniCustomDesignService;
+exports.VarniCustomProductService = VarniCustomProductService;
+exports.VendorService = VendorService;
+exports.WishlistService = WishlistService;
+exports.absoluteMedia = absoluteMedia;
+exports.addressService = addressService;
+exports.authService = authService;
+exports.autocompleteService = autocompleteService;
+exports.bannerService = bannerService;
+exports.blogService = blogService;
+exports.cartService = cartService;
+exports.categoryService = categoryService;
+exports.chatService = chatService;
+exports.checkoutService = checkoutService;
+exports.clearCheckoutDetails = clearCheckoutDetails;
+exports.clearPhantomSession = clearPhantomSession;
+exports.collectionService = collectionService;
+exports.contactService = contactService;
+exports.couponService = couponService;
+exports.currencyFractionDigits = currencyFractionDigits;
+exports.currencyService = currencyService;
+exports.dealService = dealService;
+exports.emptyPage = emptyPage;
+exports.enquiryService = enquiryService;
+exports.faqService = faqService;
+exports.feedbackService = feedbackService;
+exports.findAddress = findAddress;
+exports.flattenMetadata = flattenMetadata;
+exports.fromMoney = fromMoney;
+exports.galleryService = galleryService;
+exports.hasPhantomSession = hasPhantomSession;
+exports.hasStaticStore = hasStaticStore;
+exports.homeService = homeService;
+exports.initService = initService;
+exports.listAddresses = listAddresses;
+exports.mapCart = mapCart;
+exports.mapCategory = mapCategory;
+exports.mapCollection = mapCollection;
+exports.mapOrder = mapOrder;
+exports.mapProduct = mapProduct;
+exports.meilisearchService = meilisearchService;
+exports.menuService = menuService;
+exports.orderService = orderService;
+exports.pageService = pageService;
+exports.paginated = paginated;
+exports.patchAddress = patchAddress;
+exports.paymentMethodService = paymentMethodService;
+exports.pluginService = pluginService;
+exports.pluginsService = pluginsService;
+exports.popularSearchService = popularSearchService;
+exports.popularityService = popularityService;
+exports.productImages = productImages;
+exports.productService = productService;
+exports.profileService = profileService;
+exports.putAddress = putAddress;
+exports.readCheckoutDetails = readCheckoutDetails;
+exports.readOrderNumbers = readOrderNumbers;
+exports.readOrderToken = readOrderToken;
+exports.readStaticStore = readStaticStore;
+exports.readStaticStoreDetails = readStaticStoreDetails;
+exports.reelsService = reelsService;
+exports.regionService = regionService;
+exports.rememberOrderToken = rememberOrderToken;
+exports.removeAddress = removeAddress;
+exports.resolveProductIndex = resolveProductIndex;
+exports.reviewService = reviewService;
+exports.searchService = searchService;
+exports.setStaticStore = setStaticStore;
+exports.settingService = settingService;
+exports.settingsService = settingsService;
+exports.stateService = stateService;
+exports.storeService = storeService;
+exports.toGoCommerceAddress = toGoCommerceAddress;
+exports.toStorefrontAddress = toStorefrontAddress;
+exports.uploadService = uploadService;
+exports.userService = userService;
+exports.varniCustomDesignService = varniCustomDesignService;
+exports.varniCustomProductService = varniCustomProductService;
+exports.vendorService = vendorService;
+exports.wishlistService = wishlistService;
+exports.writeCheckoutDetails = writeCheckoutDetails;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map