@base44/app-plugin-commerce 0.1.18 → 0.1.20

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@base44/app-plugin-commerce",
-  "version": "0.1.18",
+  "version": "0.1.20",
   "description": "Base44 Commerce plugin — entities, backend functions, shared commerce engine, admin UI and the commerce skill, shipped as copyable source",
   "keywords": [
     "base44",

package/skills/commerce/docs/api-admin.md

@@ -16,7 +16,8 @@ Two access styles. **Reads are direct** entity SDK calls; **mutations with side
 | commerce.ProductReview | direct | **`commerce/admin-reviews`** | rating recalculation |
 | commerce.ProductCategory, commerce.ProductRibbon | direct | **direct CRUD**, or `commerce/admin-products` `save-term`/`delete-term`/`list-terms` (the API/agent path) | category slug uniqueness; ribbon get-or-create by name |
 | commerce.ProductAttribute, commerce.ProductAttributeTerm | direct | **direct CRUD**, or `commerce/admin-products` `save-term`/`delete-term`/`list-terms` (the API/agent path) | attribute `code` uniqueness; value rename rewrites products; attribute delete cascades its values |
-| commerce.ShippingTaxLocation, commerce.PaymentGateway | direct | **direct CRUD** | config; consumed by the pricing engine at read time |
+| commerce.ShippingTaxLocation | direct | **direct CRUD** | config; consumed by the pricing engine at read time |
+| commerce.PaymentGateway | direct | **`commerce/seed-store`** `payment_methods` to switch methods on/off; **direct CRUD** to change a record (add or rename a manual option, its `description`, bank accounts, `order`) | one seed call converges every gateway row to the given set, so "enable cards", "card-only" and "offline-only" are one idempotent call; the record's own fields are ordinary config — the admin's Settings → Payments screen edits them directly |
 | commerce.StoreSettings | direct | **direct CRUD** (one record per `group_id`) | grouped config |
 | commerce.Webhook | direct | **direct CRUD** (+ `commerce/admin-webhooks` for test/redeliver) | definition is data; dispatch is engine |
 | commerce.WebhookDelivery, commerce.EmailLog | direct (read-only logs) | written by the engine | audit logs |

package/skills/commerce/docs/api-storefront.md

@@ -89,6 +89,20 @@ Each row is the product record (minus paywalled fields) **plus a resolved `ribbo
 
 **Filters stack.** `category_id`, `ribbon_id`, `attribute_id` + `attribute_term`, `min_price`/`max_price`, `on_sale`, `featured` and `in_stock_only` are ANDed, so "Dresses + gift + on sale" is one request. Build the controls from [`list-categories`](#list-categories), [`list-ribbons`](#list-ribbons) (its `count` gives you "Gift (12)") and [`list-attributes`](#list-attributes), and mirror active filters into the URL so a filtered listing is shareable and survives reload.
 
+**The same call also serves a short strip anywhere else** — a homepage hero or banner, a "featured" row, a "new in" rail, related picks beside an article. `per_page` bounds the result and the filters/sort choose what lands in it, so a small curated slice is one request; there is no separate endpoint, and no reason to fetch a big page and slice it client-side. Available if a page wants one:
+
+```js
+const inv = (fn, payload) => base44.functions.invoke(fn, payload).then(r => r.data.data);
+const cat = (payload) => inv("commerce/storefront-catalog", { action: "list-products", ...payload });
+
+const { products: featured } = await cat({ featured: true, per_page: 4 });
+const { products: newest }   = await cat({ sort: "-created_date", per_page: 6 });
+const { products: deals }    = await cat({ on_sale: true, in_stock_only: true, per_page: 4 });
+const { products: topInCat } = await cat({ category_id, sort: "popularity", per_page: 4 });
+```
+
+`featured` is the admin's own per-product flag (the star in the products list, *Featured product* in the editor's Publish box; `commerce/seed-store` accepts `featured: true` per product), so a featured strip is curated store data rather than slugs pinned in the UI. Rows are the ordinary listing rows — same fields a grid card renders ([`../references/product-render.md`](../references/product-render.md)). **A filter may legitimately match nothing** (no product starred, nothing discounted), so drive the block off the returned array's length — hide it or fall back to another slice — instead of assuming rows came back; `has_next` tells you whether a "see all" link has more behind it.
+
 ### `get-product`
 **Payload:** `{ id }` **or** `{ slug }`; optional `reviews_page` (1), `reviews_per_page` (10, max 50).
 

package/skills/commerce/post-installation.md

@@ -64,17 +64,35 @@ Even if the client guard were bypassed, layers 2 and 3 keep the store data safe.
 
 No visitor UI ships — and no visual component ships either: **every pixel of the shopfront stays yours to design**. What ships is the logic: the storefront **API**, the framework-free helpers in `@/commerce/utils`, and the React layer in `@/commerce/storefront` — hooks and headless pickers owning the contracts every store must get right. The catalog views (§2.1–2.2) are deliberately the thinnest, because that is where storefronts differ most; the cart and checkout (§2.3–2.4) are more guided, because shipping recalculation, payment methods and the place-order gate work the same in every store. **None of it waits on anything**: every shape you build against is documented right here, so seeding (§3) runs in parallel with building these pages (§0 has the schedule) — kick off image generation, write the storefront while it renders, seed when the URLs are back. Live data is only needed once, to see real products on the finished pages. **Payments are not a prerequisite for any of this** — the whole buy path down to `place-order` is built and reviewable before a provider exists (a card gateway with no provider simply answers `503 no_card_payment_provider`, and §2.4 shows the graceful fallback), which is why the payment decision comes after these pages work, not before (§4). The four chunks below are the whole happy path; open [`docs/api-storefront.md`](./docs/api-storefront.md) only for what's beyond them (attribute/price filters, reviews, customer accounts, refunds), and [`references/product-render.md`](./references/product-render.md) for which fields belong in which view.
 
-**Set up once** — mount the provider above every storefront route. It owns the shared API client, the store-info cache and ONE shared cart, so a header badge, a cart drawer and the checkout all render the same state:
+**Set up once** — mount the provider **around `<Routes>`**, so it sits above every storefront route. It owns the shared API client, the store-info cache and ONE shared cart, so a header badge, a cart drawer and the checkout all render the same state:
 
 ```jsx
 import { StorefrontProvider } from "@/commerce/storefront";
 import { base44 } from "@/api/base44Client";
-
-<StorefrontProvider base44={base44}>
-  {/* storefront routes */}
-</StorefrontProvider>
+import AdminApp from "@/commerce/admin";
+
+<BrowserRouter>                             {/* the app's existing router, wherever it lives */}
+  <StorefrontProvider base44={base44}>      {/* wraps the router's <Routes>, not a child of it */}
+    <Routes>                                {/* ONE <Routes> — merge storefront routes into the app's */}
+      <Route path="/" element={<Home />} />
+      <Route path="/product/:slug" element={<ProductPage />} />
+      <Route path="/checkout" element={<Checkout />} />
+      <Route path="/order-received" element={<OrderReceived />} />
+      <Route path="/store-admin/*" element={<AdminApp />} />
+    </Routes>
+  </StorefrontProvider>
+</BrowserRouter>
 ```
 
+> ⚠ **`<Routes>` accepts only `<Route>` children — the provider goes outside it.** Nesting it inside (the natural reading of "wrap the storefront routes", and the usual mistake) throws at render: `Error: [StorefrontProvider] is not a <Route> component. All component children of <Routes> must be a <Route> or <React.Fragment>`. Wrapping the whole `<Routes>` as above is the simplest correct shape and fine even with the admin route inside — the admin doesn't use the storefront hooks. Same rule per file: an app that already has a `<Routes>` gets the new pages **added to it**, never a second `<Routes>` block. To scope the provider to storefront routes only, use a pathless **layout route** — the one place a wrapper component is legal — and render `<Outlet />` inside it:
+> ```jsx
+> <Route element={<StorefrontProvider base44={base44}><Outlet /></StorefrontProvider>}>
+>   <Route path="/" element={<Home />} />          {/* these share one cart */}
+>   <Route path="/checkout" element={<Checkout />} />
+> </Route>
+> <Route path="/store-admin/*" element={<AdminApp />} />   {/* outside the provider */}
+> ```
+
 The provider owns the two things hand-rolled storefronts keep getting wrong, so **don't reimplement either — and never mount a second provider or create a second client**: the **`cart_token` lifecycle** (sent with every cart/checkout call, re-persisted from every response — a stale token silently starts a fresh cart; rolling 48 h expiry; cleared when checkout consumes the cart) and the **store-info cache** (`payment_gateways`, currency, countries live **only** on `get-store-info` — the cart view never carries them). Inside the tree, `useStorefront()` returns the shared client for catalog calls, and `store.inv(fn, payload)` on it is the raw escape hatch (it unwraps the `{ success, data }` envelope). If non-React code also needs the client, create it once in `src/lib/storefront.js` (`createStorefront(base44)` from `@/commerce/utils`) and pass that same instance via `<StorefrontProvider store={store}>`.
 
 **What each hook / client method resolves to** — every envelope is already unwrapped, so take these shapes at face value (no `.data`, and no `.categories` on a list result):
@@ -111,6 +129,19 @@ const { products, page, per_page, has_next } = await store.listProducts({
 
 Each row is a full product record — for a card use `name`, `images[0]?.src` (**may be empty — render a placeholder, never a broken `<img>`**), `price`, `regular_price`, `on_sale` (sale badge), `short_description`, `stock_status`, `average_rating`/`rating_count` (stars cost no extra call) and `ribbons` (`[{ id, name }]`, may be absent — labels like "Best Seller" for the card corner). **There is no product type flag**: `product.attributes?.length > 0` means the product sells variants and its `price` is a *from*-price rolled up from the cheapest variant — render it as "From …". Categories for the nav come from `store.listCategories()` — an **array** of root categories with subcategories nested under `children` (map over it directly; there is no `{ categories }` wrapper on the result). That is the whole card — no other call or reference needed for the list view.
 
+**A short strip of products is the same call with a small `per_page`.** Products are not confined to the grid — a homepage hero or banner, a "featured" row, a "new in" rail, a few picks beside an article are all one `listProducts` call: `per_page` bounds how many come back and the filters/sort decide which ones. No separate endpoint, and never fetch a big page to slice client-side. Use this if a page of yours wants such a strip; the catalog pages above are complete without one:
+
+```js
+const { products: featured } = await store.listProducts({ featured: true, per_page: 4 });
+const { products: newest }   = await store.listProducts({ sort: "-created_date", per_page: 6 });
+const { products: deals }    = await store.listProducts({ on_sale: true, per_page: 4 });
+const { products: topInCat } = await store.listProducts({ category_id, sort: "popularity", per_page: 4 });
+// filters stack (featured + category_id + in_stock_only …); sort: -created_date | name |
+//   price | -price | popularity | rating. Rows are the same shape the cards above render.
+```
+
+`featured` is the merchant's own flag — the star in the admin's product list and *Featured product* in the editor's Publish box — and `seed-store` accepts `featured: true` per product, so such a row stays curated store data instead of a hardcoded list of slugs. **Any filter can legitimately match nothing** (nobody has starred a product, nothing is discounted): render the block from the returned array's length — hide it, or fall back to another slice — rather than assuming rows came back.
+
 **Carry forward:** each card links to the product page by **`slug`**.
 
 ### 2.2 Product page — variant selection included
@@ -189,7 +220,7 @@ Shipping cost on the cart page: a store with exactly **one shipping location** s
 
 - **address form state** (`billing`/`updateBilling`, an optional separate `shipping`/`updateShipping` behind `setShipToDifferent`), with `missingBillingFields` tracking what `place-order` would reject;
 - **automatic shipping/tax recalculation**: the moment the address is complete enough to price (default: country + city), the hook debounces and calls `set-shipping-address`, repricing every shipping option, its cost and the taxes — half-typed addresses are never sent, an unchanged address is never re-sent, and an address the store doesn't ship to surfaces as `addressError` to show **on the address fields**;
-- **the shipping choice** (`shippingStatus`, `shippingMethods`, `chosenShippingMethod`, `chooseShippingMethod`) and **the payment choice** (`paymentMethods` from store info — their only source; a store with exactly one enabled gateway gets it pre-selected);
+- **the shipping choice** (`shippingStatus`, `shippingMethods`, `chosenShippingMethod`, `chooseShippingMethod`) and **the payment choice** (`paymentMethods` from store info — their only source); on both, **a single option is a selected option** — one shipping rate arrives already applied as `chosenShippingMethod`, one enabled gateway is `selectedGateway` from the first render that has store info, and both re-resolve when the data changes (`singleShippingMethod` / `singlePaymentMethod` flag the case);
 - **the gate**: `canPlaceOrder` + named `blockers`, and `placeOrder` with the online-payment redirect handled.
 
 Share one instance across the page's components with `CheckoutProvider` and build each step as your own markup:
@@ -233,16 +264,17 @@ const { billing, updateBilling, missingBillingFields,
 The two store-data choices — **never hardcode either** — come pre-branched through the headless pickers (they render nothing themselves; the render prop is the whole UI):
 
 ```jsx
-<ShippingMethodPicker>{({ status, methods, chosen, choose, mustChoose, syncing }) => (
+<ShippingMethodPicker>{({ status, methods, chosen, choose, mustChoose, single, syncing }) => (
   // renders null for you on virtual carts (status "not_needed")
   // status "missing_address" → say options appear once the address is entered
   // mustChoose → render methods [{ id, title, cost }] as a picker → choose(m.id)
+  // single     → already selected; skip the picker, still show chosen.title + cost
   // otherwise  → display chosen.title + chosen.cost (never a raw id); dim while syncing
 )}</ShippingMethodPicker>
 
 <PaymentMethodPicker>{({ gateways, value, select, selected, single }) => (
   // several → picker labeled with the admin's title/description → select(g.slug)
-  // single  → pre-selected; skip the picker but still show selected.title
+  // single  → already selected; skip the picker but still show selected.title
   // none    → checkout cannot complete — say so instead of rendering a dead button
 )}</PaymentMethodPicker>
 ```
@@ -422,7 +454,7 @@ Decide from what the user actually asked for:
 
 Whichever row applies, **say where payments landed** in your summary to the user — including "offline only, cards off". A store's owner should never discover their payment configuration from a customer who couldn't pay.
 
-Changing the answer later is one more seed call, not surgery: `commerce/seed-store` with just `{ payment_methods: [...] }` is idempotent (no catalog needed — products are skipped) and converges **every** gateway row to that set, so an offline-only store can add cards, or go card-only, at any point. Never edit `commerce.PaymentGateway` records yourself.
+Changing the answer later is one more seed call, not surgery: `commerce/seed-store` with just `{ payment_methods: [...] }` is idempotent (no catalog needed — products are skipped) and converges **every** gateway row to that set, so an offline-only store can add cards, or go card-only, at any point. That call is the on/off switch; editing a `commerce.PaymentGateway` record directly is for the record's own fields (a new or renamed manual option, its description, bank accounts, ordering).
 
 ### 4.2 Wiring a provider — one file
 
@@ -440,7 +472,9 @@ Four steps, whichever provider it is:
 1. **Implement the four functions** in `base44/shared/commerce/card-payment.ts` against the provider's API. **No provider ships with the template** — the file arrives as stubs, and [`references/online-payments.md`](./references/online-payments.md) holds the per-provider rules plus a complete **Stripe** implementation to paste if Stripe is the provider the store chose. Write the file **whole, in one write. Never `find_replace` into the stubs**: a partial patch leaves the originals behind and breaks every commerce function's deploy with duplicate-export bundle errors (`Multiple exports with the same name "createCardPayment"` → rewrite the file whole).
 2. **Store the provider's API credential as a backend app secret** (read with `Deno.env.get(...)` — never in code, never in an entity). Test credentials work end to end. This is the only step that needs the user, so it sets the timing of the whole section (§4.1): ask when the store is standing, not in the install's first message — and if the answer takes a while, keep the rest of the work moving rather than idling on it.
 3. **Register the premade webhook URL** — `https://<app-domain>/functions/commerce/payment-webhook` — with the provider, for its "payment succeeded" event, so orders are confirmed even when the buyer pays and closes the tab. There is **no signing secret to store**: events are treated as nudges and verified against the provider's API. (Per-provider registration calls are in the reference; the user can also do it in the provider's dashboard.)
-4. **Enable the gateway** — the `card` row is seeded **off** (§4.1), so the file alone changes nothing a customer sees. Call `commerce/seed-store` with `{ payment_methods: ["offline", "card"] }` (or `["card"]` for card-only) — safe on a seeded store: no catalog needed, products are skipped, and it converges every gateway row to that set. Skipping this step is the usual reason a freshly wired provider "doesn't show up at checkout"; doing it *without* steps 1–2 is what produces `503 no_card_payment_provider`.
+4. **Enable the gateway** — the `card` row is seeded **off** (§4.1), so the file alone changes nothing a customer sees. **Turning a method on or off is the seed call:** `commerce/seed-store` with `{ payment_methods: ["offline", "card"] }` (or `["card"]` for card-only) — safe on a seeded store (no catalog needed, products are skipped), idempotent, and it converges every gateway row to that set, so the same call also goes card-only or switches cards back off later. Reach for direct CRUD on `commerce.PaymentGateway` when the **record itself** needs changing — adding a new manual option, renaming one, editing its description or bank accounts, reordering them — which is what the admin's Settings → Payments screen does.
+
+   Skipping this step is the usual reason a freshly wired provider "doesn't show up at checkout"; doing it *without* steps 1–2 is what produces `503 no_card_payment_provider`.
 
 That's it — checkout redirect, `/order-received` confirmation, the webhook, the admin's "Check payment" button, payment links and provider refunds all run through this one file.
 
@@ -454,7 +488,7 @@ Post-installation is complete when every line below holds. **Do not validate the
 - [ ] `commerce/seed-store` ran once and reported the catalog — real products, final image URLs; `payment_methods` passed only if the store's methods differ from the default (offline on, cards off).
 - [ ] **Catalog pages and a checkout exist** — the catalog UI in whatever form fits the store (a product list, product pages, or both — one can be enough), a cart step only if the store wants one (§2.3), and the checkout built on `useCheckout` with `/order-received` rendering `useOrderReturn` (§2.4).
 - [ ] **Every coupon the store has can actually be redeemed** — if `coupons` was seeded (or the operator has codes), a code field with `applyCoupon` exists in the cart or the checkout, showing `discount_total` and rendering invalid codes inline (§2.3/§2.4). No field → don't seed coupons and don't mention codes in the copy.
-- [ ] **One `<StorefrontProvider>`** above every storefront route — no second client, no hand-rolled `cart_token` handling, payment gateways read from `useStoreInfo()` only (never off a cart), and cart state everywhere through `useCart()`.
+- [ ] **One `<StorefrontProvider>`** above every storefront route — wrapping `<Routes>` (or a layout route's `<Outlet />`), never placed as a child of `<Routes>`, which React Router rejects (§2) — no second client, no hand-rolled `cart_token` handling, payment gateways read from `useStoreInfo()` only (never off a cart), and cart state everywhere through `useCart()`.
 - [ ] **Cards are either off, or on with a provider behind them** (§4.1) — the default (offline enabled, `card` off) is a complete state and needs nothing. If you enabled cards, the provider must be wired: `card-payment.ts` written whole, secret stored, webhook registered. Enabled without a wired provider means `503 no_card_payment_provider` at checkout; wired without enabling means customers never see the option. Say where payments landed when you hand over.
 
 ## 6. Next

package/src/commerce/storefront/StorefrontProvider.jsx

@@ -13,10 +13,14 @@ import { createStorefront, storefrontErrorCode, storefrontErrorMessage } from "@
  * 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):
+ * cart, checkout, order-received) — it wraps <Routes>, it is NOT a <Route>:
  *
  *   import { base44 } from "@/api/base44Client";
- *   <StorefrontProvider base44={base44}> ... </StorefrontProvider>
+ *   <StorefrontProvider base44={base44}> <Routes>…</Routes> </StorefrontProvider>
+ *
+ * Inside <Routes> it throws ("is not a <Route> component"), since React Router
+ * allows only <Route>/<Fragment> children there. To cover just some routes,
+ * use a pathless layout route: element={<StorefrontProvider …><Outlet/></…>}.
  *
  * or, if other modules also need the raw client, create it once and share it:
  *
@@ -102,7 +106,7 @@ export function useStorefrontState() {
   const ctx = useContext(StorefrontContext);
   if (!ctx) {
     throw new Error(
-      "Storefront hooks need a <StorefrontProvider> above them — mount it once around your storefront routes.",
+      "Storefront hooks need a <StorefrontProvider> above them — mount it once around your <Routes> (it wraps the router; it is not a <Route>, and inside <Routes> React Router rejects it).",
     );
   }
   return ctx;

package/src/commerce/storefront/index.js

@@ -6,7 +6,8 @@
  * every pixel stays yours. The hooks own the contracts that are easy to get
  * subtly wrong; you own the markup.
  *
- * Setup (once, above every storefront route):
+ * Setup (once, above every storefront route — it wraps <Routes>; placed as a
+ * child of <Routes> React Router throws "is not a <Route> component"):
  *
  *   import { StorefrontProvider } from "@/commerce/storefront";
  *   import { base44 } from "@/api/base44Client";

package/src/commerce/storefront/pickers.jsx

@@ -27,15 +27,19 @@ function resolveCheckout(name, prop, ctx) {
  *     status,        // "missing_address" | "choice_required" | "chosen" | "auto_selected"
  *     methods,       // [{ id, title, cost }] — what this address is offered
  *     chosen,        // the chosen/auto-selected entry (title + cost), or null
+ *     selected,      // alias of `chosen` — the same name the payment picker uses
  *     choose,        // (id) => Promise — call with a method's id on pick
  *     mustChoose,    // status === "choice_required" → render methods as a picker
+ *     single,        // exactly one method offered — already chosen; skip the
+ *                    //   picker but still show `chosen.title` and its cost
  *     syncing,       // an address edit is being repriced — show a subtle busy state
  *     addressError,  // { code, message } | null — "we don't ship there" belongs
  *   }                //   on the address fields
  *
  * Render rules the child should follow: `missing_address` → say the options
  * appear once the address is entered; `mustChoose` → a picker of `methods`;
- * otherwise display `chosen.title` + its cost (never the raw id).
+ * otherwise display `chosen.title` + its cost (never the raw id). `single` and
+ * `mustChoose` are never both true, and `single` guarantees `chosen`.
  */
 export function ShippingMethodPicker({ checkout: checkoutProp, children }) {
   const checkout = resolveCheckout("ShippingMethodPicker", checkoutProp, useCheckoutContextOptional());
@@ -43,6 +47,7 @@ export function ShippingMethodPicker({ checkout: checkoutProp, children }) {
     shippingStatus: status,
     shippingMethods: methods,
     chosenShippingMethod: chosen,
+    singleShippingMethod: single,
     chooseShippingMethod: choose,
     shippingSyncing: syncing,
     addressError,
@@ -52,8 +57,10 @@ export function ShippingMethodPicker({ checkout: checkoutProp, children }) {
     status,
     methods,
     chosen,
+    selected: chosen,
     choose,
     mustChoose: status === "choice_required",
+    single: single ?? (methods.length === 1), // fallback: a hand-built checkout object
     syncing,
     addressError,
   });
@@ -69,22 +76,30 @@ export function ShippingMethodPicker({ checkout: checkoutProp, children }) {
  *     value,      // the selected slug ("" while none)
  *     select,     // (slug) => void
  *     selected,   // the selected gateway entry, or null
- *     single,     // exactly one gateway — pre-selected; skip the picker but
+ *     single,     // exactly one gateway — already selected; skip the picker but
  *   }             //   still show its title so the customer knows how they pay
  *
  * Render rules: several gateways → a picker labeled with the admin's
  * title/description; `single` → just display it; zero gateways → say checkout
- * is unavailable instead of rendering a dead place-order button.
+ * is unavailable instead of rendering a dead place-order button. `single`
+ * guarantees `value` and `selected` — never render the one-gateway branch as
+ * "nothing selected yet" — and both re-resolve when store info changes.
  */
 export function PaymentMethodPicker({ checkout: checkoutProp, children }) {
   const checkout = resolveCheckout("PaymentMethodPicker", checkoutProp, useCheckoutContextOptional());
-  const { paymentMethods: gateways, paymentMethod: value, setPaymentMethod: select, selectedGateway: selected } = checkout;
+  const {
+    paymentMethods: gateways,
+    paymentMethod: value,
+    setPaymentMethod: select,
+    selectedGateway: selected,
+    singlePaymentMethod: single,
+  } = checkout;
   if (!gateways) return null;
   return children({
     gateways,
     value,
     select,
     selected,
-    single: gateways.length === 1,
+    single: single ?? (gateways.length === 1), // fallback: a hand-built checkout object
   });
 }

package/src/commerce/storefront/useCheckout.jsx

@@ -21,6 +21,18 @@ const EMPTY_ADDRESS = Object.freeze({
   phone: "",
 });
 
+/**
+ * The gateway a checkout is actually paying with: the customer's pick while it
+ * is still an enabled gateway, otherwise the only gateway there is — one option
+ * is not a choice. Derived on every render from the current store info, so it
+ * follows the data instead of trailing it by an effect.
+ */
+function resolvePaymentMethod(gateways, picked) {
+  if (!gateways?.length) return "";
+  if (picked && gateways.some((g) => g.slug === picked)) return picked;
+  return gateways.length === 1 ? gateways[0].slug : "";
+}
+
 /**
  * useCheckout — the guided checkout state machine. It owns the parts every
  * checkout must get right, so the page you build is only markup around it:
@@ -38,8 +50,15 @@ const EMPTY_ADDRESS = Object.freeze({
  *   `chosenShippingMethod`), `chosen`, `choice_required` (render
  *   `shippingMethods` and call `chooseShippingMethod(id)`), `missing_address`
  *   (collect the address), `not_needed` (virtual cart — render nothing).
+ *   `singleShippingMethod` flags the one-option case, and `chosenShippingMethod`
+ *   is filled for it — a single option is never left unselected.
  * - **Payment choice.** `paymentMethods` come from store info (their ONLY
- *   source); a store with exactly one enabled gateway gets it pre-selected.
+ *   source); a store with exactly one enabled gateway gets it selected
+ *   (`singlePaymentMethod`, with `selectedGateway` filled) from the first
+ *   render that has store info. The selection is derived from the current
+ *   gateway list, not remembered: when store info changes, a gateway that is
+ *   no longer enabled is dropped and a list that is down to one gateway
+ *   selects it — the customer's own pick survives as long as it stays enabled.
  * - **The gate.** `canPlaceOrder` + `blockers` say exactly what still stands
  *   between the customer and the order — drive the button's disabled state
  *   and the "what's missing" hints from them instead of re-deriving.
@@ -70,7 +89,7 @@ export function useCheckout(options = {}) {
   const [billing, setBilling] = useState({ ...EMPTY_ADDRESS, email: "" });
   const [shipping, setShipping] = useState({ ...EMPTY_ADDRESS });
   const [shipToDifferent, setShipToDifferent] = useState(false);
-  const [paymentMethod, setPaymentMethod] = useState("");
+  const [pickedPaymentMethod, setPaymentMethod] = useState("");
   const [addressError, setAddressError] = useState(null);
   const [syncing, setSyncing] = useState(false);
   const [syncedKey, setSyncedKey] = useState(undefined);
@@ -124,24 +143,30 @@ export function useCheckout(options = {}) {
   // ── shipping choice (from the shared cart view) ──────────────────────────
   const shippingStatus = cart?.shipping_status ?? null;
   const shippingMethods = cart?.available_shipping_methods ?? [];
+  const singleShippingMethod = shippingMethods.length === 1;
+  // The backend auto-selects when it offers exactly one rate (`auto_selected`)
+  // and echoes it back on the cart, so the lookup normally finds it. The
+  // fallback covers the seam where a freshly repriced address offers one rate
+  // the cart's stored id hasn't caught up with: a single option is selected,
+  // and must read as selected, from the moment it is offered.
   const chosenShippingMethod =
-    shippingMethods.find((m) => m.id === cart?.chosen_shipping_method) ?? null;
+    shippingMethods.find((m) => m.id === cart?.chosen_shipping_method) ??
+    (singleShippingMethod ? shippingMethods[0] : null);
   const chooseShippingMethod = useCallback(
     (methodId) => runCart(() => client.chooseShippingMethod(methodId)),
     [client, runCart],
   );
 
   // ── payment choice (gateways live on store info ONLY) ────────────────────
+  // The pick is state; the *method* is derived, so a lone gateway is selected
+  // on the very first render that has store info (never a frame of "nothing
+  // selected", never a wasted effect pass) and every one of these re-resolves
+  // the moment the gateway list changes — a gateway the admin just disabled
+  // drops out, and if that leaves exactly one, it takes over immediately.
   const paymentMethods = info?.payment_gateways ?? null;
-  useEffect(() => {
-    if (!paymentMethods) return;
-    if (paymentMethod && !paymentMethods.some((g) => g.slug === paymentMethod)) {
-      setPaymentMethod("");
-    } else if (!paymentMethod && paymentMethods.length === 1) {
-      setPaymentMethod(paymentMethods[0].slug); // one option is not a choice
-    }
-  }, [paymentMethods, paymentMethod]);
+  const paymentMethod = resolvePaymentMethod(paymentMethods, pickedPaymentMethod);
   const selectedGateway = paymentMethods?.find((g) => g.slug === paymentMethod) ?? null;
+  const singlePaymentMethod = paymentMethods?.length === 1;
 
   // ── the gate ─────────────────────────────────────────────────────────────
   const missingBilling = missingBillingFields(billing, requiredBillingFields);
@@ -220,12 +245,14 @@ export function useCheckout(options = {}) {
     shippingStatus,
     shippingMethods,
     chosenShippingMethod,
+    singleShippingMethod,
     chooseShippingMethod,
     // payment choice
     paymentMethods,
     paymentMethod,
     setPaymentMethod,
     selectedGateway,
+    singlePaymentMethod,
     // the gate + the order
     blockers,
     canPlaceOrder,