@misiki/gocommerce-connector 0.2.0 → 0.3.0

package/dist/index.cjs

@@ -190,6 +190,16 @@ function toVariant(v, p, optionless) {
     metadata: v.metadata ?? null
   };
 }
+function attributesOf(p) {
+  const answers = p.metadata?.category;
+  if (!answers || typeof answers !== "object" || Array.isArray(answers)) return [];
+  return Object.entries(answers).flatMap(([handle, raw]) => {
+    const values = (Array.isArray(raw) ? raw : [raw]).map((v) => String(v ?? "").trim()).filter(Boolean);
+    if (!values.length) return [];
+    const name = handle.replace(/[-_]+/g, " ").replace(/^./, (c) => c.toUpperCase());
+    return [{ name, value: values.join(", "), handle }];
+  });
+}
 function toProduct(p, extra = {}) {
   const live = liveVariants(p);
   const lead = live[0] ?? arr(p.variants)[0];
@@ -255,7 +265,7 @@ function toProduct(p, extra = {}) {
     rating: null,
     ratingCount: 0,
     reviewCount: 0,
-    attributes: [],
+    attributes: attributesOf(p),
     metadata: p.metadata ?? null,
     createdAt: p.created_at,
     updatedAt: p.updated_at
@@ -748,7 +758,7 @@ function storedCartId() {
   if (!v || v === "undefined" || v === "null") return null;
   return v;
 }
-var rememberCartId = (id) => writeLocal("cart_id", id);
+var rememberCartId = (id2) => writeLocal("cart_id", id2);
 var extrasKey = (cartId) => `gocommerce_cart_${cartId}`;
 var cartExtras = (cartId) => readJSON(extrasKey(cartId)) ?? {};
 function saveCartExtras(cartId, patch) {
@@ -816,7 +826,8 @@ var BaseService = class _BaseService {
    * as what it is rather than as a JSON parse error three frames away.
    */
   async engine(path, req = {}) {
-    const url = this.engineURL(path, req.query);
+    const lang = (req.method ?? "GET") === "GET" ? this.creds.language : void 0;
+    const url = this.engineURL(path, lang ? { lang, ...req.query } : req.query);
     const headers = { Accept: "application/json", ...req.headers };
     if (req.body !== void 0) headers["Content-Type"] = "application/json";
     if (this.creds.store) headers["X-Store"] = this.creds.store;
@@ -1099,8 +1110,11 @@ var CatalogService = class extends BaseService {
         sorted
       };
     }
+    const attr = Object.entries(q.attributes ?? {}).flatMap(
+      ([handle, values]) => values.filter(Boolean).map((v) => `${handle}:${v}`)
+    );
     const env = await this.engine("/api/products", {
-      query: { q: search, page, limit, channel: this.creds.channel }
+      query: { q: search, page, limit, channel: this.creds.channel, attr }
     });
     return { ...toPage(env, (p) => toProduct(p)), categoryHierarchy: hierarchy, sorted };
   }
@@ -1235,6 +1249,16 @@ var num = (v) => {
   const n = Number(v);
   return Number.isFinite(n) ? n : void 0;
 };
+function attributesFrom(p) {
+  const out = {};
+  for (const [key, value] of p) {
+    if (!key.startsWith("attributes.")) continue;
+    const handle = key.slice("attributes.".length);
+    const values = value.split(",").map((v) => decodeURIComponent(v).trim()).filter(Boolean);
+    if (handle && values.length) out[handle] = [...out[handle] ?? [], ...values];
+  }
+  return Object.keys(out).length ? out : void 0;
+}
 var SearchService = class extends CatalogService {
   emptyResult() {
     return {
@@ -1256,7 +1280,8 @@ var SearchService = class extends CatalogService {
         sort: p.get("sort") ?? void 0,
         category: slug || p.get("categories")?.split(",")[0] || void 0,
         priceFrom: num(p.get("priceFrom")) ?? num(from ?? null),
-        priceTo: num(p.get("priceTo")) ?? num(to ?? null)
+        priceTo: num(p.get("priceTo")) ?? num(to ?? null),
+        attributes: attributesFrom(p)
       });
       return {
         data: res.data,
@@ -1388,10 +1413,10 @@ var REMOVE = -9999999;
 var CartService = class extends BaseService {
   facts = new StoreFacts(this._fetch);
   async getCartByCartId(cartId) {
-    const id = clean(cartId);
-    if (!id) return emptyCart(await this.currency());
+    const id2 = clean(cartId);
+    if (!id2) return emptyCart(await this.currency());
     try {
-      return await this.present(await this.data(`/api/carts/${encodeURIComponent(id)}`));
+      return await this.present(await this.data(`/api/carts/${encodeURIComponent(id2)}`));
     } catch (err) {
       if (err instanceof GoCommerceError && err.status === 404) return emptyCart(await this.currency());
       throw err;
@@ -1406,9 +1431,9 @@ var CartService = class extends BaseService {
    * to clear the bag on the success page.
    */
   async refereshCart() {
-    const id = storedCartId();
-    const cart = await this.getCartByCartId(id);
-    if (id && cart.status === "converted") forgetCartExtras(id);
+    const id2 = storedCartId();
+    const cart = await this.getCartByCartId(id2);
+    if (id2 && cart.status === "converted") forgetCartExtras(id2);
     return cart;
   }
   /**
@@ -1421,21 +1446,21 @@ var CartService = class extends BaseService {
     qty = 1,
     variantId
   }) {
-    let id = clean(cartId) ?? storedCartId();
-    if (lineId && id) {
-      const cart = await this.data(`/api/carts/${encodeURIComponent(id)}`);
+    let id2 = clean(cartId) ?? storedCartId();
+    if (lineId && id2) {
+      const cart = await this.data(`/api/carts/${encodeURIComponent(id2)}`);
       const line = (cart.line_items ?? []).find((l) => String(l.id) === String(lineId));
       if (line) {
         const next = qty === REMOVE ? 0 : line.quantity + Number(qty);
-        return this.setQuantity(id, line.id, next);
+        return this.setQuantity(id2, line.id, next);
       }
     }
-    if (qty === REMOVE || Number(qty) <= 0) return this.getCartByCartId(id);
+    if (qty === REMOVE || Number(qty) <= 0) return this.getCartByCartId(id2);
     if (!variantId) throw new GoCommerceError("Please choose an option before adding this to your bag.", 400);
-    if (!id) id = await this.open();
+    if (!id2) id2 = await this.open();
     try {
       return await this.present(
-        await this.data(`/api/carts/${encodeURIComponent(id)}/line-items`, {
+        await this.data(`/api/carts/${encodeURIComponent(id2)}/line-items`, {
           method: "POST",
           body: { variant_id: Number(variantId), quantity: Number(qty) }
         })
@@ -1459,15 +1484,15 @@ var CartService = class extends BaseService {
     lineId,
     qty
   }) {
-    const id = clean(cartId) ?? storedCartId();
-    if (!id) return emptyCart(await this.currency());
-    return this.setQuantity(id, lineId, Number(qty));
+    const id2 = clean(cartId) ?? storedCartId();
+    if (!id2) return emptyCart(await this.currency());
+    return this.setQuantity(id2, lineId, Number(qty));
   }
   async removeCart({ cartId, lineId }) {
-    const id = clean(cartId) ?? storedCartId();
-    if (!id) return emptyCart(await this.currency());
+    const id2 = clean(cartId) ?? storedCartId();
+    if (!id2) return emptyCart(await this.currency());
     return this.present(
-      await this.data(`/api/carts/${encodeURIComponent(id)}/line-items/${encodeURIComponent(String(lineId))}`, {
+      await this.data(`/api/carts/${encodeURIComponent(id2)}/line-items/${encodeURIComponent(String(lineId))}`, {
         method: "DELETE"
       })
     );
@@ -1478,8 +1503,8 @@ var CartService = class extends BaseService {
    * and the rest is kept for the checkout request.
    */
   async updateCart2(args) {
-    const id = clean(args.cartId) ?? storedCartId();
-    if (!id) return emptyCart(await this.currency());
+    const id2 = clean(args.cartId) ?? storedCartId();
+    if (!id2) return emptyCart(await this.currency());
     const patch = {};
     if (args.phone !== void 0) patch.phone = args.phone || void 0;
     if (args.shippingAddress !== void 0) {
@@ -1489,20 +1514,20 @@ var CartService = class extends BaseService {
     if (args.billingAddress !== void 0 || args.isBillingAddressSameAsShipping) {
       patch.billingAddress = args.isBillingAddressSameAsShipping ? null : args.billingAddress ?? null;
     }
-    const before = cartExtras(id);
+    const before = cartExtras(id2);
     const country = (a) => String(a?.countryCode || a?.country || "").toUpperCase();
     if (args.shippingAddress !== void 0 && country(args.shippingAddress) !== country(before.shippingAddress)) {
       patch.shippingRateId = null;
       patch.shippingRate = null;
     }
-    saveCartExtras(id, patch);
+    saveCartExtras(id2, patch);
     const email = args.email ?? (args.shippingAddress?.email ? String(args.shippingAddress.email) : void 0);
     if (email !== void 0) {
       return this.present(
-        await this.data(`/api/carts/${encodeURIComponent(id)}/email`, { method: "PUT", body: { email } })
+        await this.data(`/api/carts/${encodeURIComponent(id2)}/email`, { method: "PUT", body: { email } })
       );
     }
-    return this.getCartByCartId(id);
+    return this.getCartByCartId(id2);
   }
   /**
    * A discount code. The engine prices it against the basket now and decides
@@ -1510,34 +1535,34 @@ var CartService = class extends BaseService {
    * because the cart itself does not carry the code.
    */
   async applyCoupon({ cartId, couponCode }) {
-    const id = clean(cartId) ?? storedCartId();
-    if (!id) throw new GoCommerceError("Add something to your bag before applying a code.", 400);
-    const cart = await this.data(`/api/carts/${encodeURIComponent(id)}`);
-    const discount = await this.data(`/api/carts/${encodeURIComponent(id)}/discount`, {
+    const id2 = clean(cartId) ?? storedCartId();
+    if (!id2) throw new GoCommerceError("Add something to your bag before applying a code.", 400);
+    const cart = await this.data(`/api/carts/${encodeURIComponent(id2)}`);
+    const discount = await this.data(`/api/carts/${encodeURIComponent(id2)}/discount`, {
       method: "PUT",
       body: { code: String(couponCode ?? "").trim(), ...cart.email ? { email: cart.email } : {} }
     });
-    saveCartExtras(id, { discount: { ...discount, code: discount.code || String(couponCode).trim() } });
+    saveCartExtras(id2, { discount: { ...discount, code: discount.code || String(couponCode).trim() } });
     return this.present(cart);
   }
   async removeCoupon(cartId) {
-    const id = clean(cartId) ?? storedCartId();
-    if (!id) return emptyCart(await this.currency());
-    await this.engine(`/api/carts/${encodeURIComponent(id)}/discount`, { method: "DELETE" });
-    saveCartExtras(id, { discount: null });
-    return this.getCartByCartId(id);
+    const id2 = clean(cartId) ?? storedCartId();
+    if (!id2) return emptyCart(await this.currency());
+    await this.engine(`/api/carts/${encodeURIComponent(id2)}/discount`, { method: "DELETE" });
+    saveCartExtras(id2, { discount: null });
+    return this.getCartByCartId(id2);
   }
   /** The delivery option the shopper picked, priced from the engine's own quote. */
   async updateShippingRate({ cartId, shippingRateId }) {
-    const id = clean(cartId) ?? storedCartId();
-    if (!id) return emptyCart(await this.currency());
-    const ship = cartExtras(id).shippingAddress;
+    const id2 = clean(cartId) ?? storedCartId();
+    if (!id2) return emptyCart(await this.currency());
+    const ship = cartExtras(id2).shippingAddress;
     const country = String(ship?.countryCode || ship?.country || "").toUpperCase();
     if (!country) throw new GoCommerceError("Add a delivery address first.", 400);
-    const quote2 = await this.data("/api/checkout/rates", { query: { cart: id, country, state: ship?.state ? String(ship.state) : void 0 } });
+    const quote2 = await this.data("/api/checkout/rates", { query: { cart: id2, country, state: ship?.state ? String(ship.state) : void 0 } });
     const rate = (quote2.rates ?? []).find((r) => String(r.rate_id) === String(shippingRateId));
     if (!rate) throw new GoCommerceError("That delivery option is not available for this address any more.", 409);
-    saveCartExtras(id, {
+    saveCartExtras(id2, {
       shippingRateId: String(rate.rate_id),
       shippingRate: {
         id: String(rate.rate_id),
@@ -1546,7 +1571,7 @@ var CartService = class extends BaseService {
         currency: rate.price.currency
       }
     });
-    return this.getCartByCartId(id);
+    return this.getCartByCartId(id2);
   }
   /** The payment method is chosen at checkout, by which checkout route is called. */
   async updateCartPaymentMethod({ cartId }) {
@@ -1592,25 +1617,25 @@ var CartService = class extends BaseService {
       return { slug: p.slug, thumbnail: v?.image?.url ?? p.image_url ?? null };
     });
   }
-  productFor(id) {
+  productFor(id2) {
     return remember(
-      `${this.engineBase()}|product|${id}`,
-      () => this.data(`/api/products/${id}`).catch(() => null)
+      `${this.engineBase()}|product|${id2}`,
+      () => this.data(`/api/products/${id2}`).catch(() => null)
     );
   }
 };
-var clean = (id) => id && id !== "undefined" && id !== "null" ? id : null;
+var clean = (id2) => id2 && id2 !== "undefined" && id2 !== "null" ? id2 : null;
 var cartService = new CartService();
 
 // src/services/checkout-service.ts
 var CheckoutService = class extends BaseService {
   /** Delivery options for the address on the cart: `{ data: [{ id, name, base_rate }] }`. */
   async getShippingRates({ cartId } = {}) {
-    const id = cartId || storedCartId();
-    const ship = id ? cartExtras(id).shippingAddress : null;
+    const id2 = cartId || storedCartId();
+    const ship = id2 ? cartExtras(id2).shippingAddress : null;
     const country = String(ship?.countryCode || ship?.country || "").toUpperCase();
-    if (!id || !country) return { data: [] };
-    const quote2 = await this.data("/api/checkout/rates", { query: { cart: id, country, state: ship?.state ? String(ship.state) : void 0 } });
+    if (!id2 || !country) return { data: [] };
+    const quote2 = await this.data("/api/checkout/rates", { query: { cart: id2, country, state: ship?.state ? String(ship.state) : void 0 } });
     return {
       data: (quote2.rates ?? []).map((r) => ({
         id: String(r.rate_id),
@@ -1664,10 +1689,11 @@ var CheckoutService = class extends BaseService {
     if (!order) throw new GoCommerceError("That payment does not belong to an order placed from this browser.", 404);
     return { order_no: order.number, status: "processing" };
   }
-  // The family's other gateways. GoCommerce's Stripe is a Payment Element
-  // (a client secret, not a hosted page), and PayPal, Cashfree, PhonePe and
-  // Affirm are not engine gateways at all; paymentMethodService never lists
-  // them, so these are reached only by a storefront that hard-codes one.
+  // The family's other gateway flows. GoCommerce's Stripe is a Payment
+  // Element (a client secret, not a hosted page) — `checkout('stripe')` returns
+  // that secret for a storefront that mounts the element. Cashfree, PhonePe and
+  // Affirm are not engine gateways at all. paymentMethodService never offers
+  // these codes, so they are reached only by a storefront that hard-codes one.
   async checkoutStripe() {
     throw unsupported(
       "checkoutStripe",
@@ -1677,11 +1703,34 @@ var CheckoutService = class extends BaseService {
   async checkoutStripeCapture() {
     throw unsupported("checkoutStripeCapture", "Stripe confirms payments to the engine by webhook");
   }
-  async checkoutPaypal() {
-    throw unsupported("checkoutPaypal", "the engine has no PayPal gateway");
+  /**
+   * The storefront's generic redirect flow, which it reaches through the code
+   * `PAYPAL`. The engine has no PayPal gateway; paymentMethodService puts the
+   * store's first hosted-page gateway — Adyen, Paddle, Lemon Squeezy, Creem,
+   * Hyperswitch or RevenueCat — under that code, with its own name and a
+   * neutral icon, because this is the one storefront flow that sends a shopper
+   * to a URL and back. The shopper returns to the success page; the gateway's
+   * webhook tells the engine the order is paid.
+   */
+  async checkoutPaypal({ cartId, origin } = {}) {
+    const gateway = await this.redirectGateway();
+    if (!gateway) throw unsupported("checkoutPaypal", "this store has no hosted-page payment gateway switched on");
+    const id2 = cartId || storedCartId() || "";
+    const back = origin ? `${origin.replace(/\/+$/, "")}/checkout/success?cart_id=${encodeURIComponent(id2)}` : void 0;
+    const result = await this.place(gateway, id2, back ? { return_url: back } : {});
+    const url = result.payment.client_data?.url;
+    if (!url) throw new GoCommerceError("The payment page did not open. Please try again.", 502);
+    return { redirect_url: url, order_no: result.order.number };
   }
-  async capturePaypalPayment() {
-    throw unsupported("capturePaypalPayment", "the engine has no PayPal gateway");
+  /**
+   * Nothing to capture: a hosted-page gateway confirms the payment to the
+   * engine by webhook. Answering, rather than throwing, sends the storefront's
+   * process page on to the success page instead of the failure page.
+   */
+  async capturePaypalPayment({
+    order_no
+  } = {}) {
+    return { order_no: order_no ?? null, status: "processing" };
   }
   async checkoutCashfree() {
     throw unsupported("checkoutCashfree", "the engine has no Cashfree gateway");
@@ -1704,6 +1753,57 @@ var CheckoutService = class extends BaseService {
   async checkoutPOS() {
     throw unsupported("checkoutPOS", "point-of-sale orders are placed from the admin panel");
   }
+  /**
+   * Any payment method the engine has switched on, by its engine code —
+   * `cod`, `stripe`, `razorpay`, `adyen`, `paddle`, `helcim`… For a storefront
+   * that drives the payment itself: the answer says what to do next.
+   *
+   * - `kind: 'none'` — nothing to pay now (cash on delivery).
+   * - `kind: 'client_action'` — mount the gateway's own widget with
+   *   `clientData`: Stripe's Payment Element takes `clientSecret`, Razorpay's
+   *   modal `razorpay_order_id` and `key_id`, Helcim's `checkout_token`.
+   * - `kind: 'redirect'` — send the shopper to `redirectUrl`; `returnUrl` is
+   *   where the gateway brings them back.
+   *
+   * Either way the gateway's webhook tells the engine when the money arrives;
+   * read `orderService.getOrder(orderNo).paymentStatus` to see it.
+   */
+  async checkout(code, {
+    cartId,
+    returnUrl,
+    paymentData,
+    metadata
+  } = {}) {
+    const result = await this.place(String(code).toLowerCase(), cartId, {
+      ...returnUrl ? { return_url: returnUrl } : {},
+      ...paymentData ? { payment_data: paymentData } : {},
+      ...metadata ? { metadata } : {}
+    });
+    const data = result.payment.client_data ?? {};
+    return {
+      orderNo: result.order.number,
+      order: toOrder(result.order),
+      payment: {
+        kind: result.payment.kind,
+        provider: result.payment.provider,
+        reference: result.payment.reference ?? null,
+        clientSecret: data.client_secret ?? null,
+        redirectUrl: data.url ?? null,
+        clientData: data
+      }
+    };
+  }
+  /** Every payment method the engine has switched on, by engine code and name — drivable here or not. */
+  async listMethods() {
+    const options = await this.data(
+      "/api/checkout"
+    );
+    return { methods: options.methods ?? [], currency: options.currency };
+  }
+  async redirectGateway() {
+    const { methods } = await this.listMethods();
+    return methods.find((m) => REDIRECT_GATEWAYS.has(m.code))?.code;
+  }
   /**
    * One checkout attempt.
    *
@@ -1714,27 +1814,28 @@ var CheckoutService = class extends BaseService {
    * request — a different address, a different method — gets a new key, since
    * the engine refuses a key replayed with a different body.
    */
-  async place(code, cartId) {
-    const id = cartId || storedCartId();
-    if (!id) throw new GoCommerceError("Your bag is empty.", 400);
-    const extras = cartExtras(id);
+  async place(code, cartId, extra = {}) {
+    const id2 = cartId || storedCartId();
+    if (!id2) throw new GoCommerceError("Your bag is empty.", 400);
+    const extras = cartExtras(id2);
     const ship = extras.shippingAddress;
     if (!ship) throw new GoCommerceError("Add a delivery address first.", 400);
-    const cart = await this.data(`/api/carts/${encodeURIComponent(id)}`);
+    const cart = await this.data(`/api/carts/${encodeURIComponent(id2)}`);
     const email = cart.email || (ship.email ? String(ship.email) : "");
     if (!email) throw new GoCommerceError("Add an email address so we can send your receipt.", 400);
     const address = toEngineAddress(ship);
     const body = {
-      cart_id: id,
+      cart_id: id2,
       email,
       ...extras.phone || address.phone ? { phone: String(extras.phone || address.phone) } : {},
       ...address.name ? { name: address.name } : {},
       address,
-      ...extras.shippingRateId ? { shipping_rate_id: Number(extras.shippingRateId) } : {}
+      ...extras.shippingRateId ? { shipping_rate_id: Number(extras.shippingRateId) } : {},
+      ...extra
     };
     const serialised = JSON.stringify(body);
     const key = extras.attempt?.body === `${code}:${serialised}` ? extras.attempt.key : newKey();
-    saveCartExtras(id, { attempt: { key, body: `${code}:${serialised}` } });
+    saveCartExtras(id2, { attempt: { key, body: `${code}:${serialised}` } });
     const result = await this.data(`/api/checkout/${encodeURIComponent(code)}`, {
       method: "POST",
       body,
@@ -1744,7 +1845,7 @@ var CheckoutService = class extends BaseService {
       rememberOrder({
         number: result.order.number,
         token: result.order.access_token,
-        cartId: id,
+        cartId: id2,
         reference: result.payment.client_data?.razorpay_order_id ?? result.payment.reference
       });
       if (sessionToken()) {
@@ -1755,10 +1856,11 @@ var CheckoutService = class extends BaseService {
         }).catch(() => void 0);
       }
     }
-    saveCartExtras(id, { attempt: null });
+    saveCartExtras(id2, { attempt: null });
     return result;
   }
 };
+var REDIRECT_GATEWAYS = /* @__PURE__ */ new Set(["adyen", "paddle", "lemonsqueezy", "creem", "hyperswitch", "revenuecat"]);
 var unsupported = (method, why) => new NotSupportedError("CheckoutService", method, why);
 function newKey() {
   const c = globalThis.crypto;
@@ -1778,23 +1880,25 @@ var PaymentMethodService = class extends BaseService {
   async list(_args = {}) {
     const options = await this.facts.checkoutOptions();
     const methods = options.methods ?? [];
+    const redirect = methods.find((m) => REDIRECT_GATEWAYS.has(m.code))?.code;
+    const drive = (code) => DRIVABLE[code] ?? (code === redirect ? { code: "PAYPAL", img: "/payment/card.svg" } : void 0);
     const data = methods.filter((m) => {
-      if (DRIVABLE[m.code]) return true;
+      if (drive(m.code)) return true;
       if (!reported2.has(m.code)) {
         reported2.add(m.code);
         console.warn(
-          `[gocommerce] payment method "${m.code}" is switched on but this storefront cannot drive its flow, so it is not offered.`
+          `[gocommerce] payment method "${m.code}" is switched on but this storefront cannot drive its flow, so it is not offered here; checkoutService.checkout('${m.code}') still reaches it.`
         );
       }
       return false;
     }).map((m, i) => ({
       id: m.code,
-      code: DRIVABLE[m.code].code,
+      code: drive(m.code).code,
       engineCode: m.code,
       name: m.name,
       title: m.name,
       description: "",
-      img: DRIVABLE[m.code].img ?? null,
+      img: drive(m.code).img ?? null,
       rank: i,
       active: true,
       isActive: true
@@ -1965,6 +2069,42 @@ var UserService = class extends BaseService {
     startSession(auth);
     return toUser(auth.record);
   }
+  /**
+   * Mails the signed-in shopper a link to confirm their address. The engine
+   * sends none at signup, and a confirmed address is what customer-group
+   * prices are keyed on. 409 once confirmed; 429 within a minute of the last.
+   */
+  async requestEmailVerification() {
+    return this.account("/x/identity/me/email-verification", { method: "POST", auth: true });
+  }
+  /** Extends the session another thirty days. The token stays the same. */
+  async refreshSession() {
+    return startSession(await this.account("/x/identity/refresh", { method: "POST", auth: true }));
+  }
+  /**
+   * Files a guest order under the signed-in account, so it appears in their
+   * order history. The order's access token is the proof of ownership: pass
+   * it, or leave it out for an order placed from this browser, whose token was
+   * kept at checkout.
+   *
+   * Never done automatically at sign-in. On a shared computer that would file
+   * one person's orders — address and all — under whoever signed in next.
+   */
+  async claimOrder({ number, token }) {
+    const proof = token ?? placedOrder(number)?.token;
+    if (!proof) {
+      throw new GoCommerceError(
+        "This order was not placed from this browser; enter the code from its confirmation.",
+        400
+      );
+    }
+    const order = await this.account("/x/identity/me/orders", {
+      method: "POST",
+      auth: true,
+      body: { number: String(number), token: proof }
+    });
+    return toOrder(order);
+  }
   async deleteUser() {
     throw new NotSupportedError("UserService", "deleteUser", "an account is closed by the store, on request");
   }
@@ -2062,16 +2202,16 @@ var AddressService = class extends BaseService {
       page: env.meta?.page ?? page
     };
   }
-  async fetchAddress(id) {
+  async fetchAddress(id2) {
     return fromIdentityAddress(
-      await this.data(`/x/identity/me/addresses/${enc(id)}`, { auth: true }),
+      await this.data(`/x/identity/me/addresses/${enc(id2)}`, { auth: true }),
       currentMe()?.email
     );
   }
   /** New when it has no id (or the form's `'new'`), an edit when it has one — the storefront saves both here. */
   async saveAddress(address) {
-    const id = address?.id && address.id !== "new" ? String(address.id) : null;
-    if (id) return this.editAddress(id, address);
+    const id2 = address?.id && address.id !== "new" ? String(address.id) : null;
+    if (id2) return this.editAddress(id2, address);
     const a = await this.data("/x/identity/me/addresses", {
       method: "POST",
       auth: true,
@@ -2079,20 +2219,20 @@ var AddressService = class extends BaseService {
     });
     return fromIdentityAddress(a, currentMe()?.email);
   }
-  async editAddress(id, address) {
-    const a = await this.data(`/x/identity/me/addresses/${enc(id)}`, {
+  async editAddress(id2, address) {
+    const a = await this.data(`/x/identity/me/addresses/${enc(id2)}`, {
       method: "PATCH",
       auth: true,
       body: toIdentityAddress(address)
     });
     return fromIdentityAddress(a, currentMe()?.email);
   }
-  async deleteAddress(id) {
-    await this.engine(`/x/identity/me/addresses/${enc(id)}`, { method: "DELETE", auth: true });
-    return { id: String(id), deleted: true };
+  async deleteAddress(id2) {
+    await this.engine(`/x/identity/me/addresses/${enc(id2)}`, { method: "DELETE", auth: true });
+    return { id: String(id2), deleted: true };
   }
 };
-var enc = (id) => encodeURIComponent(String(id));
+var enc = (id2) => encodeURIComponent(String(id2));
 var addressService = new AddressService();
 
 // src/services/wishlist-service.ts
@@ -2144,6 +2284,18 @@ var WishlistService = class extends BaseService {
     const saved = new Set((list?.items ?? []).map((i) => String(i.product_id)));
     return (pairs ?? []).map((p) => ({ ...p, exists: saved.has(String(p.productId)) }));
   }
+  /**
+   * The address the store may write to when a saved product is back in stock
+   * or on sale; `''` takes it off. A list that does not exist yet is made.
+   */
+  async setEmail(email) {
+    const list = await this.current() ?? await this.create();
+    await this.data(`/x/wishlist/${enc2(list.token)}`, {
+      method: "PATCH",
+      body: { email: String(email ?? "").trim() }
+    });
+    return { email: String(email ?? "").trim() || null };
+  }
   async current() {
     const token = wishlistToken();
     if (!token) return null;
@@ -2226,6 +2378,15 @@ var MenuService = class extends BaseService {
     if (menus) return { data: menus };
     return resolveRestLocally("get", "/api/menu");
   }
+  /** Every menu the store keeps, by handle — not only the header and footer. */
+  async listMenus() {
+    return await this.data("/x/navigation/menus") ?? [];
+  }
+  /** One menu by handle, in the storefront's shape: `{ menuId, name, items: [{ id, name, link, items }] }`. */
+  async getMenu(handle) {
+    const m = await this.data(`/x/navigation/menus/${encodeURIComponent(handle)}`);
+    return { menuId: m.handle, name: m.title, items: (m.items ?? []).map(toItem) };
+  }
   /** The header and footer menus, or `null` when the module is not there. Cached: a menu is store-level. */
   async engineMenus() {
     if (!await this.facts.pluginOn("navigation")) return null;
@@ -2244,6 +2405,24 @@ var MenuService = class extends BaseService {
 };
 var menuService = new MenuService();
 
+// src/services/newsletter-service.ts
+var NewsletterService = class extends BaseService {
+  async subscribe({ email, name, source }) {
+    return this.data("/x/newsletter/subscribe", {
+      method: "POST",
+      body: { email: String(email ?? "").trim(), ...name ? { name } : {}, ...source ? { source } : {} }
+    });
+  }
+  /** The token from the unsubscribe link in a newsletter email. */
+  async unsubscribe(token) {
+    return this.data("/x/newsletter/unsubscribe", {
+      method: "POST",
+      body: { token: String(token ?? "") }
+    });
+  }
+};
+var newsletterService = new NewsletterService();
+
 // src/services/store-service.ts
 function symbolFor(code) {
   try {
@@ -2277,6 +2456,22 @@ var StoreService = class extends BaseService {
     }
     return super.get(path);
   }
+  /**
+   * The storefront's newsletter box posts `{ email }` to Litekart's
+   * `/api/newsletter/subscribe` through this verb; ext/newsletter is where
+   * that list lives here.
+   */
+  async post(path, data) {
+    if (path.split("?")[0] === "/api/newsletter/subscribe") {
+      const { email, name } = data ?? {};
+      return await new NewsletterService(this._fetch).subscribe({
+        email: email ?? "",
+        name,
+        source: "storefront"
+      });
+    }
+    return super.post(path, data);
+  }
   async live() {
     const [ready, plugins, menus, base] = await Promise.all([
       this.facts.ready(),
@@ -2582,9 +2777,304 @@ var varniCustomProductService = new VarniCustomProductService();
 var pluginsService = pluginService;
 var settingsService = settingService;
 
+// src/services/variant-service.ts
+var VariantService = class extends BaseService {
+  /** A product's variants, inactive ones included (filter on `active`), in the merchant's order. */
+  async list(productId, { page = 1, limit = 50 } = {}) {
+    const env = await this.engine("/api/variants", { query: { product_id: productId, page, limit } });
+    return { data: (env.data ?? []).map(withAmounts), meta: env.meta };
+  }
+  async getOne(id2) {
+    return withAmounts(await this.data(`/api/variants/${encodeURIComponent(String(id2))}`));
+  }
+  /**
+   * What each approved seller asks for this variant, cheapest first. A cart
+   * line takes a variant, not an offer, so this informs a shopper rather than
+   * choosing who fulfils.
+   */
+  async offers(variantId) {
+    const offers = await this.data(`/api/variants/${encodeURIComponent(String(variantId))}/offers`) ?? [];
+    return offers.map((o) => ({ ...o, price: { ...o.price, amount: toMajor(o.price) } }));
+  }
+};
+function withAmounts(v) {
+  return {
+    ...v,
+    price: { ...v.price, amount: toMajor(v.price) },
+    compare_at_price: v.compare_at_price ? { ...v.compare_at_price, amount: toMajor(v.compare_at_price) } : void 0
+  };
+}
+var variantService = new VariantService();
+
+// src/services/b2b-service.ts
+var B2bService = class extends BaseService {
+  // ------------------------------------------------------------ company
+  /** The company, the caller's role in it, and its credit: limit, outstanding, available, overdue. */
+  async me() {
+    const me = await this.data("/x/b2b/me", { auth: true });
+    const { notes: _notes, metadata: _metadata, ...company } = me.company;
+    return { company, role: me.role, credit: me.credit };
+  }
+  async members() {
+    return await this.data("/x/b2b/members", { auth: true }) ?? [];
+  }
+  /** Admin only. Demoting the last admin is refused (409). */
+  async setMemberRole(customerId, role) {
+    return this.data(`/x/b2b/members/${id(customerId)}`, { method: "PATCH", auth: true, body: { role } });
+  }
+  /** An admin removes anyone; any member may remove themselves. */
+  async removeMember(customerId) {
+    await this.engine(`/x/b2b/members/${id(customerId)}`, { method: "DELETE", auth: true });
+  }
+  // ------------------------------------------------------------ invitations
+  /** Admin only. Open invitations: not accepted, not expired. */
+  async invitations() {
+    return await this.data("/x/b2b/invitations", { auth: true }) ?? [];
+  }
+  /** Admin only. Emails a link; a second invitation to the same address replaces the first. */
+  async invite({ email, role }) {
+    return this.data("/x/b2b/invitations", {
+      method: "POST",
+      auth: true,
+      body: { email: String(email ?? "").trim(), role }
+    });
+  }
+  async withdrawInvitation(invitationId) {
+    await this.engine(`/x/b2b/invitations/${id(invitationId)}`, { method: "DELETE", auth: true });
+  }
+  /**
+   * The token from the invitation email, accepted by the account it was sent
+   * to — which also confirms that account's email address.
+   */
+  async acceptInvitation(token) {
+    return this.data("/x/b2b/invitations/accept", {
+      method: "POST",
+      auth: true,
+      body: { token: String(token ?? "").trim() }
+    });
+  }
+  // ------------------------------------------------------------ filling a basket
+  /**
+   * A quick order: up to 500 lines by SKU or variant id, into the bag (or a new
+   * one), at the company's prices. A line that will not go in is reported in
+   * `rejected` with its reason; the rest are added.
+   */
+  async addLines({
+    cartId,
+    lines
+  }) {
+    const res = await this.data("/x/b2b/cart/lines", {
+      method: "POST",
+      auth: true,
+      body: {
+        ...cartId ?? storedCartId() ? { cart_id: cartId ?? storedCartId() } : {},
+        lines: (lines ?? []).map((l) => ({
+          ...l.variantId ? { variant_id: Number(l.variantId) } : {},
+          ...l.sku ? { sku: String(l.sku).trim() } : {},
+          quantity: Number(l.quantity)
+        }))
+      }
+    });
+    rememberCartId(res.cart.id);
+    return { cart: toCart(res.cart, cartExtras(res.cart.id)), rejected: res.rejected ?? [] };
+  }
+  /** A past order's lines in a new bag, at today's prices. Nothing is placed. */
+  async reorder(orderId) {
+    const res = await this.data(
+      `/x/b2b/orders/${id(orderId)}/reorder`,
+      {
+        method: "POST",
+        auth: true
+      }
+    );
+    rememberCartId(res.cart.id);
+    return { cart: toCart(res.cart, cartExtras(res.cart.id)), rejected: res.rejected ?? [] };
+  }
+  // ------------------------------------------------------------ placing an order
+  /**
+   * Places the bag through the company: on account by default, with a PO
+   * number, optionally only some lines (`lineIds`). A buyer over the company's
+   * approval threshold gets `{ kind: 'approval' }` instead of an order — the
+   * bag stays as it was, and an approver places it later.
+   *
+   * Over the credit limit is 403 `credit_limit_exceeded`; `me().credit` says
+   * how much is available before the shopper tries.
+   */
+  async checkout({
+    cartId,
+    lineIds,
+    shippingRateId,
+    returnUrl,
+    paymentData,
+    ...opts
+  } = {}) {
+    const cart = cartId || storedCartId();
+    if (!cart) throw new GoCommerceError("Your bag is empty.", 400);
+    const extras = cartExtras(cart);
+    const rate = shippingRateId ?? extras.shippingRateId;
+    const body = {
+      cart_id: cart,
+      ...this.placeBody(opts, extras.shippingAddress ?? void 0),
+      ...rate ? { shipping_rate_id: Number(rate) } : {},
+      ...lineIds?.length ? { line_ids: lineIds.map(Number) } : {},
+      ...returnUrl ? { return_url: returnUrl } : {},
+      ...paymentData ? { payment_data: paymentData } : {}
+    };
+    const res = await this.data("/x/b2b/checkout", {
+      method: "POST",
+      auth: true,
+      body,
+      headers: { "Idempotency-Key": attemptKey(`b2b:${JSON.stringify(body)}`) }
+    });
+    return this.placed(res, cart);
+  }
+  // ------------------------------------------------------------ the company's orders
+  /** Admins and approvers see the company's; a buyer sees their own. `q` matches the number, PO or email. */
+  async orders({
+    page = 1,
+    limit = 20,
+    q,
+    overdue
+  } = {}) {
+    return this.engine("/x/b2b/orders", {
+      auth: true,
+      query: { page, limit, q, ...overdue ? { overdue: "true" } : {} }
+    });
+  }
+  // ------------------------------------------------------------ approvals
+  async approvals({
+    page = 1,
+    limit = 20,
+    status
+  } = {}) {
+    return this.engine("/x/b2b/approvals", { auth: true, query: { page, limit, status } });
+  }
+  async approval(approvalId) {
+    return this.data(`/x/b2b/approvals/${id(approvalId)}`, { auth: true });
+  }
+  /**
+   * Admin or approver: places the requested order at the prices it was
+   * requested at. Credit limits and holds still apply. The payment intent is
+   * the approver's to act on — for an account order there is nothing to do.
+   */
+  async approve(approvalId) {
+    const res = await this.data(`/x/b2b/approvals/${id(approvalId)}/approve`, {
+      method: "POST",
+      auth: true
+    });
+    return { approval: res.approval, orderNo: res.order.number, order: toOrder(res.order), payment: res.payment };
+  }
+  async reject(approvalId, reason) {
+    return this.data(`/x/b2b/approvals/${id(approvalId)}/reject`, {
+      method: "POST",
+      auth: true,
+      ...reason ? { body: { reason } } : {}
+    });
+  }
+  /** The buyer who asked withdraws the request. */
+  async cancelApproval(approvalId) {
+    return this.data(`/x/b2b/approvals/${id(approvalId)}/cancel`, { method: "POST", auth: true });
+  }
+  // ------------------------------------------------------------ quotes
+  async quotes({ page = 1, limit = 20, status } = {}) {
+    return this.engine("/x/b2b/quotes", { auth: true, query: { page, limit, status } });
+  }
+  async quote(quoteId) {
+    return this.data(`/x/b2b/quotes/${id(quoteId)}`, { auth: true });
+  }
+  /** Asks the store to price these lines. The store answers with unit prices and an expiry. */
+  async requestQuote({ lines, note }) {
+    return this.data("/x/b2b/quotes", {
+      method: "POST",
+      auth: true,
+      body: {
+        lines: (lines ?? []).map((l) => ({ variant_id: Number(l.variantId), quantity: Number(l.quantity) })),
+        ...note ? { note } : {}
+      }
+    });
+  }
+  /** Places the quote at its agreed prices — or, for a buyer over the threshold, asks for approval. */
+  async acceptQuote(quoteId, opts = {}) {
+    const res = await this.data(`/x/b2b/quotes/${id(quoteId)}/accept`, {
+      method: "POST",
+      auth: true,
+      body: this.placeBody(opts)
+    });
+    return this.placed(res);
+  }
+  async declineQuote(quoteId) {
+    return this.data(`/x/b2b/quotes/${id(quoteId)}/decline`, { method: "POST", auth: true });
+  }
+  // ------------------------------------------------------------ dealer leads
+  /**
+   * The public "find a dealer" form: no account needed. The engine routes it to
+   * the dealer whose territory covers the address — or keeps it — and answers
+   * the same either way, so the form never reveals who got it.
+   */
+  async submitLead(lead) {
+    return this.data("/x/b2b/leads", {
+      method: "POST",
+      body: {
+        ...lead.name ? { name: lead.name } : {},
+        ...lead.email ? { email: lead.email } : {},
+        ...lead.phone ? { phone: lead.phone } : {},
+        ...lead.message ? { message: lead.message } : {},
+        ...lead.country ? { country: lead.country } : {},
+        ...lead.state ? { state: lead.state } : {},
+        ...lead.postalCode ? { postal_code: lead.postalCode } : {},
+        ...lead.productId ? { product_id: Number(lead.productId) } : {},
+        ...lead.variantId ? { variant_id: Number(lead.variantId) } : {},
+        ...lead.source ? { source: lead.source } : {}
+      }
+    });
+  }
+  /** A dealer's admins and approvers: the leads routed to their company. */
+  async leads({ page = 1, limit = 20, status } = {}) {
+    return this.engine("/x/b2b/leads", { auth: true, query: { page, limit, status } });
+  }
+  async setLeadStatus(leadId, status) {
+    return this.data(`/x/b2b/leads/${id(leadId)}`, { method: "PATCH", auth: true, body: { status } });
+  }
+  // ------------------------------------------------------------ internals
+  /** The fields checkout and quote acceptance share. Only declared ones: the engine refuses the rest. */
+  placeBody(opts, fallback) {
+    const raw = opts.address ?? fallback;
+    if (!raw) throw new GoCommerceError("Add a delivery address first.", 400);
+    const address = "line1" in raw ? raw : toEngineAddress(raw);
+    return {
+      address,
+      ...opts.paymentMethod ? { payment_method: String(opts.paymentMethod).toLowerCase() } : {},
+      ...opts.poNumber ? { po_number: String(opts.poNumber).trim() } : {},
+      ...opts.name ?? address.name ? { name: opts.name ?? address.name } : {},
+      ...opts.phone ?? address.phone ? { phone: opts.phone ?? address.phone } : {}
+    };
+  }
+  placed(res, cartId) {
+    if (res.approval && !res.order) return { kind: "approval", approval: res.approval };
+    const order = res.order;
+    if (order.access_token && cartId) {
+      rememberOrder({ number: order.number, token: order.access_token, cartId, reference: res.payment?.reference });
+    }
+    return { kind: "order", orderNo: order.number, order: toOrder(order), payment: res.payment };
+  }
+};
+var id = (v) => encodeURIComponent(String(v));
+var keys = /* @__PURE__ */ new Map();
+function attemptKey(request) {
+  let key = keys.get(request);
+  if (!key) {
+    const c = globalThis.crypto;
+    key = c?.randomUUID?.() ?? `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+    keys.set(request, key);
+  }
+  return key;
+}
+var b2bService = new B2bService();
+
 exports.AddressService = AddressService;
 exports.AuthService = AuthService;
 exports.AutocompleteService = AutocompleteService;
+exports.B2bService = B2bService;
 exports.BannerService = BannerService;
 exports.BaseService = BaseService;
 exports.BlogService = BlogService;
@@ -2609,6 +3099,7 @@ exports.HomeService = HomeService;
 exports.InitService = InitService;
 exports.MeilisearchService = MeilisearchService;
 exports.MenuService = MenuService;
+exports.NewsletterService = NewsletterService;
 exports.NotSupportedError = NotSupportedError;
 exports.OrderService = OrderService;
 exports.PageService = PageService;
@@ -2619,6 +3110,7 @@ exports.PopularSearchService = PopularSearchService;
 exports.PopularityService = PopularityService;
 exports.ProductService = ProductService;
 exports.ProfileService = ProfileService;
+exports.REDIRECT_GATEWAYS = REDIRECT_GATEWAYS;
 exports.ReelsService = ReelsService;
 exports.RegionService = RegionService;
 exports.ReviewService = ReviewService;
@@ -2629,6 +3121,7 @@ exports.StateService = StateService;
 exports.StoreService = StoreService;
 exports.UploadService = UploadService;
 exports.UserService = UserService;
+exports.VariantService = VariantService;
 exports.VarniCustomDesignService = VarniCustomDesignService;
 exports.VarniCustomProductService = VarniCustomProductService;
 exports.VendorService = VendorService;
@@ -2637,6 +3130,7 @@ exports.WishlistService = WishlistService;
 exports.addressService = addressService;
 exports.authService = authService;
 exports.autocompleteService = autocompleteService;
+exports.b2bService = b2bService;
 exports.bannerService = bannerService;
 exports.blogService = blogService;
 exports.cartService = cartService;
@@ -2668,6 +3162,7 @@ exports.initService = initService;
 exports.meilisearchService = meilisearchService;
 exports.menuService = menuService;
 exports.minorToMajor = minorToMajor;
+exports.newsletterService = newsletterService;
 exports.orderService = orderService;
 exports.pageService = pageService;
 exports.paymentMethodService = paymentMethodService;
@@ -2710,6 +3205,7 @@ exports.toVariant = toVariant;
 exports.toVendor = toVendor;
 exports.uploadService = uploadService;
 exports.userService = userService;
+exports.variantService = variantService;
 exports.varniCustomDesignService = varniCustomDesignService;
 exports.varniCustomProductService = varniCustomProductService;
 exports.vendorService = vendorService;