@base44/app-plugin-commerce 0.2.7 → 0.3.2

package/src/commerce/storefront/StorefrontProvider.jsx

@@ -8,8 +8,6 @@ import React, {
   useState,
 } from "react";
 import {
-  attributesLabel,
-  cartTotalsLines,
   createStorefront,
   storefrontErrorCode,
   storefrontErrorMessage,
@@ -18,43 +16,24 @@ import {
 /**
  * StorefrontProvider — one client, one store-info cache, ONE shared cart.
  *
- * Mount it once, above every storefront page (product list, product page,
- * cart, checkout, order-received). It is NOT a <Route>. A store with shared
- * chrome — nearly all of them — mounts it on a pathless layout route, wrapping
- * the layout that renders <Outlet/>, which keeps the nav's cart badge and the
- * page on one cart and leaves the admin outside:
+ * Mount it **once**, above every storefront page, on a pathless layout route
+ * wrapping the layout that renders `<Outlet/>` (`<StorefrontProvider
+ * base44={base44}><StoreLayout /></StorefrontProvider>` as that route's
+ * `element`); with no shared layout, wrap `<Routes>` instead. Two ways to get
+ * this wrong, both with symptoms:
+ * - as a child of `<Routes>` React Router throws "is not a `<Route>` component";
+ * - a layout that renders the provider *inside* itself leaves the nav outside
+ *   it, so the cart badge and the cart page read different carts.
  *
- *   import { base44 } from "@/api/base44Client";
- *   <Route element={<StorefrontProvider base44={base44}><StoreLayout /></StorefrontProvider>}>
- *     <Route path="/" element={<Home />} /> …
- *   </Route>
+ * Pass `base44`, or `store={createStorefront(base44)}` when other modules need
+ * the same client.
  *
- * With no shared layout it can wrap <Routes> directly instead:
- *
- *   <StorefrontProvider base44={base44}> <Routes>…</Routes> </StorefrontProvider>
- *
- * As a child of <Routes> it throws ("is not a <Route> component"), since React
- * Router allows only <Route>/<Fragment> children there. Never the other way
- * round either: a layout that renders the provider inside itself puts the nav
- * outside it, so the badge and the cart page read different carts.
- *
- * or, if other modules also need the raw client, create it once and share it:
- *
- *   // src/lib/storefront.js
- *   import { createStorefront } from "@/commerce/utils";
- *   import { base44 } from "@/api/base44Client";
- *   export const store = createStorefront(base44);
- *
- *   <StorefrontProvider store={store}> ... </StorefrontProvider>
- *
- * What lives here (and why it must not be duplicated per page):
- * - the `createStorefront` instance — it owns the cart_token lifecycle;
- * - store info — payment_gateways, currency, countries/currencies come from
- *   `get-store-info` ONLY (never off a cart view), cached for the session;
- * - the cart view — every mutation from any component funnels through one
- *   serialized queue, so a slow response can never clobber a newer cart, and
- *   a header badge, a cart drawer and the checkout all re-render from the
- *   same state.
+ * What lives here, and why it must not be duplicated per page: the client (it
+ * owns the cart_token lifecycle); store info, cached for the session —
+ * payment gateways, currency and countries come from `get-store-info` ONLY,
+ * never off a cart view; and the cart, whose every mutation funnels through one
+ * serialized queue, so a slow response cannot clobber a newer cart and the
+ * badge, the drawer and the checkout all re-render from one state.
  */
 
 const StorefrontContext = createContext(null);
@@ -167,6 +146,22 @@ export function useStoreInfo() {
   };
 }
 
+/**
+ * The store's country list, **always as an array** — `{ countries, options,
+ * loading, error }`, `options` as `{value, label}` for a `<select>`.
+ *
+ * `useStoreInfo().countries` is `null` until store info resolves, so mapping it
+ * directly white-screens the checkout on a cold load — the most severe defect
+ * observed in a generated storefront. Here the list is empty-then-full, never
+ * null, and `loading` says which.
+ */
+export function useCountries() {
+  const { countries, loading, error } = useStoreInfo();
+  const list = Array.isArray(countries) ? countries : [];
+  const options = useMemo(() => list.map((c) => ({ value: c.code, label: c.name })), [countries]); // eslint-disable-line react-hooks/exhaustive-deps
+  return { countries: list, options, loading, error };
+}
+
 /**
  * `(amount) => "€19.99"` in the store's currency, per the viewer's locale.
  * Falls back to a plain number while store info is still loading.
@@ -189,55 +184,49 @@ export function useFormatMoney() {
 }
 
 /**
- * The shared cart — state, decorated lines, and every cart mutation. All
- * consumers see the same view; every action resolves to the fresh priced cart.
+ * The shared cart — state plus every cart mutation. All consumers see the same
+ * view; every action resolves to the fresh priced cart it published.
  *
- *   const { status, lines, totalsLines, notices, updateItem, removeItem } = useCart();
- *   if (status === "loading") return <Skeleton />;
- *   if (status === "empty")   return <EmptyBag />;
- *   lines.map(line => …)   // line.attributesLabel, line.image, line.canIncrease
+ *   const { status, cart, updateItem, removeItem, applyCoupon } = useCart();
+ *   if (status === "loading") return <YourSkeleton />;
+ *   if (status === "empty")   return <YourEmptyBag />;
+ *   cart.items.map(item => …)   // your rows; useCartLine(item) per row
  *
  * **Branch on `status`, not on `isEmpty`.** `isEmpty` is true while the cart is
  * still loading (there are no items *yet*), so a page that renders its empty
  * state from it flashes "your bag is empty" on every visit before the cart
  * arrives. `status` separates the two: `"loading"` → `"empty"` | `"ready"`.
  *
- * - `lines` are `cart.items` decorated with what a renderer needs and would
- *   otherwise re-derive: `attributesLabel` ("Size: 42 · Color: Ivory" — the raw
- *   `attributes` is an **array** of `{name, option}`, never a map),
- *   `image` normalized to `{src, alt}` or null, money pre-formatted
- *   (`totalLabel`, `subtotalLabel`, `unitPriceLabel` — no `useFormatMoney`
- *   needed in a row), `purchasable` as a boolean with `unavailableReason`
- *   beside it, and the quantity bounds.
- * - `notices` normalizes `coupon_notices` + `removed_items` into one list —
- *   render it, or a line that auto-dropped vanishes with no explanation.
- * - `mutationError` is the last failed mutation (insufficient stock, an expired
- *   cart), cleared on the next success. Mutations still reject, so
- *   `useCartLine`/`useAddToCart` can handle failures locally.
- * - `applyCoupon(code)` resolves to `{ ok, cart }` or `{ ok: false, code,
- *   message }` — an invalid code is expected flow, not an exception.
- *
- * ## When `status` settles — and what it does not cover
+ * Rendering `cart.items` is yours; three shapes in there are easy to misread,
+ * and `@/commerce/utils` has the helper for each:
+ * - `item.attributes` is an **array** of `{name, option}`, never a map →
+ *   `attributesLabel(item.attributes)`.
+ * - `item.purchasable` is a **result object** `{ok, code, error}`, not a
+ *   boolean — truthiness alone calls every line purchasable.
+ * - the cart's totals are **nested** (`cart.totals`), an order's are flat →
+ *   `cartTotalsLines(cart, { formatMoney })` renders every line the store
+ *   actually has, including the discount and tax rows a hand-written summary
+ *   drops.
  *
- * `status` is `"loading"` for exactly one thing: the **first** `getCart()` of
- * the session has not resolved yet (internally, `cart === undefined`). It
- * settles once, to `"empty"` or `"ready"`, and after that:
+ * Also render `cart.coupon_notices` / `cart.removed_items` when present: they
+ * say what auto-dropped and why, in the server's words.
  *
- * - **A mutation never returns it to `"loading"`.** Adding, updating, removing
- *   or couponing leaves `status` as it was, previous numbers on screen, until
- *   the new view lands. There is no cart-wide busy flag by design: a page-wide
- *   spinner for a 250ms quantity step is worse than the stale number, and the
- *   right busy scope is the row (`useCartLine`'s `pending`) or the control that
- *   started it.
- * - `"empty"` therefore means *loaded, with no items* — including after
- *   checkout consumes the cart — never "still arriving".
- * - It flips `"empty"` → `"ready"` when the first line lands, so a header badge
- *   and a drawer switch states off the same signal.
+ * - `mutationError` is the last failed mutation (insufficient stock, an expired
+ *   cart) as `{code, message}`, cleared on the next success. Mutations still
+ *   reject, so a caller can handle failures locally too.
+ * - `applyCoupon(code)` resolves `{ ok, cart }` or `{ ok: false, code, message }`
+ *   — an invalid code is expected flow, not an exception. Coupons are admin-only
+ *   data, so a seeded code is reachable **only** through a field the customer
+ *   types it into: a store with coupons needs one, in the cart or the checkout.
  *
- * So branch **`status`** for the page's loading/empty/ready shape, and watch
- * **`useCartLine().pending`** (or your own flag around `addItem`) for "did that
- * change land". Anything waiting on a mutation — a queued follow-up action, a
- * script driving the page — waits on the second, never the first.
+ * `status` settles **once** — `"loading"` means only that the session's first
+ * `getCart()` is outstanding. A mutation never returns it to `"loading"`
+ * (previous numbers stay on screen until the new view lands), so there is no
+ * cart-wide busy flag by design: the right busy scope is the row
+ * (`useCartLine().pending`) or the control that started it. `"empty"` therefore
+ * always means *loaded, with no items* — including after checkout consumes the
+ * cart. Anything waiting for a mutation to land waits on `pending`, never on
+ * `status`.
  */
 export function useCart() {
   const { client, cart, cartError, mutationError, runCart } = useStorefrontState();
@@ -270,58 +259,9 @@ export function useCart() {
     [client, runCart],
   );
 
-  const formatMoney = useFormatMoney();
   const items = cart?.items ?? [];
   const loading = cart === undefined;
 
-  const lines = useMemo(
-    () =>
-      items.map((item) => {
-        // A cart line's `purchasable` is a RESULT object ({ ok, code, error }),
-        // not a boolean — truthiness alone would call every line purchasable.
-        const purchasable = item.purchasable?.ok ?? Boolean(item.purchasable);
-        // `sold_individually` is the only per-line ceiling the cart view
-        // carries; real stock limits surface as `insufficient_stock` from the
-        // server when a customer tries to exceed them.
-        const maxQuantity = item.sold_individually ? 1 : Infinity;
-        return {
-          ...item,
-          attributesLabel: attributesLabel(item.attributes),
-          image: item.image ? { src: item.image, alt: item.name ?? "" } : null,
-          totalLabel: item.total != null ? formatMoney(item.total) : "",
-          subtotalLabel: item.subtotal != null ? formatMoney(item.subtotal) : "",
-          unitPriceLabel: item.price != null ? formatMoney(item.price) : "",
-          maxQuantity,
-          canIncrease: item.quantity < maxQuantity,
-          canDecrease: item.quantity > 1,
-          purchasable,
-          unavailableReason: purchasable ? null : (item.purchasable?.error ?? null),
-        };
-      }),
-    [items, formatMoney],
-  );
-
-  const notices = useMemo(
-    () => [
-      ...(cart?.coupon_notices ?? []).map((n) => ({
-        kind: "coupon",
-        code: n.error_code ?? n.code ?? "coupon_invalid",
-        message: n.error ?? `Coupon ${n.code} is no longer valid.`,
-      })),
-      ...(cart?.removed_items ?? []).map((r) => ({
-        kind: "removed_item",
-        code: r.code ?? "unavailable",
-        message: r.reason ?? "An item is no longer available and was removed.",
-      })),
-    ],
-    [cart],
-  );
-
-  const totalsLines = useMemo(
-    () => (cart ? cartTotalsLines(cart, { formatMoney }) : []),
-    [cart, formatMoney],
-  );
-
   return {
     cart: cart ?? null,
     loading,
@@ -330,9 +270,6 @@ export function useCart() {
     itemCount: items.reduce((n, i) => n + (i.quantity || 0), 0),
     isEmpty: !items.length,
     status: loading ? "loading" : items.length ? "ready" : "empty",
-    lines,
-    notices,
-    totalsLines,
     refresh,
     addItem,
     updateItem,

package/src/commerce/storefront/cartUI.jsx

@@ -5,39 +5,20 @@ import { useLocation } from "react-router-dom";
  * Cart drawer/panel state, headless: `open` plus the handlers to change it,
  * and the two behaviors every drawer needs but a hand-written one forgets —
  * it closes when the route changes (`closeOnNavigate`) and it opens when an
- * item lands in the cart (`openOnAdd`, wired through `useAddToCart` /
- * `useUpsell`; pass false for a navigate-to-bag flow). Esc closes it. You own
- * every element, class and attribute.
+ * item lands in the cart (`openOnAdd`, wired through `useAddToCart`; pass false
+ * for a navigate-to-bag flow). Esc closes it. You own every element, class and
+ * attribute.
  *
  * Mount `<CartUIProvider>` once, inside `<StorefrontProvider>`, around the
- * layout. Then the layout renders off `open`:
+ * layout; the layout then renders the panel off `open`.
  *
- *   function StoreLayout() {
- *     const ui = useCartUI();
- *     const { itemCount } = useCart();
- *     return (<>
- *       <header>… <button type="button" onClick={ui.toggleCart}
- *                         aria-expanded={ui.open}>Bag ({itemCount})</button></header>
- *       <Outlet />
- *       {ui.open && (<>
- *         <div onClick={ui.closeCart} aria-hidden="true" className="…" />
- *         <aside role="dialog" aria-modal="true" aria-label="Cart" className="…">
- *           <button type="button" onClick={ui.closeCart} aria-label="Close cart">×</button>
- *           {…your cart rows: useCart + CartLine…}
- *         </aside>
- *       </>)}
- *     </>);
- *   }
- *
- * ⚑ **Render the drawer conditionally (`{ui.open && …}`), as above.** The
- * classic drawer bug is a panel that is translated off-screen but still
- * mounted: its buttons stay clickable, tab-able and visible to screen readers.
- * Unmounting it when closed is the trivial fix. If you keep it mounted to
- * animate the slide, that concern is yours again — set the `inert` attribute
- * while closed.
- *
- * The overlay is a click-away surface (`aria-hidden`, no tab stop needed) —
- * it is not the close control; a named close button inside the panel is.
+ * ⚑ **Render the drawer conditionally — `{ui.open && …}`.** The classic drawer
+ * bug is a panel translated off-screen but still mounted: its buttons stay
+ * clickable, tab-able and visible to screen readers. Unmounting when closed is
+ * the trivial fix; if you keep it mounted to animate the slide, that concern is
+ * yours again — set the `inert` attribute while closed. The overlay is a
+ * click-away surface (`aria-hidden`, no tab stop) — it is not the close control;
+ * a named close button inside the panel is.
  *
  * `useCartUI()` → `{ open, openCart, closeCart, toggleCart }`.
  * `useCartUIOptional()` returns null instead of throwing (how `useAddToCart`

package/src/commerce/storefront/index.js

@@ -1,97 +1,56 @@
 /**
  * Storefront React layer — **headless**: hooks and render-prop components that
- * own the store's logic and hand you the data; they render nothing and carry
- * no styling. Every element, class and word of copy in the storefront is
- * written by you, against these APIs. Ships with the Base44 Commerce Template
- * next to the framework-free `@/commerce/utils` (which it builds on); needs
- * React and nothing else.
+ * own the store's logic and hand you the data. They render nothing, carry no
+ * styling, and ship no customer-facing copy — every element, class and word in
+ * the storefront is written by you, against these APIs. Ships with the Base44
+ * Commerce Plugin next to the framework-free `@/commerce/utils` (which it
+ * builds on); needs React and nothing else.
  *
  * The split: **logic is premade, UI never is.** Checkout repricing, variant
- * resolution, cart state, review policies, order-return verification — done
- * here, and hand-rolling any of it is where storefront bugs cluster. What a
- * checkout or a product page *looks like* is the store's identity, and no two
- * stores should share it — so nothing here emits markup. Each hook returns a
- * complete view-model (statuses to branch on, ready-to-map arrays, handlers,
- * error objects), and each doc comment states the render rules that keep the
- * store correct (e.g. an unbuyable variant option renders *disabled, not
- * hidden*; a receipt page must render `paymentInstructions`).
+ * resolution, cart state, order-return verification — done here, and
+ * hand-rolling any of it is where storefront bugs cluster. What a checkout or a
+ * product page *looks like* is the store's identity, and no two stores should
+ * share it — so nothing here emits markup, and every state arrives as a **code**
+ * (`state`, `status`, `hint.code`, `blockers`) that you write the words for.
  *
- * Setup (once, above every storefront route — on a pathless layout route,
- * wrapping the layout that renders <Outlet/>; as a child of <Routes> React
- * Router throws "is not a <Route> component"):
+ * `StorefrontProvider` mounts once, above every storefront route (see its own
+ * doc comment — getting the mounting wrong is the one setup error worth
+ * knowing). Each hook's doc comment is its contract; the map:
  *
- *   import { StorefrontProvider } from "@/commerce/storefront";
- *   import { base44 } from "@/api/base44Client";
- *   <Route element={<StorefrontProvider base44={base44}><StoreLayout /></StorefrontProvider>}>
- *     <Route path="/" element={<Home />} /> …
- *   </Route>
- *   // no shared layout? <StorefrontProvider …> <Routes>…</Routes> </StorefrontProvider>
- *
- * Every hook hands back **plain states and handlers** — strings, booleans,
- * arrays, callbacks (`buy.label`, `buy.disabled`, `buy.addToCart`, `f.value`,
- * `f.set`) — never ready-made prop objects to spread. You write every element
- * and every attribute; the hook guarantees the values are right.
- *
- * ## Hooks
- * - `useStorefront` / `useStoreInfo` / `useFormatMoney` / `useMoney` — the
+ * - `useStorefront` / `useStoreInfo` / `useFormatMoney` / `useCountries` — the
  *     shared client, cached store info (the ONLY source of payment gateways,
- *     currency and countries), money in the store's currency.
- * - `useProductList` / `useCategories` / `useRibbons` — a listing with paging
- *     (render the paging control off `hasNext` — a page that skips it caps the
- *     catalog), filters, `refreshing`, and failure as a visible state.
- * - `useProduct` / `useAddToCart` / `useProductPrice` / `useProductGallery` /
- *     `useProductSpecs` — the product page: fetch + variant selection +
- *     quantity + price + gallery, race-safe, with `status: "not_found"` and
- *     every add-to-cart failure handled; the buy box as
- *     `state`/`label`/`disabled`/`addToCart`. `variantAxes(view, pick)`
- *     (from `@/commerce/utils`, re-exported here) turns the resolved view into
- *     a render-ready model for the selector you write; `useProductSpecs` adds
- *     normalized `pick`/`get` lookup over `productSpecs`.
- * - `useProductReviews` — the review list and the submit form, with the store's
- *     policy as a prop and field errors matching the server's codes.
- * - `useCart` / `useCartLine` / `useCoupon` — the shared cart (branch on
- *     `status`, render `lines` and `notices` — money pre-formatted per line),
- *     quantity steppers that clamp and recover, and the coupon field a store
- *     with coupons must have.
- * - `useCartUI` + `<CartUIProvider>` — the cart drawer's non-visual machinery:
- *     `open` + open/close/toggle handlers, Esc, close-on-navigate, open-on-add;
- *     render the drawer conditionally off `open`.
+ *     currency and countries), money in the store's currency, and the country
+ *     list as an array that is never null.
+ * - `useProductList` / `useCategories` / `useRibbons` — a listing with paging,
+ *     the whole server-side filter surface, and failure as a visible state.
+ * - `useProduct` / `useAddToCart` — the product page: fetch + variant selection
+ *     + quantity, race-safe; the buy box as `state`/`disabled`/`addToCart`.
+ * - `useCart` / `useCartLine` / `CartLine` — the shared cart (branch on
+ *     `status`, map `cart.items` into your own rows) plus quantity steppers that
+ *     clamp, coalesce rapid clicks and roll back on rejection.
+ * - `useCartUI` + `<CartUIProvider>` — a cart drawer's non-visual state.
  * - `useCheckout` / `CheckoutProvider` / `useCheckoutContext` — the guided
- *     checkout: address state with automatic debounced shipping/tax
- *     recalculation, shipping and payment choice, a `canPlaceOrder` gate with
- *     named blockers, `placeOrder` with both navigations handled (online →
- *     provider redirect, manual → `/order-received`).
- * - `usePlaceOrder` — the gate as one surface: `placeOrder`, `disabled`,
- *     `label`, `stage` (guards the just-placed-order frames), `blockers` in
- *     words.
- * - `useAddressForm` / `useCountries` / `useTotalsLines` /
- *     `useCheckoutBlockers` — the address form as a field spec, each field
- *     self-contained (`id`/`value`/`set`/`error`/`autoComplete`, `state`
- *     included, country options never null), one totals projection for cart
- *     and order, and blocker codes turned into copy.
- * - `useUpsell` — one product offered beside another surface: fetch-or-row,
- *     already-in-cart matched by id, one-click add.
- * - `useOrderReturn` — the mandatory `/order-received` page in one hook:
- *     status, order, `lines`, `paymentLink`, `paymentInstructions`, noindex.
- * - `useStorefrontSeo` + `productSeo` / `collectionSeo` / `orderSeo` — titles,
- *     meta and product structured data; receipts are `noindex`.
+ *     checkout: automatic shipping/tax recalculation, shipping and payment
+ *     choice, a `canPlaceOrder` gate with named blockers, `placeOrder`.
+ * - `useOrderReturn` — the mandatory `/order-received` page in one hook.
+ * - `ShippingMethodPicker` / `PaymentMethodPicker` — render-prop components for
+ *     the two checkout choices that are store data, never hardcoded.
  *
- * ## Render-prop components (headless — children is a function, no markup ships)
- * - `ShippingMethodPicker` / `PaymentMethodPicker` — the two checkout choices
- *     that are store data, never hardcoded; options arrive decorated with
- *     `selected`/`select()`/`costLabel` and a single `hint` message.
- * - `CartLine` — per-line `useCartLine` binding for your cart rows, so a
- *     `lines.map(...)` never calls a hook in a loop.
+ * Re-exported from `@/commerce/utils` so one import line covers a page:
+ * `variantAxes` (axes → options with selected/disabled/stock derived),
+ * `productPrice` (the from-price and incomplete-selection range rules),
+ * `productImages` + `imageIndex` (an image's position in that list — how a
+ * gallery follows the variant selection without owning a second copy of it),
+ * `productSpecs` + `findSpec` (meta keys are free text, so featuring a
+ * particular spec needs a tolerant lookup, not an equality test),
+ * `attributesLabel`, `cartTotalsLines` / `orderTotalsLines`,
+ * `addressFieldSpec` (the checkout's field list, including the state/province
+ * field that silently mis-prices US/CA/AU orders when it is left out), and
+ * `storefrontErrorCode` / `storefrontErrorMessage` for the calls you make
+ * yourself — every rejection from the client carries a code worth branching on.
  *
- * ## Helpers re-exported from `@/commerce/utils`
- * - `variantAxes(view, pick)` — axes → options with selected/disabled/stock
- *     state derived, for the variant selector you write.
- * - `productSpecs(product)` — `meta_data` → descriptive rows carrying an
- *     inferred `type` (`numeric` with `number`/`unit` split out, `duration`,
- *     `location`, `list` with `items`, `text`), so a weight can be a figure and
- *     a composition bars instead of every modifier being one grey table row.
- * - `productImages(product)` — images normalized to `{src, name, alt}` and
- *     de-duplicated; `[]` means render your placeholder.
+ * The catalog and product surfaces are where the design freedom lives: these
+ * hooks hand you resolved data, and the rendering is entirely yours.
  */
 export {
   StorefrontProvider,
@@ -99,10 +58,10 @@ export {
   useStorefront,
   useStoreInfo,
   useFormatMoney,
+  useCountries,
   useCart,
 } from "./StorefrontProvider";
 export { useCheckout, CheckoutProvider, useCheckoutContext } from "./useCheckout";
-export { usePlaceOrder } from "./usePlaceOrder";
 export { useOrderReturn, orderReceivedUrl } from "./useOrderReturn";
 export { ShippingMethodPicker, PaymentMethodPicker } from "./pickers";
 export { CartUIProvider, useCartUI } from "./cartUI";
@@ -115,19 +74,23 @@ export {
 
 // ── catalog ────────────────────────────────────────────────────────────────
 export { useProductList, useCategories, useRibbons } from "./useProductList";
-export { useProduct, useAddToCart, useProductSpecs } from "./useProduct";
-export { useUpsell } from "./useUpsell";
-export { useProductPrice, useMoney } from "./useProductPrice";
-export { useProductGallery } from "./useProductGallery";
-export { useProductReviews } from "./useProductReviews";
+export { useProduct, useAddToCart } from "./useProduct";
 
-// ── cart & checkout ────────────────────────────────────────────────────────
-export { useCartLine, useCoupon, CartLine } from "./useCartLine";
-export { useAddressForm, useCountries } from "./useAddressForm";
-export { useTotalsLines, useCheckoutBlockers, blockerMessage } from "./useTotalsLines";
-
-// ── SEO ────────────────────────────────────────────────────────────────────
-export { useStorefrontSeo, productSeo, collectionSeo, orderSeo } from "./useStorefrontSeo";
+// ── cart ───────────────────────────────────────────────────────────────────
+export { useCartLine, CartLine } from "./useCartLine";
 
 // ── view-model helpers (framework-free, from @/commerce/utils) ─────────────
-export { variantAxes, productSpecs, productImages } from "@/commerce/utils";
+export {
+  variantAxes,
+  productPrice,
+  productImages,
+  imageIndex,
+  productSpecs,
+  findSpec,
+  attributesLabel,
+  cartTotalsLines,
+  orderTotalsLines,
+  addressFieldSpec,
+  storefrontErrorCode,
+  storefrontErrorMessage,
+} from "@/commerce/utils";