@base44/app-plugin-commerce 0.1.6 → 0.1.7

package/base44/functions/commerce/admin-reports/entry.ts

@@ -1,11 +1,11 @@
 /**
  * commerce/admin-reports — on-demand report aggregation over orders.
  * Fine to ~10k orders; larger stores should materialize stats
- * (see skills/commerce/references/limits-and-performance.md).
+ * (see .agents/skills/commerce/references/limits-and-performance.md).
  *
  * Actions: summary | sales | top-sellers | stock |
  * orders-totals | products-totals | customers-totals | coupons-totals |
- * reviews-totals | categories-totals | tags-totals | attributes-totals
+ * reviews-totals | categories-totals | ribbons-totals | attributes-totals
  */
 import { createClientFromRequest } from "npm:@base44/sdk";
 import { HttpError, requireAdmin } from "../../../shared/commerce/auth.ts";
@@ -35,7 +35,7 @@ Deno.serve(async (req) => {
       case "coupons-totals": return ok(await groupCount(sr.entities["commerce.Coupon"], "discount_type"));
       case "reviews-totals": return ok(await groupCount(sr.entities["commerce.ProductReview"], "status"));
       case "categories-totals": return ok(await termTotals(sr.entities["commerce.ProductCategory"]));
-      case "tags-totals": return ok(await termTotals(sr.entities["commerce.ProductTag"]));
+      case "ribbons-totals": return ok(await termTotals(sr.entities["commerce.ProductRibbon"]));
       case "attributes-totals": return ok(await attributesTotals(sr));
       default:
         return fail(400, `Unknown action: ${action}`, "unknown_action");

package/base44/functions/commerce/admin-tools/entry.ts

@@ -1,7 +1,7 @@
 /**
  * commerce/admin-tools — maintenance and diagnostics (mini "system status").
  *
- * Actions: status | payment-connector-status | admin-email-recipients |
+ * Actions: status | admin-email-recipients |
  * recount-terms | recount-coupon-usage | recalculate-customer-stats-all |
  * prune-webhook-deliveries | clear-abandoned-carts |
  * regenerate-download-permissions
@@ -10,7 +10,6 @@ import { createClientFromRequest } from "npm:@base44/sdk";
 import { HttpError, requireAdmin } from "../../../shared/commerce/auth.ts";
 import { getSettings } from "../../../shared/commerce/settings.ts";
 import { adminUserEmails } from "../../../shared/commerce/emails.ts";
-import { onlinePaymentStatus } from "../../../shared/commerce/payments.ts";
 import { round2 } from "../../../shared/commerce/money.ts";
 import { grantDownloadPermissions, revokeDownloadPermissions } from "../../../shared/commerce/orders.ts";
 import { scanAll } from "../../../shared/commerce/scan.ts";
@@ -28,7 +27,6 @@ Deno.serve(async (req) => {
 
     switch (action) {
       case "status": return ok(await status(sr));
-      case "payment-connector-status": return ok(await paymentConnectorStatus(sr, payload));
       case "admin-email-recipients": return ok(await adminEmailRecipients(sr));
       case "recount-terms": return ok(await recountTerms(sr));
       case "recount-coupon-usage": return ok(await recountCouponUsage(sr));
@@ -70,34 +68,12 @@ async function adminEmailRecipients(
   };
 }
 
-/**
- * Is a gateway's Base44 connector actually connected?
- *
- * The admin UI calls this instead of hardcoding a "not wired" notice, so the
- * warning disappears on its own once the connector is connected. Connectors are
- * service-role only, which is why this needs a round trip rather than a client
- * check. Any failure (SDK without `connectors`, connector never set up) is
- * reported as `connected: false` — the conservative answer.
- */
-/**
- * Is an online payment provider usable right now? Delegates to the payment
- * utility, so this answers for whichever provider is wired — the admin UI shows
- * "no payment provider connected" rather than naming one.
- */
-async function paymentConnectorStatus(sr: any, _payload: any): Promise<any> {
-  const status = await onlinePaymentStatus(sr);
-  return {
-    ...status,
-    connector: status.provider, // kept for callers written against the old shape
-  };
-}
-
 /** Entity counts (capped at 1000 — shown as "1000+"), settings sanity, seeded flag. */
 async function status(sr: any): Promise<any> {
   const entities = [
-    "commerce.Product", "commerce.ProductVariation", "commerce.ProductCategory", "commerce.ProductTag", "commerce.ProductAttribute",
+    "commerce.Product", "commerce.ProductVariation", "commerce.ProductCategory", "commerce.ProductRibbon", "commerce.ProductAttribute",
     "commerce.Order", "commerce.OrderRefund", "commerce.Coupon", "commerce.Customer", "commerce.ProductReview",
-    "commerce.TaxRate", "commerce.ShippingZone", "commerce.PaymentGateway", "commerce.Webhook", "commerce.Cart",
+    "commerce.ShippingTaxLocation", "commerce.PaymentGateway", "commerce.Webhook", "commerce.Cart",
   ];
   const counts: Record<string, string | number> = {};
   for (const name of entities) {
@@ -119,23 +95,21 @@ async function status(sr: any): Promise<any> {
       // counts is keyed by the namespaced entity name — `counts.PaymentGateway`
       // is undefined, which silently reported both checks as false.
       has_payment_gateways: (counts["commerce.PaymentGateway"] as number) > 0,
-      has_default_zone: (counts["commerce.ShippingZone"] as number) > 0,
+      has_default_location: (counts["commerce.ShippingTaxLocation"] as number) > 0,
     },
   };
 }
 
-/** Rebuild category/tag/shipping-class/attribute-term `count` fields from products. */
+/** Rebuild category/ribbon/attribute-term `count` fields from products. */
 async function recountTerms(sr: any): Promise<any> {
   const products = await scanAll(sr.entities["commerce.Product"]);
   const catCounts: Record<string, number> = {};
-  const tagCounts: Record<string, number> = {};
-  const classCounts: Record<string, number> = {};
+  const ribbonCounts: Record<string, number> = {};
   const termCounts: Record<string, number> = {}; // `${attribute_id}::${option}`
 
   for (const p of products) {
     for (const c of p.category_ids ?? []) catCounts[c] = (catCounts[c] ?? 0) + 1;
-    for (const t of p.tag_ids ?? []) tagCounts[t] = (tagCounts[t] ?? 0) + 1;
-    if (p.shipping_class_id) classCounts[p.shipping_class_id] = (classCounts[p.shipping_class_id] ?? 0) + 1;
+    for (const t of p.ribbon_ids ?? []) ribbonCounts[t] = (ribbonCounts[t] ?? 0) + 1;
     for (const a of p.attributes ?? []) {
       if (!a.attribute_id) continue;
       for (const opt of a.options ?? []) {
@@ -158,8 +132,7 @@ async function recountTerms(sr: any): Promise<any> {
   };
 
   const categories = await updateCounts("commerce.ProductCategory", catCounts);
-  const tags = await updateCounts("commerce.ProductTag", tagCounts);
-  const classes = await updateCounts("commerce.ShippingClass", classCounts);
+  const ribbons = await updateCounts("commerce.ProductRibbon", ribbonCounts);
 
   let terms = 0;
   for (const term of await scanAll(sr.entities["commerce.ProductAttributeTerm"])) {
@@ -169,7 +142,7 @@ async function recountTerms(sr: any): Promise<any> {
       terms++;
     }
   }
-  return { updated: { categories, tags, shipping_classes: classes, attribute_terms: terms } };
+  return { updated: { categories, ribbons, attribute_terms: terms } };
 }
 
 /** Rebuild coupon usage_count/used_by from orders where usage was counted. */

package/base44/functions/commerce/payment-webhook/entry.ts

@@ -1,131 +1,92 @@
 /**
- * commerce/payment-webhook — the payment provider's server-to-server callback.
+ * commerce/payment-webhook — file 2 of 2 to implement when wiring a payment
+ * provider. File 1 is `base44/shared/commerce/card-payment.ts`.
  *
- * The second of the two confirmation paths (the first is the customer returning
- * to the storefront, which calls `commerce/payments` `verify`). This one covers
- * the buyer who pays and closes the tab. Both are idempotent, so whichever
- * arrives second does nothing.
+ * This is the provider's server-to-server callback — the confirmation path
+ * that covers the buyer who pays and closes the tab (the other path is the
+ * customer returning to the storefront, which calls `commerce/payments`
+ * `complete-return`; both are idempotent, whichever arrives second does
+ * nothing).
  *
- * Unlike every other function here this takes the provider's **raw body** rather
- * than an `{action, ...}` envelope, because the signature is computed over those
- * exact bytes.
+ * Implement ONLY `parseWebhook` below. Everything after it is premade: the
+ * order lookup, the order_key check, the idempotent confirmation and the
+ * order progression (stock, emails, download permissions, store webhooks).
  *
- * **Trust model — the payload is never believed on its own.** Two paths:
+ * Unlike every other function here this takes the provider's **raw body**
+ * rather than an `{action, ...}` envelope, because webhook signatures are
+ * computed over those exact bytes.
  *
- * 1. **A signing secret is configured** (`PAYMENT_WEBHOOK_SECRET`, or
- *    `STRIPE_WEBHOOK_SECRET`): the signature is verified here and the event's
- *    "paid" is then trusted directly — one fewer round trip.
- * 2. **No secret available** — which is the case on Base44, where a function's
- *    environment is fixed (`BASE44_APP_ID`, `STRIPE_PUBLISHABLE_KEY`,
- *    `STRIPE_SECRET_KEY`) and apps cannot add their own: the body is treated as
- *    nothing more than a *nudge naming an order*. Whether money arrived is then
- *    asked of the provider directly, over our own authenticated API call.
- *
- * Either way the event must carry a matching `order_key`, and any session it
- * names is checked to have been opened for that order — so a real payment for
- * one order can't be pointed at another, and a forged webhook achieves nothing
- * beyond making us re-check an order.
- *
- * So this endpoint is useful with or without a secret, and safe either way.
- *
- * Setup: register this function's URL with the provider (Stripe: events
- * `checkout.session.completed`, `payment_intent.succeeded`). On the hosted Base44
- * platform, also configure the app's Stripe webhook secret in the app settings —
- * verified behavior: a request carrying a `stripe-signature` header is rejected
- * by the platform *before* any function runs unless that is set.
- *
- * Provider specifics (signature scheme, event shapes) live in
- * shared/commerce/payments.ts and its adapter — nothing here is Stripe-only.
+ * Until implemented, every request answers 400 `webhook_not_implemented`.
  */
 import { createClientFromRequest } from "npm:@base44/sdk";
 import { getSettings } from "../../../shared/commerce/settings.ts";
-import {
-  confirmOnlinePayment,
-  parsePaymentWebhook,
-  verifyPaymentWebhook,
-} from "../../../shared/commerce/payments.ts";
+import { confirmCardPayment } from "../../../shared/commerce/payments.ts";
 
 /** Providers retry on non-2xx; answer 200 for anything we deliberately ignore. */
 const ok = (data: unknown, status = 200) => Response.json({ success: true, data }, { status });
 const fail = (status: number, error: string, code: string) =>
   Response.json({ success: false, error, code }, { status });
 
-function webhookSecret(): string {
-  try {
-    return String(
-      Deno.env.get("PAYMENT_WEBHOOK_SECRET") ?? Deno.env.get("STRIPE_WEBHOOK_SECRET") ?? "",
-    );
-  } catch {
-    return ""; // no env access → unsigned path (the payload is not trusted)
-  }
+interface CardWebhookEvent {
+  /** The order the event is about — read it from the event's metadata. */
+  order_id: string;
+  /** Must match the order's key; attach both to the payment when creating it. */
+  order_key: string;
+  /**
+   * Set true ONLY when you verified the request signature AND the event says
+   * the payment succeeded. When false, the event is treated as a nudge naming
+   * an order, and whether money arrived is asked of the provider through
+   * `checkCardPaymentPaid` — useful when no signing secret is available.
+   */
+  paid: boolean;
+  /** The provider's payment id, if the event carries one. */
+  reference?: string;
+}
+
+/**
+ * ← IMPLEMENT THIS for your provider: verify the signature (over the raw
+ * `payload` bytes) and pull out the order reference. Return null for events
+ * that aren't about a payment for one of this store's orders.
+ */
+async function parseWebhook(_req: Request, _payload: string): Promise<CardWebhookEvent | null> {
+  return null;
 }
 
 Deno.serve(async (req: Request) => {
   try {
     const payload = await req.text();
-    const header = req.headers.get("stripe-signature") ?? req.headers.get("x-payment-signature") ?? "";
-    const secret = webhookSecret();
 
-    // With a secret we can prove the event came from the provider and take its
-    // word. Without one we accept the request but believe nothing in it — the
-    // payment is confirmed against the provider below.
-    let signatureVerified = false;
-    if (secret) {
-      signatureVerified = await verifyPaymentWebhook({ payload, header, secret });
-      if (!signatureVerified) return fail(400, "Invalid webhook signature.", "invalid_signature");
-    }
-
-    let body: any;
-    try {
-      body = JSON.parse(payload);
-    } catch {
-      return fail(400, "Malformed webhook body.", "invalid_body");
-    }
-    const event = parsePaymentWebhook(body);
-    if (!event.order_id) return ok({ ignored: true, type: event.type, reason: "no_order_reference" });
-    // An unsigned event claiming "paid" proves nothing, but it is still worth
-    // re-checking the order it names; a signed one that doesn't claim paid isn't.
-    if (signatureVerified && !event.paid) {
-      return ok({ ignored: true, type: event.type, reason: "not_a_payment_success" });
+    const event = await parseWebhook(req, payload);
+    if (!event) {
+      return fail(400, "This store's payment webhook is not implemented.", "webhook_not_implemented");
     }
+    if (!event.order_id) return ok({ ignored: true, reason: "no_order_reference" });
 
     const base44 = createClientFromRequest(req);
     const sr = base44.asServiceRole;
 
     let order: any = null;
     try { order = await sr.entities["commerce.Order"].get(event.order_id); } catch { order = null; }
-    // Required, not merely checked when offered: every session we open carries one.
+    // order_key is required, not merely checked when offered — it is what stops
+    // a forged event (or a payment for a cheap order) being pointed at another.
     if (!order || !event.order_key || order.order_key !== event.order_key) {
       console.error(`commerce/payment-webhook: no matching order for ${event.order_id}`);
       return ok({ ignored: true, reason: "order_not_found" });
     }
 
     const settings = await getSettings(sr);
-    let result;
-    try {
-      result = await confirmOnlinePayment(sr, order, {
-        sessionId: event.session_id,
-        paymentReference: event.payment_reference,
-        // Only a verified signature justifies skipping the provider round trip.
-        trustedPaid: signatureVerified,
-        settings,
-        actor: "payment-webhook",
-      });
-    } catch (e) {
-      // Forged or misrouted: answer 200 so the provider stops retrying.
-      if ((e as any)?.code === "session_order_mismatch") {
-        console.error(`commerce/payment-webhook: session ${event.session_id} is not for order ${order.id}`);
-        return ok({ ignored: true, reason: "session_order_mismatch" });
-      }
-      throw e;
-    }
+    const result = await confirmCardPayment(sr, order, {
+      reference: event.reference,
+      trustedPaid: event.paid,
+      settings,
+      actor: "payment-webhook",
+    });
 
     return ok({
       order_id: order.id,
       paid: result.paid,
       already_confirmed: result.already_confirmed,
       status: result.order.status,
-      verified_signature: signatureVerified,
     });
   } catch (e) {
     // 500 makes the provider retry, which is what we want for a transient failure.

package/base44/functions/commerce/payments/entry.ts

@@ -1,18 +1,18 @@
 /**
- * commerce/payments — online payment for an order, provider-neutral.
+ * commerce/payments — online payment for an order.
  *
- * All provider specifics live in shared/commerce/payments.ts (currently wired to
- * the Stripe adapter); this function is the API the storefront and the admin use.
+ * The provider specifics live in the two implementable files (see
+ * `.agents/skills/commerce/references/online-payments.md`); this function is
+ * the premade API the storefront and the admin use.
  *
  * Actions:
- *   status       — is an online payment provider connected? (admin)
  *   create-link  — hosted payment page for an unpaid order: the storefront's
  *                  redirect target and the admin's "payment link" (admin, or the
  *                  customer holding the order_key). Works whatever the order's
  *                  current payment method is — asking for a link is the decision
- *                  to collect online, so the order is switched onto the online
+ *                  to collect by card, so the order is switched onto the card
  *                  gateway (noted in the order log). Refused only when the store
- *                  has online payment switched off.
+ *                  has the card option switched off.
  *   complete-return — the `/order-received` flow in one call: confirm the payment,
  *                  progress the order, and return the render-ready result plus a
  *                  fresh payment link while unpaid. This is what the storefront's
@@ -23,25 +23,19 @@
  * Access: `order_id` + `order_key` authorizes the customer who owns the order
  * (the same bearer rule as commerce/storefront-account); an admin may act on any
  * order without a key. Entity access is service-role throughout.
- * Authorization is not confirmation: a `session_id` passed to verify/
- * complete-return must be one the provider opened for this order
- * (409 `session_order_mismatch`).
  */
 import { createClientFromRequest } from "npm:@base44/sdk";
 import { HttpError, getCallerUser, isAdmin } from "../../../shared/commerce/auth.ts";
 import { getSettings } from "../../../shared/commerce/settings.ts";
 import { serializeOrderForCustomer } from "../../../shared/commerce/orders.ts";
 import {
-  ACTIVE_PROVIDER,
-  confirmOnlinePayment,
-  isOnlineGateway,
+  CARD_GATEWAY_SLUG,
+  confirmCardPayment,
+  isCardGateway,
   isOrderPaid,
-  onlinePaymentStatus,
-  orderMeta,
   paymentReturnState,
   resolveReturnUrls,
-  SESSION_META_KEY,
-  startOnlinePayment,
+  startCardPayment,
 } from "../../../shared/commerce/payments.ts";
 
 function ok(data: unknown, status = 200): Response {
@@ -71,33 +65,28 @@ Deno.serve(async (req: Request) => {
     const { action, ...payload } = await req.json();
 
     switch (action) {
-      case "status": {
-        if (!admin) throw new HttpError(403, "Admin access required.", "forbidden");
-        return ok(await onlinePaymentStatus(sr));
-      }
-
       case "create-link": {
         const order = await authorizeOrder(sr, payload, admin);
         if (isOrderPaid(order)) throw new HttpError(409, "This order is already paid.", "already_paid");
 
         // Asking for a payment link *is* the decision to collect this order
-        // online, so it works whatever the order's current method is — an admin
+        // by card, so it works whatever the order's current method is — an admin
         // order starts with none at all, and switching from a manual method is a
         // normal thing to want ("just send them a card link"). The one hard
-        // requirement is that the store offers online payment: an operator who
+        // requirement is that the store offers card payment: an operator who
         // turned the card gateway off has declined it, and this must respect that.
-        const gateway = await onlineGateway(sr);
+        const gateway = await cardGateway(sr);
         if (!gateway || gateway.enabled === false) {
           throw new HttpError(
             400,
-            "Online payment is switched off for this store.",
-            "online_payments_disabled",
-            { gateway_slug: ACTIVE_PROVIDER.gatewaySlug },
+            "Card payment is switched off for this store.",
+            "card_payments_disabled",
+            { gateway_slug: CARD_GATEWAY_SLUG },
           );
         }
         // Record the switch, or the order would claim it's cash-on-delivery while
         // the customer pays by card — and refunds key off `payment_method`.
-        if (!isOnlineGateway(order.payment_method)) {
+        if (!isCardGateway(order.payment_method)) {
           const previous = order.payment_method_title || order.payment_method || "none";
           await sr.entities["commerce.Order"].update(order.id, {
             payment_method: gateway.slug,
@@ -122,7 +111,7 @@ Deno.serve(async (req: Request) => {
           returnUrl: payload.return_url,
           returnPath: settings.general?.order_received_path,
         });
-        const link = await startOnlinePayment(sr, order, {
+        const link = await startCardPayment(sr, order, {
           successUrl,
           cancelUrl,
           customerEmail: order.billing?.email || undefined,
@@ -132,7 +121,7 @@ Deno.serve(async (req: Request) => {
 
       /**
        * The whole payment-return flow in one call, for the `/order-received`
-       * page a storefront has to implement: confirm with the provider, move the
+       * page a storefront has to implement: confirm the payment, move the
        * order on if the money landed, and hand back everything the page needs to
        * render — including a fresh payment link when it is still unpaid, so
        * "Pay now" needs no second round trip.
@@ -144,18 +133,17 @@ Deno.serve(async (req: Request) => {
       case "complete-return": {
         const order = await authorizeOrder(sr, payload, admin);
         const settings = await getSettings(sr);
-        const result = await confirmOnlinePayment(sr, order, {
-          sessionId: payload.session_id || orderMeta(order, SESSION_META_KEY),
+        const result = await confirmCardPayment(sr, order, {
           settings,
           actor: admin ? (user?.email ?? "admin") : "customer-return",
         });
         const state = paymentReturnState({ paid: result.paid, outcome: payload.payment });
 
-        // Offer a way to pay again while unpaid — best-effort: an unavailable
+        // Offer a way to pay again while unpaid — best-effort: an unimplemented
         // provider or a store that switched card payment off must not break the
         // page, it just means no "Pay now" button.
-        let paymentLink: { url: string; session_id: string } | null = null;
-        if (state !== "paid" && payload.with_payment_link !== false && isOnlineGateway(result.order.payment_method)) {
+        let paymentLink: { url: string; reference: string } | null = null;
+        if (state !== "paid" && payload.with_payment_link !== false && isCardGateway(result.order.payment_method)) {
           try {
             const { successUrl, cancelUrl } = resolveReturnUrls({
               order: result.order,
@@ -165,17 +153,33 @@ Deno.serve(async (req: Request) => {
               returnUrl: payload.return_url,
               returnPath: settings.general?.order_received_path,
             });
-            const link = await startOnlinePayment(sr, result.order, {
+            paymentLink = await startCardPayment(sr, result.order, {
               successUrl,
               cancelUrl,
               customerEmail: result.order.billing?.email || undefined,
             });
-            paymentLink = { url: link.url, session_id: link.session_id };
           } catch (e) {
             console.error("complete-return: could not mint a payment link:", e);
           }
         }
 
+        // A manual order still needs its payment instructions after the
+        // customer lands back here — the place-order response that carried
+        // them is long gone, so the return page gets them again.
+        let paymentInstructions: any = null;
+        if (state !== "paid" && result.order.payment_method && !isCardGateway(result.order.payment_method)) {
+          const gw = (await sr.entities["commerce.PaymentGateway"].filter(
+            { slug: result.order.payment_method }, undefined, 1,
+          ))?.[0];
+          if (gw) {
+            paymentInstructions = {
+              type: gw.slug === "offline" ? "offline" : "manual",
+              description: gw.description ?? "",
+              account_details: gw.settings?.account_details ?? [],
+            };
+          }
+        }
+
         return ok({
           state,                                   // paid | cancelled | unpaid
           paid: result.paid,
@@ -183,14 +187,14 @@ Deno.serve(async (req: Request) => {
           status: result.order.status,
           order: admin ? result.order : serializeOrderForCustomer(result.order),
           payment_link: paymentLink,
+          payment_instructions: paymentInstructions,
         });
       }
 
       case "verify": {
         const order = await authorizeOrder(sr, payload, admin);
         const settings = await getSettings(sr);
-        const result = await confirmOnlinePayment(sr, order, {
-          sessionId: payload.session_id || orderMeta(order, SESSION_META_KEY),
+        const result = await confirmCardPayment(sr, order, {
           settings,
           actor: admin ? (user?.email ?? "admin") : "customer-return",
         });
@@ -210,10 +214,10 @@ Deno.serve(async (req: Request) => {
   }
 });
 
-/** The `commerce.PaymentGateway` record backing online payment, if any. */
-async function onlineGateway(sr: any): Promise<any | null> {
+/** The `commerce.PaymentGateway` record for the card option, if any. */
+async function cardGateway(sr: any): Promise<any | null> {
   const hits = (await sr.entities["commerce.PaymentGateway"].filter(
-    { slug: ACTIVE_PROVIDER.gatewaySlug },
+    { slug: CARD_GATEWAY_SLUG },
     undefined,
     1,
   )) ?? [];

package/base44/functions/commerce/seed-store/defaults.ts

@@ -1,7 +1,8 @@
 /**
- * commerce/seed-store default data: settings groups, payment gateways, tax classes and
- * the fallback shipping zone. All idempotent — the seeder checks for existing
- * records (by group_id / slug / name) before creating.
+ * commerce/seed-store default data: settings groups, payment gateways and the
+ * fallback Shipping & Tax Location (seeded only when the caller passes no
+ * `locations` of their own). All idempotent — the seeder checks for
+ * existing records (by group_id / slug / name) before creating.
  */
 
 /** Per-type email config keys. reset_password/new_account are handled by Base44 auth. */
@@ -9,6 +10,10 @@ const EMAIL_TYPE_DEFAULTS: Record<string, any> = {
   new_order: { enabled: true, subject: "", heading: "", recipient: "" },
   cancelled_order: { enabled: true, subject: "", heading: "", recipient: "" },
   failed_order: { enabled: true, subject: "", heading: "", recipient: "" },
+  // Stock alerts sit in the same Settings → Emails list; subject/body are
+  // generated, so only the switch and recipient override are configurable.
+  low_stock: { enabled: true, recipient: "" },
+  out_of_stock: { enabled: true, recipient: "" },
   on_hold_order: { enabled: true, subject: "", heading: "" },
   processing_order: { enabled: true, subject: "", heading: "" },
   completed_order: { enabled: true, subject: "", heading: "" },
@@ -26,21 +31,18 @@ export const SETTINGS_DEFAULTS: Array<{ group_id: string; values: Record<string,
     values: {
       // Storefront route customers return to after paying; a mismatch is a 404.
       order_received_path: "/order-received",
+      // A value, not a format — prices are rendered with Intl.NumberFormat.
       currency: "USD",
-      currency_position: "left",         // left | right | left_space | right_space
-      thousand_sep: ",",
-      decimal_sep: ".",
-      num_decimals: 2,
+      weight_unit: "kg",                 // kg | g | lbs | oz
+      dimension_unit: "cm",              // m | cm | mm | in | yd
     },
   },
   {
     group_id: "products",
     values: {
-      weight_unit: "kg",                 // kg | g | lbs | oz
-      dimension_unit: "cm",              // m | cm | mm | in | yd
-      enable_reviews: true,
-      only_verified_reviews: false,
-      review_rating_required: true,
+      // The one review switch the server enforces; every other review policy
+      // (login-gated, verified-only, required rating) belongs to the storefront
+      // UI — see .agents/skills/commerce/references/reviews.md.
       auto_approve_reviews: false,
     },
   },
@@ -49,9 +51,6 @@ export const SETTINGS_DEFAULTS: Array<{ group_id: string; values: Record<string,
     values: {
       manage_stock: true,
       hold_stock_minutes: 60,
-      notify_low_stock: true,
-      notify_out_of_stock: true,
-      notification_recipient: "",
       low_stock_threshold: 2,
       out_of_stock_threshold: 0,
       hide_out_of_stock: false,
@@ -62,7 +61,6 @@ export const SETTINGS_DEFAULTS: Array<{ group_id: string; values: Record<string,
     values: {
       prices_include_tax: false,
       tax_based_on: "shipping",          // shipping | billing
-      shipping_tax_class: "inherit",     // inherit | standard | <class slug>
       display_prices_shop: "excl",       // incl | excl
       display_prices_cart: "excl",
     },
@@ -98,39 +96,34 @@ export const GATEWAY_DEFAULTS = [
     settings: { account_details: [] as any[] },
   },
   {
-    slug: "stripe",
+    slug: "card",
     title: "Credit card",
     description: "Pay securely by credit card.",
-    // Enabled by default: online payment is how a store should take money. It is
-    // only *offered* to customers while a payment provider is connected — the
-    // storefront gateway list and the admin both check that live — so enabling it
-    // here cannot strand a shopper on an unusable option.
+    // Enabled means offered: the storefront lists every enabled gateway. Until
+    // shared/commerce/card-payment.ts is implemented, picking this at checkout
+    // answers 503 no_card_payment_provider — switch it off to hide it instead.
     enabled: true,
     order: 1,
-    method_title: "Online card payments (Stripe by default)",
-    method_description:
-      "Card payments through the connected payment provider (Stripe out of the box). Set the provider up in the app's integrations to start taking payments; customers only see this option once it is connected.",
-    settings: { connector: "stripe" },
+    method_title: "Credit card",
+    method_description: "Card payment on a provider-hosted page.",
+    settings: {},
   },
 ];
 
-export const TAX_CLASS_DEFAULTS = [
-  { slug: "standard", name: "Standard" },
-  { slug: "reduced-rate", name: "Reduced rate" },
-  { slug: "zero-rate", name: "Zero rate" },
-];
-
-export const REST_OF_WORLD_ZONE = {
+/**
+ * Fallback Shipping & Tax Location so a fresh store can sell anywhere: one
+ * free shipping rate, the default 'Products' tax group with no rates (no tax),
+ * no shipping tax. Admins refine it in Settings → Shipping & Tax.
+ */
+export const REST_OF_WORLD_LOCATION = {
   name: "Rest of the world",
   order: 999,
-  locations: [] as any[],
-};
-
-/** Example method attached to the fallback zone so admins see the pattern. */
-export const REST_OF_WORLD_EXAMPLE_METHOD = {
-  method_id: "flat_rate",
-  title: "Flat rate",
-  enabled: true,
-  order: 0,
-  settings: { cost: 0, tax_status: "taxable", class_costs: [], no_class_cost: 0, calculation_type: "class" },
+  regions: [] as any[],
+  shipping_rates: [
+    { id: "rest-of-world-standard", name: "Standard delivery", cost: 0, free_over: null },
+  ],
+  tax_groups: [
+    { name: "Products", rates: [] as any[] },
+  ],
+  shipping_tax: null,
 };