@wix/himalaya-cli 0.1527.0 → 0.1529.0

package/templates/restaurant/tier5-src/wix-spaces-food-orders/index.ts

@@ -1,97 +1,849 @@
-// Tier-5 bundle: Wix Spaces clone — signed-in member's device-local restaurant basket.
-// Restaurant Orders is an owner-capable API. A client-side filter cannot keep records
-// private because the raw response has already reached the member device, so this worker
-// never calls that surface. A customer deployment may replace the explicit handoff copy
-// with a member-authorized site endpoint once one is configured.
+// Tier-5 bundle: restaurant order screen — the customer's Wix cart, pickup or delivery,
+// the Wix-hosted checkout, and (signed in) their placed restaurant orders.
+//
+// Wix's visitor flow (_shared/restaurant-ordering.ts): an ENABLED operation → its enabled
+// fulfillment methods → the eCom current cart (Cart V2) → the cart's address (required even
+// for pickup) → its delivery method → a redirect session for the cart id, opened in-app. The
+// checkout path is the Stores cart's (`payCashierOrder` + `@himalaya/wix-redirects`; the hosted
+// Spaces shell opens it as its member through `_shared/hosted-checkout.ts`). The cart is the
+// site's single eCom cart, so it lists every line Wix will charge, not only the dishes.
+//
+// History reads the member's eCom orders the way the member Orders screen does (`searchOrders`
+// filtered to the signed-in email, the member-scope cache rules of `_shared/member-orders.ts`)
+// and keeps the orders with a Restaurants line. The owner-capable Restaurants Orders API is never
+// called from a member device. `orders` + `emptyText` stay the list contract the Spaces clone binds.
 import { defineService } from "@himalaya/state";
-import { memberAccess } from "../_shared/member-access.js";
-import { localPreferences } from "../_shared/local-preferences.js";
+import {
+  ecomApplicationErrorCode,
+  isOrdersForbiddenError,
+  estimateCurrentCartV2,
+  getCurrentCartV2,
+  removeLineItemsFromCurrentCartV2,
+  searchOrders,
+  setDeliveryMethodForCurrentCartV2,
+  updateCurrentCartV2DeliveryAddress,
+  updateLineItemsInCurrentCartV2,
+  type WixCartV2,
+  type WixCartV2LineItem,
+  type WixOrder,
+} from "@himalaya/wix-ecom";
+import type { WixFulfillmentMethod, WixFulfillmentTimeSlot, WixOperation, WixRestaurantsAddress } from "@himalaya/wix-restaurants";
+import { createRedirectSession } from "@himalaya/wix-redirects";
+import { payCashierOrder } from "@himalaya/checkout";
+import { getAll, upsert, type DbEntity } from "@himalaya/local-db";
+import {
+  RESTAURANTS_ORDERS_APP_ID, cartCurrency, decimal, deliveryCode, firstSlots, isRestaurantLine, lineQuantity,
+  loadOfferedMethods, loadOrderingOperation, money, pickupCartAddress, slotFor, type FulfillmentType,
+} from "../_shared/restaurant-ordering.js";
+import { hostedCheckoutOpener, hostedSitePageOpener, isHostedWorker } from "../_shared/hosted-checkout.js";
+import { assertOrderMember, orderAccessDenied, orderMember, ownedOrderCache, type OrderMember } from "../_shared/member-orders.js";
+import { formatDateMedium, formatWeekdayDateTime } from "../_shared/engine-intl.js";
 import { copyParam, copyTemplate, stashCopy } from "../_shared/himi-copy.js";
 
-interface BasketRow { id: string; name: string; priceLine: string; quantity: number; subtitle: string }
-interface OrderRow { id: string; name: string; subtitle: string }
+interface LineRow {
+  id: string;
+  name: string;
+  /** The media helper's accessible name for the dish image. */
+  title: string;
+  subtitle: string;
+  quantity: number;
+  quantityLabel: string;
+  total: string;
+  image: string;
+  initial: string;
+  hasImage: boolean;
+  noImage: boolean;
+}
+
+interface OrderRow { id: string; name: string; subtitle: string; status: string; detailScreenId: string }
+
 interface S {
   status: "loading" | "ready" | "error";
+  errorText: string;
+  isLoading: boolean;
+  notLoading: boolean;
+  // Ordering
+  orderingOpen: boolean;
+  orderingClosed: boolean;
+  notClosed: boolean;
+  /** Why no operation can be ordered from: closed, a cart that mixes locations, or details that
+   *  could not be refreshed. Each has its own banner, whose TITLE is catalog copy (translatable);
+   *  the worker only chooses which shows, and supplies the message. */
+  closedKind: "" | "closed" | "mixed" | "refresh";
+  hideClosedBanner: boolean;
+  hideMixedBanner: boolean;
+  hideRefreshBanner: boolean;
+  closedText: string;
+  // Cart
+  items: LineRow[];
+  containsOtherItems: boolean;
+  hasItems: boolean;
+  noItems: boolean;
+  showEmptyCart: boolean;
+  hideEmptyCart: boolean;
+  subtotal: string;
+  totalLine: string;
+  noTotalLine: boolean;
+  // Fulfillment
+  fulfillment: "" | FulfillmentType;
+  hasPickup: boolean;
+  noPickup: boolean;
+  hasDelivery: boolean;
+  noDelivery: boolean;
+  pickupSelected: boolean;
+  pickupNotSelected: boolean;
+  deliverySelected: boolean;
+  deliveryNotSelected: boolean;
+  pickupLabel: string;
+  pickupDetail: string;
+  deliveryLabel: string;
+  deliveryDetail: string;
+  hideFulfillment: boolean;
+  hideAddress: boolean;
+  addressLine: string;
+  city: string;
+  postalCode: string;
+  subdivision: string;
+  country: string;
+  deliveryTerms: { addressKey: string; minOrderPrice?: string; fee?: string } | null;
+  // Minimum order / delivery area
+  belowMinimum: boolean;
+  minimumText: string;
+  noMinimumText: boolean;
+  outsideArea: boolean;
+  notOutsideArea: boolean;
+  hideCheckout: boolean;
+  checkoutHint: string;
+  // History
   orders: OrderRow[];
-  basketItems: BasketRow[];
-  basketCount: number;
-  basketLabel: string;
-  emptyText: string;
   needsSignIn: boolean;
   noSignIn: boolean;
-  hasBasket: boolean;
-  noBasket: boolean;
+  hasOrders: boolean;
+  noOrders: boolean;
+  emptyText: string;
+  onSite: boolean;
+  notOnSite: boolean;
+  /** Back-compat list flags (the Spaces clone binds `orders`/`emptyText`). */
   hasActiveOrder: boolean;
   noActiveOrder: boolean;
   errored: boolean;
   notErrored: boolean;
 }
 
-function normalizeBasket(value: unknown): BasketRow[] {
-  if (!Array.isArray(value)) return [];
-  return value.flatMap((entry) => {
-    const item = entry as Partial<BasketRow> | null;
-    if (!item || typeof item.id !== "string" || !item.id || typeof item.name !== "string") return [];
-    const quantity = Number.isFinite(item.quantity) ? Math.max(1, Math.min(99, Math.floor(item.quantity!))) : 1;
-    const priceLine = typeof item.priceLine === "string" ? item.priceLine.slice(0, 128) : "";
-    return [{ id: item.id.slice(0, 256), name: item.name.slice(0, 256), priceLine, quantity,
-      subtitle: [copyTemplate("foodOrders.quantityLine", "Qty {quantity}", { quantity }), priceLine].filter(Boolean).join(" · ") }];
-  }).slice(0, 50);
+// What load learned about ordering — kept beside the state, never rendered.
+let operation: WixOperation | undefined;
+let methods: WixFulfillmentMethod[] = [];
+let slots: WixFulfillmentTimeSlot[] = [];
+/** True once the customer picked pickup or delivery, or typed an address, on this screen. Until
+ *  then the fulfillment shown is only a default, and a load takes the one the cart holds. */
+let customerChose = false;
+/** The member the screen's fulfillment and address were last loaded for ("" before the first load). */
+let shownFor = "";
+/** The `flowRevision` a pending checkout was tapped at; -1 when none is pending. */
+let checkoutPendingAt = -1;
+let flowRevision = 0;
+let cartQueue: Promise<unknown> = Promise.resolve();
+
+/** Who the order history belongs to: the email AND the account/business scope, as memberAccess
+ *  defines it — the same email under another account is another member's history. */
+function memberKey(member: { email: string; scope?: string }): string {
+  return `${member.email}\u0000${member.scope ?? ""}`;
 }
 
-const basket = localPreferences<BasketRow[]>("restaurant.basket", normalizeBasket);
+/** Every action that reads and commits the cart — a load, a quantity change, a checkout — runs here,
+ *  one at a time. Interleaved, whichever finished last committed a cart or an operation another one
+ *  had already replaced (an older cart over a newer one, a closed operation over an open one). */
+function serialized(work: () => Promise<S>): Promise<S> {
+  const task = cartQueue.then(work);
+  cartQueue = task.then(async (next) => {
+    // The runtime stores an action's answer a few microtasks after the action resolves. The next
+    // queued action waits for it, so it starts from this answer and not from the state before it.
+    for (let turn = 0; turn < 50 && latestState() !== next; turn++) await Promise.resolve();
+  }, () => undefined);
+  return task;
+}
+/** The last cart's currency and subtotal, for derives that run without a fresh cart. */
+let lastCurrency = "";
+let subtotalValue = 0;
+
+const method = (type: string): WixFulfillmentMethod | undefined => methods.find((m) => m.type === type);
 
-function derive(state: S): S {
-  const basketItems = normalizeBasket(basket.read());
-  const basketCount = basketItems.reduce((total, item) => total + item.quantity, 0);
+function deliveryAddressKey(state: S): string {
+  return JSON.stringify([state.addressLine.trim(), state.city.trim(), state.postalCode.trim(),
+    state.subdivision.trim().toUpperCase(), state.country.trim().toUpperCase()]);
+}
+
+function initialOf(name: string): string {
+  return (name.trim()[0] || "D").toUpperCase();
+}
+
+function lineRow(line: WixCartV2LineItem, index: number, currency: string): LineRow {
+  const quantity = lineQuantity(line);
+  const name = line.name?.translated || line.name?.original || copyParam("foodOrders.itemFallbackName", "Item");
+  const unit = line.pricing?.unitPrice?.amount;
+  const image = line.attributes?.image?.url ?? "";
+  return {
+    id: line.id || `line-${index}`,
+    name,
+    title: name,
+    subtitle: unit !== undefined ? copyTemplate("foodOrders.unitPrice", "{price} each", { price: money(unit, currency) }) : "",
+    quantity,
+    quantityLabel: `${quantity}`,
+    total: money(line.pricing?.totalPrice?.amount, currency),
+    image,
+    initial: initialOf(name),
+    hasImage: !!image,
+    noImage: !image,
+  };
+}
+
+function methodLabel(m: WixFulfillmentMethod | undefined, type: FulfillmentType, currency: string,
+  terms?: S["deliveryTerms"]): { label: string; detail: string } {
+  const base = type === "PICKUP" ? copyParam("foodOrders.pickupLabel", "Pickup") : copyParam("foodOrders.deliveryLabel", "Delivery");
+  if (!m) return { label: base, detail: "" };
+  const parts: string[] = [];
+  const slot = slotFor(slots, type);
+  const window = slot?.timeSlot;
+  if (window?.orderSchedulingType === "PREORDER" && window.startTime && !Number.isNaN(Date.parse(window.startTime))) {
+    parts.push(copyTemplate("foodOrders.earliest", "Earliest {time}", { time: formatWeekdayDateTime(new Date(window.startTime)) }));
+  } else {
+    const minutes = slot?.fulfillmentInfo?.[0]?.maxTime ?? (type === "DELIVERY" ? m.deliveryOptions?.deliveryTimeInMinutes : undefined);
+    if (minutes) parts.push(copyTemplate("foodOrders.readyIn", "About {minutes} min", { minutes }));
+  }
+  const multipleAreas = type === "DELIVERY" && methods.filter((candidate) => candidate.type === "DELIVERY").length > 1;
+  // A missing fee is 0 (restaurants SDK). Several areas: unknown until the address picks one.
+  const fee = terms ? (terms.fee ?? "0") : multipleAreas ? undefined : (m.fee ?? "0");
+  const minOrderPrice = terms?.minOrderPrice ?? (multipleAreas ? undefined : m.minOrderPrice);
+  if (type === "DELIVERY") parts.push(fee === undefined
+    ? copyParam("foodOrders.deliveryTermsPending", "Fee and minimum shown after checking your address")
+    : decimal(fee) > 0
+      ? copyTemplate("foodOrders.deliveryFee", "Fee {fee}", { fee: money(fee, currency) })
+      : copyParam("foodOrders.freeDelivery", "Free delivery"));
+  if (decimal(minOrderPrice) > 0) parts.push(copyTemplate("foodOrders.minimumShort", "Minimum {amount}", { amount: money(minOrderPrice, currency) }));
+  if (type === "PICKUP" && m.pickupOptions?.address?.formattedAddress) parts.push(m.pickupOptions.address.formattedAddress);
+  return { label: base, detail: parts.join(" · ") };
+}
+
+function derive(state: S, cart?: WixCartV2): S {
+  const currency = cartCurrency(cart) || lastCurrency;
+  if (cart) lastCurrency = currency;
+  const pickup = method("PICKUP"), delivery = method("DELIVERY");
+  const open = !!operation;
+  let fulfillment = state.fulfillment;
+  if (fulfillment && !method(fulfillment)) fulfillment = "";
+  if (!fulfillment) {
+    const preferred = operation?.defaultFulfillmentType;
+    fulfillment = preferred === "DELIVERY" && delivery ? "DELIVERY" : pickup ? "PICKUP" : delivery ? "DELIVERY" : "";
+  }
+  const chosen = fulfillment ? method(fulfillment) : undefined;
+  const subtotalAmount = cart ? decimal(cart.subtotal?.amount) : subtotalValue;
+  if (cart) subtotalValue = subtotalAmount;
+  const terms = state.deliveryTerms?.addressKey === deliveryAddressKey(state) ? state.deliveryTerms : null;
+  const multipleDeliveryAreas = methods.filter((candidate) => candidate.type === "DELIVERY").length > 1;
+  const minimum = fulfillment === "DELIVERY" && multipleDeliveryAreas
+    ? decimal(terms?.minOrderPrice) : decimal(chosen?.minOrderPrice);
+  const belowMinimum = state.items.length > 0 && minimum > 0 && subtotalAmount < minimum;
+  const ready = state.status === "ready";
+  const pickupText = methodLabel(pickup, "PICKUP", currency), deliveryText = methodLabel(delivery, "DELIVERY", currency, terms);
   const signedIn = !state.needsSignIn;
   return {
     ...state,
-    basketItems,
-    basketCount,
-    basketLabel: basketCount ? copyTemplate("foodOrders.basketCount", "{count} {unit} saved on this device", { count: basketCount, unit: basketCount === 1 ? "item" : "items" }) : "",
-    hasBasket: signedIn && basketItems.length > 0,
-    noBasket: !signedIn || basketItems.length === 0,
+    fulfillment,
+    subtotal: cart ? money(cart.subtotal?.amount, currency) : state.subtotal,
+    orderingOpen: open,
+    orderingClosed: ready && !open,
+    notClosed: !(ready && !open),
+    hideClosedBanner: !(ready && !open && (state.closedKind === "closed" || state.closedKind === "")),
+    hideMixedBanner: !(ready && !open && state.closedKind === "mixed"),
+    hideRefreshBanner: !(ready && !open && state.closedKind === "refresh"),
+    hasItems: ready && state.items.length > 0,
+    noItems: !ready || state.items.length === 0,
+    showEmptyCart: ready && state.items.length === 0,
+    hideEmptyCart: !ready || state.items.length > 0,
+    noTotalLine: !state.totalLine,
+    hasPickup: !!pickup,
+    noPickup: !pickup,
+    hasDelivery: !!delivery,
+    noDelivery: !delivery,
+    pickupSelected: fulfillment === "PICKUP",
+    pickupNotSelected: fulfillment !== "PICKUP",
+    deliverySelected: fulfillment === "DELIVERY",
+    deliveryNotSelected: fulfillment !== "DELIVERY",
+    pickupLabel: pickupText.label,
+    pickupDetail: pickupText.detail,
+    deliveryLabel: deliveryText.label,
+    deliveryDetail: deliveryText.detail,
+    hideFulfillment: !ready || !open || state.items.length === 0 || (!pickup && !delivery),
+    hideAddress: !ready || !open || state.items.length === 0 || fulfillment !== "DELIVERY",
+    belowMinimum,
+    minimumText: belowMinimum
+      ? copyTemplate("foodOrders.belowMinimum", "The minimum order for {method} is {amount}. Add {missing} more to check out.", {
+          method: fulfillment === "DELIVERY" ? copyParam("foodOrders.deliveryLabel", "Delivery").toLowerCase() : copyParam("foodOrders.pickupLabel", "Pickup").toLowerCase(),
+          amount: money(minimum, currency),
+          missing: money(minimum - subtotalAmount, currency),
+        })
+      : "",
+    noMinimumText: !belowMinimum,
+    notOutsideArea: !state.outsideArea,
+    hideCheckout: !ready || !open || state.items.length === 0 || !chosen || belowMinimum || state.outsideArea || state.containsOtherItems || state.items.some((item) => item.quantity === 0),
+    checkoutHint: state.containsOtherItems
+      ? copyParam("foodOrders.otherItemsHint", "This cart also has store items. Remove them here to check out your food order.")
+      : state.items.some((item) => item.quantity === 0)
+        ? copyParam("foodOrders.unavailableItemHint", "A dish in your cart is unavailable. Remove it before checking out.")
+      : state.checkoutHint,
+    needsSignIn: state.needsSignIn,
+    noSignIn: !ready || !state.needsSignIn,
+    hasOrders: signedIn && state.orders.length > 0,
+    noOrders: !signedIn || state.orders.length === 0,
+    notOnSite: !state.onSite,
     hasActiveOrder: signedIn && state.orders.length > 0,
     noActiveOrder: !signedIn || state.orders.length === 0,
-    notErrored: !state.errored,
+    isLoading: state.status === "loading",
+    notLoading: state.status !== "loading",
+    errored: state.status === "error",
+    notErrored: state.status !== "error",
   };
 }
 
 const initial: S = {
-  status: "loading", orders: [], basketItems: [], basketCount: 0, basketLabel: "", emptyText: "",
-  needsSignIn: true, noSignIn: false, hasBasket: false, noBasket: true,
+  status: "loading", errorText: "", isLoading: true, notLoading: false,
+  orderingOpen: false, orderingClosed: false, notClosed: true, closedKind: "", hideClosedBanner: true, hideMixedBanner: true, hideRefreshBanner: true, closedText: "",
+  items: [], containsOtherItems: false, hasItems: false, noItems: true, showEmptyCart: false, hideEmptyCart: true, subtotal: "", totalLine: "", noTotalLine: true,
+  fulfillment: "", hasPickup: false, noPickup: true, hasDelivery: false, noDelivery: true,
+  pickupSelected: false, pickupNotSelected: true, deliverySelected: false, deliveryNotSelected: true,
+  pickupLabel: "", pickupDetail: "", deliveryLabel: "", deliveryDetail: "", hideFulfillment: true, hideAddress: true,
+  addressLine: "", city: "", postalCode: "", subdivision: "", country: "", deliveryTerms: null,
+  belowMinimum: false, minimumText: "", noMinimumText: true, outsideArea: false, notOutsideArea: true, hideCheckout: true, checkoutHint: "",
+  orders: [], needsSignIn: true, noSignIn: true, hasOrders: false, noOrders: true, emptyText: "", onSite: false, notOnSite: true,
   hasActiveOrder: false, noActiveOrder: true, errored: false, notErrored: true,
 };
 
+// ---- History: the member's placed restaurant orders ----
+
+const CACHE = "food_orders";
+
+function orderStatus(order: WixOrder): string {
+  const raw = order as WixOrder & { status?: string };
+  if (raw.status === "CANCELED") return copyParam("foodOrders.statusCanceled", "Canceled");
+  if (order.fulfillmentStatus === "FULFILLED") return copyParam("foodOrders.statusCompleted", "Completed");
+  if (order.paymentStatus === "NOT_PAID" || order.paymentStatus === "PENDING") return copyParam("foodOrders.statusAwaitingPayment", "Awaiting payment");
+  return copyParam("foodOrders.statusReceived", "Received");
+}
+
+function isRestaurantOrder(order: WixOrder): boolean {
+  return (order.lineItems ?? []).some((line) =>
+    (line as { catalogReference?: { appId?: string } }).catalogReference?.appId === RESTAURANTS_ORDERS_APP_ID);
+}
+
+function orderRow(order: WixOrder): OrderRow {
+  const count = (order.lineItems ?? []).reduce((sum, line) => sum + (line.quantity || 1), 0);
+  const created = order.createdDate ? new Date(order.createdDate) : undefined;
+  const status = orderStatus(order);
+  return {
+    id: order.id,
+    name: copyTemplate("foodOrders.orderTitle", "Order #{number}", { number: order.number || order.id }),
+    subtitle: [
+      created && !Number.isNaN(created.getTime()) ? formatDateMedium(created) : "",
+      count ? copyTemplate("foodOrders.itemCount", "{count} {unit}", { count, unit: count === 1 ? "item" : "items" }) : "",
+      order.priceSummary?.total?.formattedAmount ?? "",
+      status,
+    ].filter(Boolean).join(" · "),
+    status,
+    detailScreenId: "himi_food_order",
+  };
+}
+
+type CachedOrders = { kind: "loaded"; rows: OrderRow[] } | { kind: "unavailable" };
+
+async function readCachedOrders(member: OrderMember): Promise<CachedOrders> {
+  if (!member.scope) return { kind: "unavailable" };
+  try {
+    const rows = await getAll(CACHE);
+    await assertOrderMember(member);
+    return { kind: "loaded", rows: rows.filter((row) => ownedOrderCache(row, member))
+      .map(({ memberOrderScope: _, ...row }) => row as unknown as OrderRow) };
+  } catch { return { kind: "unavailable" }; }
+}
+
+async function writeCachedOrders(rows: OrderRow[], member: OrderMember): Promise<void> {
+  if (!member.scope) return;
+  try {
+    for (const row of rows) {
+      await assertOrderMember(member);
+      await upsert(CACHE, { ...row, memberOrderScope: member.scope } as unknown as DbEntity);
+    }
+  } catch { /* capability not granted / identity changed → stop caching */ }
+}
+
+type Past = Pick<S, "orders" | "needsSignIn" | "emptyText" | "onSite">;
+
+/** The history together with the member it was read for, so a caller can check that member is
+ *  still the one signed in. An identity read beside it, in parallel, can already see the next one. */
+async function historyOf(): Promise<{ past: Past; who: string }> {
+  const member = await orderMember();
+  return { past: await history(member), who: memberKey(member) };
+}
+
+async function history(known?: OrderMember): Promise<Past> {
+  const member = known ?? await orderMember();
+  if (!member.email) {
+    return { orders: [], needsSignIn: true, emptyText: copyParam("foodOrders.signInEmptyText", "Sign in to see your restaurant orders."), onSite: false };
+  }
+  try {
+    const orders: OrderRow[] = [];
+    const seenCursors = new Set<string>();
+    let cursor = "";
+    do {
+      const response = await searchOrders({ search: {
+        filter: { "buyerInfo.email": { $eq: member.email } },
+        cursorPaging: { limit: 100, ...(cursor ? { cursor } : {}) },
+        sort: [{ fieldName: "createdDate", order: "DESC" }],
+      } });
+      await assertOrderMember(member);
+      orders.push(...(response.orders ?? [])
+        .filter((order) => !!order.id && (order.buyerInfo?.email ?? "").trim().toLowerCase() === member.email && isRestaurantOrder(order))
+        .map(orderRow));
+      const next = (response.metadata as typeof response.metadata & { cursors?: { next?: string } } | undefined)?.cursors?.next ?? "";
+      if (!response.metadata?.hasNext) break;
+      if (!next || seenCursors.has(next)) throw new Error("Order history pagination stopped before the last page");
+      seenCursors.add(next);
+      cursor = next;
+    } while (cursor);
+    void writeCachedOrders(orders, member);
+    // Hosted as its member, Wix answers the member an EMPTY list: never claim "no orders" there.
+    const onSite = isHostedWorker() && orders.length === 0;
+    return {
+      orders, needsSignIn: false, onSite,
+      emptyText: onSite ? copyParam("foodOrders.onSiteText", "Your restaurant orders are on the site.")
+        : orders.length ? "" : copyParam("foodOrders.historyEmptyText", "No restaurant orders yet."),
+    };
+  } catch (error) {
+    // Hosted as its member, Wix can refuse this member session the orders search outright
+    // (403 READ_ORDER_FORBIDDEN). The site's own My Orders page is the way to them, as for an empty answer.
+    if (isHostedWorker() && isOrdersForbiddenError(error)) {
+      await assertOrderMember(member);
+      return { orders: [], needsSignIn: false, onSite: true,
+        emptyText: copyParam("foodOrders.onSiteText", "Your restaurant orders are on the site.") };
+    }
+    const cache: CachedOrders = orderAccessDenied(error) ? { kind: "unavailable" } : await readCachedOrders(member);
+    await assertOrderMember(member);
+    const cached = cache.kind === "loaded" ? cache.rows : [];
+    return {
+      orders: cached, needsSignIn: false, onSite: false,
+      emptyText: cached.length ? "" : copyParam("foodOrders.historyErrorText", "Your past orders could not be loaded."),
+    };
+  }
+}
+
+// ---- Cart ----
+
+/** Everything the screen shows about the cart, from Wix's answer. */
+function withCart(state: S, cart: WixCartV2, checkoutHint = state.checkoutHint): S {
+  const currency = cartCurrency(cart) || lastCurrency;
+  const items = (cart.lineItems ?? []).map((line, index) => lineRow(line, index, currency));
+  return derive({ ...state, status: "ready", errorText: "", items,
+    containsOtherItems: (cart.lineItems ?? []).some((line) => !isRestaurantLine(line)), totalLine: "", checkoutHint }, cart);
+}
+
+function cartOperationIds(cart: WixCartV2): Set<string> {
+  return new Set((cart.lineItems ?? []).filter(isRestaurantLine)
+    .map((line) => (line.source?.catalogReference?.options as { operationId?: unknown } | undefined)?.operationId)
+    .filter((id): id is string => typeof id === "string" && !!id));
+}
+
+/** What one ordering read learned. It is read into a value and applied only by a caller that is
+ *  still current, so a slower, superseded read never overwrites the operation a newer one chose. */
+interface Ordering { operation?: WixOperation; methods: WixFulfillmentMethod[]; slots: WixFulfillmentTimeSlot[] }
+
+async function readOrdering(cart: WixCartV2): Promise<Ordering> {
+  const ids = cartOperationIds(cart);
+  const found = ids.size > 1 ? undefined : await loadOrderingOperation({ operationId: ids.values().next().value });
+  return {
+    operation: found,
+    methods: found ? await loadOfferedMethods(found) : [],
+    slots: found ? await firstSlots(found.id).catch(() => []) : [],
+  };
+}
+
+function applyOrdering(ordering: Ordering): void {
+  operation = ordering.operation; methods = ordering.methods; slots = ordering.slots;
+}
+
+function closedText(): string {
+  return copyParam("foodOrders.orderingClosed", "Online ordering is closed right now. You can still review your order.");
+}
+
+/** What the banner says while no operation applies to [cart] (both empty when one does). */
+function orderingNote(cart: WixCartV2 | undefined, refreshFailed = false): Pick<S, "closedKind" | "closedText"> {
+  if (operation) return { closedKind: "", closedText: "" };
+  if (refreshFailed) return {
+    closedKind: "refresh",
+    closedText: copyParam("foodOrders.orderingRefreshFailed", "Your order was updated, but its pickup and delivery details could not be refreshed. Reopen this screen to check out."),
+  };
+  if (cart && cartOperationIds(cart).size > 1) return {
+    closedKind: "mixed",
+    closedText: copyParam("foodOrders.mixedLocations", "Your order has dishes from more than one restaurant location. Remove the dishes from one location to check out."),
+  };
+  return { closedKind: "closed", closedText: closedText() };
+}
+
+/** A checkout input changed (address, pickup/delivery): the last estimate, its total and its
+ *  feedback ("Checkout opened", an outside-area banner) describe other inputs, so they go. */
+const INPUTS_CHANGED = { totalLine: "", checkoutHint: "", outsideArea: false } as const;
+
+/** The service's live state, for work that settles after a newer action changed it. Set once the
+ *  service exists: reading `svc` inside its own initializer makes its type circular, which the
+ *  off-repo typecheck reports as an implicit `any` (TS7022/TS7023). */
+let latestState: () => S = () => derive(initial);
+
+/** Re-reads ordering when [cart] no longer belongs to the operation on screen (another tab swapped a
+ *  dish or location). A failed read clears ordering, so the old location's methods never stay on
+ *  screen as if they applied; true means that happened and the banner should say so. */
+async function refreshOrderingFor(cart: WixCartV2): Promise<boolean> {
+  const ids = cartOperationIds(cart);
+  if (ids.size === 1 && operation && ids.has(operation.id)) return false;
+  try {
+    applyOrdering(await readOrdering(cart));
+    return false;
+  } catch {
+    applyOrdering({ operation: undefined, methods: [], slots: [] });
+    return true;
+  }
+}
+
+function changeQuantity(id: string, delta: number, remove = false): Promise<S> {
+  // Actions can overlap. Serialize writes and calculate from Wix's current quantity,
+  // so two rapid taps never both send the same absolute newQuantity.
+  flowRevision++;
+  return serialized(async () => {
+    try {
+      const current = await getCurrentCartV2();
+      const line = (current.lineItems ?? []).find((item) => item.id === id);
+      // Gone from the cart — Wix can clear it once the hosted checkout opens: show the cart as it is.
+      if (!line) {
+        const refreshFailed = await refreshOrderingFor(current);
+        return withCart({ ...latestState(), deliveryTerms: null, ...orderingNote(current, refreshFailed) }, current, "");
+      }
+      const next = lineQuantity(line) + delta;
+      const deleted = remove || next < 1;
+      const response = deleted
+        ? await removeLineItemsFromCurrentCartV2([id])
+        : await updateLineItemsInCurrentCartV2([{ lineItemId: id, quantity: next }]);
+      const cart = response.cart ?? await getCurrentCartV2();
+      const hint = deleted ? copyParam("foodOrders.itemRemoved", "Removed from your order.") : "";
+      // The write already landed: a failed ordering refresh must not hide the updated cart.
+      const refreshFailed = await refreshOrderingFor(cart);
+      const latest = latestState();
+      return withCart({ ...latest, deliveryTerms: null, ...orderingNote(cart, refreshFailed) }, cart, hint);
+    } catch {
+      return derive({ ...(latestState()), checkoutHint: copyParam("foodOrders.quantityFailed", "Could not update your order. Try again.") });
+    }
+  });
+}
+
+function idOf(arg: unknown): string {
+  if (typeof arg === "string") return arg;
+  const id = (arg as { id?: unknown } | undefined)?.id;
+  return typeof id === "string" ? id : "";
+}
+
+function valueOf(arg: unknown): string {
+  if (typeof arg === "string") return arg;
+  const value = (arg as { value?: unknown } | undefined)?.value;
+  return typeof value === "string" ? value.slice(0, 200) : "";
+}
+
+/** The address the cart gets for [type]: the restaurant's country for pickup, the customer's
+ *  street for delivery. Undefined when delivery is missing what Wix needs to place it. */
+/** The pickup or delivery a checkout already wrote to the shared cart, for a screen whose
+ *  customer has not chosen one: reopened after a cancelled checkout, it shows what the cart holds, so the next
+ *  Checkout does not silently switch a delivery order to pickup. */
+function savedFulfillment(cart: WixCartV2): Partial<S> {
+  const code = cart.deliveryInfo?.method?.code ?? "";
+  if (code.startsWith("PICKUP|")) return { fulfillment: "PICKUP" };
+  const address = cart.deliveryInfo?.address;
+  if (!code.startsWith("DELIVERY|") || !address?.addressLine) return {};
+  return {
+    fulfillment: "DELIVERY",
+    addressLine: address.addressLine,
+    city: address.city ?? "",
+    postalCode: address.postalCode ?? "",
+    subdivision: address.subdivision ?? "",
+    country: address.country ?? "",
+  };
+}
+
+function cartAddress(state: S, type: FulfillmentType): WixRestaurantsAddress | undefined {
+  if (type === "PICKUP") return pickupCartAddress(method("PICKUP"), state.country);
+  const address: WixRestaurantsAddress = {
+    addressLine: state.addressLine.trim(),
+    city: state.city.trim(),
+    postalCode: state.postalCode.trim(),
+    country: state.country.trim().toUpperCase(),
+  };
+  const subdivision = state.subdivision.trim().toUpperCase();
+  if (subdivision) address.subdivision = subdivision.includes("-") ? subdivision : `${address.country}-${subdivision}`;
+  if (!address.addressLine || !address.city || !address.country) return undefined;
+  return address;
+}
+
+/** What the checkout opens for: the lines, and the address and method the estimate was for. The
+ *  cart is shared, so another tab can change either while the checkout is opening. */
+function cartSignature(cart: WixCartV2): string {
+  return JSON.stringify({
+    lines: (cart.lineItems ?? []).map((line) => [line.id, lineQuantity(line)]),
+    address: cart.deliveryInfo?.address ?? null,
+    method: cart.deliveryInfo?.method?.code ?? "",
+  });
+}
+
+async function checkout(state: S, revision: number): Promise<S> {
+  const type = state.fulfillment;
+  if (!operation) return derive({ ...state, ...orderingNote(undefined) });
+  if (!type || !method(type)) return derive({ ...state, checkoutHint: copyParam("foodOrders.chooseFulfillment", "Choose pickup or delivery.") });
+  const cart = await getCurrentCartV2();
+  if (!(cart.lineItems ?? []).length || !cart.id) return withCart(state, cart, copyParam("foodOrders.checkoutEmpty", "Add a dish before checking out."));
+  if ((cart.lineItems ?? []).some((line) => !isRestaurantLine(line))) return withCart(state, cart);
+  const cartOps = cartOperationIds(cart);
+  if (cartOps.size !== 1 || !cartOps.has(operation.id)) {
+    return withCart(state, cart, copyParam("foodOrders.operationChanged", "The restaurant location changed. Review your order before checking out."));
+  }
+  if ((cart.lineItems ?? []).some((line) => lineQuantity(line) === 0)) return withCart(state, cart);
+  const address = cartAddress(state, type);
+  if (!address) {
+    return derive({ ...state, checkoutHint: type === "DELIVERY"
+      ? copyParam("foodOrders.addressNeeded", "Enter your street, city and country for delivery.")
+      : copyParam("foodOrders.pickupUnavailable", "Pickup isn't available right now.") });
+  }
+  // Multiple delivery areas can have different fees and minima. Only the slot for this address
+  // tells us which terms apply; never block against the first site's delivery method.
+  const fresh = await firstSlots(operation.id, type === "DELIVERY" ? address : undefined).catch(() => undefined);
+  // Fail closed: without the slots we cannot tell whether this type can be ordered now, and every
+  // step below writes to the shared cart.
+  if (!fresh) return derive({ ...state, checkoutHint: copyParam("foodOrders.slotsUnavailable", "Pickup and delivery times could not be checked. Try again.") });
+  // `fresh` is judged for THIS address and stays local: storing it in `slots` left an address's ETA on
+  // the Delivery row after the customer typed another address.
+  // Only orderable slots come back, so a type missing from the answer cannot be ordered now. Never
+  // send `<TYPE>|ASAP` for it. For delivery, a slot without an address but none for this one means
+  // the address is outside every area (verified live); none at all means delivery is closed now.
+  if (!slotFor(fresh, type)) {
+    // Ask again with no address, now: the slots read at load can predate delivery closing, and
+    // would then call a closed kitchen "outside the area". Unreadable → not called outside.
+    const general = type === "DELIVERY" ? await firstSlots(operation.id).catch(() => []) : [];
+    if (slotFor(general, "DELIVERY")) return derive({ ...state, outsideArea: true, checkoutHint: "" });
+    return derive({ ...state, outsideArea: false, checkoutHint: type === "DELIVERY"
+      ? copyParam("foodOrders.deliveryUnavailable", "Delivery isn't available right now.")
+      : copyParam("foodOrders.pickupUnavailable", "Pickup isn't available right now.") });
+  }
+  if (type === "DELIVERY") {
+    const info = fresh ? slotFor(fresh, type)?.fulfillmentInfo?.[0] : undefined;
+    state = { ...state, deliveryTerms: info
+      ? { addressKey: deliveryAddressKey(state), minOrderPrice: info.minOrderPrice, fee: info.fee }
+      : null };
+  }
+  const multipleDeliveryAreas = methods.filter((candidate) => candidate.type === "DELIVERY").length > 1;
+  const minimum = type === "DELIVERY" && multipleDeliveryAreas
+    ? decimal(state.deliveryTerms?.minOrderPrice) : decimal(method(type)?.minOrderPrice);
+  if (minimum > 0 && decimal(cart.subtotal?.amount) < minimum) return withCart(state, cart);
+  // The awaits above take network round trips. A flow the customer has since superseded (an
+  // address or method edit, a quantity change) must not write its captured address or method
+  // into the shared cart, so every cart write below is preceded by this check.
+  const superseded = () => flowRevision !== revision;
+  if (superseded()) return latestState();
+  try {
+    await updateCurrentCartV2DeliveryAddress(address);
+  } catch (error) {
+    if (ecomApplicationErrorCode(error) === "INVALID_ADDRESS_FORMAT") {
+      return derive({ ...state, checkoutHint: copyParam("foodOrders.addressInvalid", "Check the delivery address and try again.") });
+    }
+    throw error;
+  }
+  // The earliest slot for this address: ASAP when the kitchen can take it now, else its window.
+  if (superseded()) return latestState();
+  try {
+    await setDeliveryMethodForCurrentCartV2(deliveryCode(type, fresh ? slotFor(fresh, type) : undefined));
+  } catch (error) {
+    // The slot read above found this type for this address, so a refusal now means its window
+    // closed in between, not that the address is outside every area.
+    if (ecomApplicationErrorCode(error) === "DELIVERY_METHOD_NOT_FOUND") {
+      return derive({ ...state, outsideArea: false, checkoutHint: type === "DELIVERY"
+        ? copyParam("foodOrders.deliveryUnavailable", "Delivery isn't available right now.")
+        : copyParam("foodOrders.pickupUnavailable", "Pickup isn't available right now.") });
+    }
+    throw error;
+  }
+  if (superseded()) return latestState();
+  const estimate = await estimateCurrentCartV2();
+  const estimated = estimate.cart ?? cart;
+  if (!(estimated.lineItems ?? []).length) {
+    return withCart(state, estimated, copyParam("foodOrders.checkoutEmpty", "Add a dish before checking out."));
+  }
+  const currency = cartCurrency(estimated) || lastCurrency;
+  const totals = estimate.summary?.priceSummary;
+  const totalLine = totals?.total?.amount !== undefined
+    ? copyTemplate("foodOrders.totalLine", "Total {total} (delivery {delivery})", { total: money(totals.total.amount, currency), delivery: money(totals.delivery?.amount, currency) })
+    : "";
+  const blocking = (estimate.summary?.violations ?? []).find((violation) => violation.severity === "ERROR");
+  if (blocking) {
+    return { ...withCart({ ...state, outsideArea: false }, estimated), totalLine, noTotalLine: !totalLine,
+      checkoutHint: copyTemplate("foodOrders.checkoutBlocked", "Checkout isn't possible yet: {reason}", { reason: blocking.description || blocking.code || "" }) };
+  }
+  const checkoutId = cart.id;
+  // The lines checked above, with the address and method the estimate was for: a change to either
+  // while the checkout opens withdraws it. The estimate's own cart holds them; only when it leaves
+  // them out is the cart read again, and then the method must still be the type validated here.
+  if (superseded()) return latestState();
+  const held = estimated.deliveryInfo?.method?.code ? estimated.deliveryInfo : (await getCurrentCartV2()).deliveryInfo;
+  const before = cartSignature({ ...cart, deliveryInfo: held });
+  const sameType = (code: string | undefined) => (code ?? "").startsWith(`${type}|`);
+  let withdrawn = false;
+  const hosted = isHostedWorker();
+  const pay = await payCashierOrder({
+    appId: RESTAURANTS_ORDERS_APP_ID,
+    // No order is created in the app: the site's checkout creates it, so a site with no payment
+    // method set up still reaches its own checkout page, which says so. With no cashier order
+    // there is nothing for the wallet rail to settle, so the msid it would need is not read.
+    snapshotId: "",
+    msid: "",
+    mayCharge: async () => {
+      if (flowRevision !== revision) return false;
+      const now = await getCurrentCartV2();
+      const same = sameType(now.deliveryInfo?.method?.code) && cartSignature(now) === before;
+      if (!same) withdrawn = true;
+      return same;
+    },
+    ...(hosted ? { openCashier: hostedCheckoutOpener(checkoutId) } : {}),
+    cashierUrl: async () => flowRevision === revision ? (await createRedirectSession({
+      ecomCheckout: { checkoutId },
+      callbacks: { postFlowUrl: "himalaya-__HIMI_APP_SLUG__://screen/himi_food_orders" },
+    })).redirectSession?.fullUrl : undefined,
+  });
+  const next = { ...withCart({ ...state, outsideArea: false }, estimated), totalLine, noTotalLine: !totalLine };
+  if (pay.kind === "handoff" || pay.kind === "paid") {
+    // The cart stays until the order lands: the customer can still leave the checkout unpaid.
+    return { ...next, checkoutHint: copyParam("foodOrders.checkoutOpened", "Checkout opened. Finish your order on the restaurant's checkout page.") };
+  }
+  if (pay.kind === "cancelled") return { ...next, checkoutHint: copyParam("foodOrders.checkoutCancelled", "Payment cancelled. Your order is still here.") };
+  if (withdrawn) {
+    const now = await getCurrentCartV2().catch(() => estimated);
+    const refreshFailed = await refreshOrderingFor(now);
+    return withCart({ ...state, outsideArea: false, totalLine: "", noTotalLine: true, deliveryTerms: null, ...orderingNote(now, refreshFailed) }, now,
+      copyParam("foodOrders.checkoutChanged", "Your order changed while checkout was opening. Review it and tap Checkout again."));
+  }
+  return { ...next, checkoutHint: copyParam("foodOrders.checkoutFailed", "Checkout could not open. The restaurant may not take online payments yet.") };
+}
+
 const svc = defineService<S, {
   load: (state: S, arg?: unknown) => Promise<S>;
-  clearBasket: (state: S) => S;
+  increment: (state: S, arg?: unknown) => Promise<S>;
+  decrement: (state: S, arg?: unknown) => Promise<S>;
+  remove: (state: S, arg?: unknown) => Promise<S>;
+  choosePickup: (state: S) => S;
+  chooseDelivery: (state: S) => S;
+  setAddressLine: (state: S, arg?: unknown) => S;
+  setCity: (state: S, arg?: unknown) => S;
+  setPostalCode: (state: S, arg?: unknown) => S;
+  setSubdivision: (state: S, arg?: unknown) => S;
+  setCountry: (state: S, arg?: unknown) => S;
+  checkout: (state: S) => Promise<S>;
+  openOrdersOnSite: (state: S) => Promise<S>;
 }>("spacesFoodOrders", {
   state: derive(initial),
   actions: {
-    load: async (state, arg) => {
+    load: (_state, arg) => {
+      flowRevision++; // a reload withdraws a checkout that has not opened yet
       stashCopy(arg);
-      const member = await memberAccess();
-      if (!member.email || !member.scope) {
-        return derive({ ...state, status: "ready", orders: [], emptyText: "", needsSignIn: true, noSignIn: false, errored: false });
-      }
-      return derive({
-        ...state,
-        status: "ready",
-        orders: [],
-        emptyText: copyParam("foodOrders.trackingHandoff", "Live order tracking requires a secure connection configured by this business."),
-        needsSignIn: false,
-        noSignIn: true,
-        errored: false,
+      // Serialized with quantity changes and checkout (the module-scope load and the screen's
+      // on-appear load queue too), and committed onto the state as it is when it finishes, so an
+      // address or fulfillment edit made meanwhile is kept.
+      return serialized(async () => {
+        try {
+          const [cart, first] = await Promise.all([getCurrentCartV2(), historyOf()]);
+          applyOrdering(await readOrdering(cart));
+          // The ordering reads take several round trips: a member who signed out (or another who
+          // signed in) meanwhile must not be shown the first member's orders.
+          const current = memberKey(await orderMember());
+          const past = current === first.who ? first.past : await history();
+          // The address and pickup/delivery choice are the member's own: when a member signs out or
+          // another signs in on this device, the screen drops them and takes the new cart's instead.
+          // A visitor who signs in keeps what they typed: it is the same person.
+          const previousMember = shownFor !== "" && !shownFor.startsWith("\u0000") ? shownFor : "";
+          const memberLeft = previousMember !== "" && current !== previousMember;
+          shownFor = current;
+          if (memberLeft) customerChose = false;
+          const latest = memberLeft
+            ? { ...latestState(), fulfillment: "" as const, addressLine: "", city: "", postalCode: "", subdivision: "", country: "", deliveryTerms: null }
+            : latestState();
+          // The delivery country starts as the restaurant's — the common case, and what Wix needs.
+          const country = latest.country || (method("PICKUP")?.pickupOptions?.address?.country ?? "");
+          // A choice or an address the customer made here wins; a defaulted pickup does not.
+          const saved = customerChose ? {} : savedFulfillment(cart);
+          return withCart({ ...latest, ...past, country, deliveryTerms: null, outsideArea: false,
+            ...orderingNote(cart), ...saved }, cart, "");
+        } catch {
+          // Re-read history against the current identity. The earlier parallel read may belong
+          // to a member who signed out while the cart or operations request was in flight.
+          const past = await history().catch(() => undefined);
+          applyOrdering({ operation: undefined, methods: [], slots: [] });
+          const latest = latestState();
+          return derive({ ...latest, ...past, status: "error", items: [], containsOtherItems: false,
+            deliveryTerms: null, checkoutHint: "", orders: past?.orders ?? [],
+            needsSignIn: past?.needsSignIn ?? true, onSite: past?.onSite ?? false,
+            emptyText: past?.emptyText ?? "", errorText: copyParam("foodOrders.loadError", "Your order could not be loaded.") });
+        }
       });
     },
-    clearBasket: (state) => {
-      if (!basket.available || state.needsSignIn) return state;
-      basket.write([]);
-      return derive({ ...state });
+    increment: (_state, arg) => changeQuantity(idOf(arg), 1),
+    decrement: (_state, arg) => changeQuantity(idOf(arg), -1),
+    remove: (_state, arg) => changeQuantity(idOf(arg), 0, true),
+    choosePickup: (state) => { flowRevision++; customerChose = true; return derive({ ...state, ...INPUTS_CHANGED, fulfillment: method("PICKUP") ? "PICKUP" : state.fulfillment }); },
+    chooseDelivery: (state) => { flowRevision++; customerChose = true; return derive({ ...state, ...INPUTS_CHANGED, fulfillment: method("DELIVERY") ? "DELIVERY" : state.fulfillment }); },
+    setAddressLine: (state, arg) => { flowRevision++; customerChose = true; return derive({ ...state, ...INPUTS_CHANGED, addressLine: valueOf(arg) }); },
+    setCity: (state, arg) => { flowRevision++; customerChose = true; return derive({ ...state, ...INPUTS_CHANGED, city: valueOf(arg) }); },
+    setPostalCode: (state, arg) => { flowRevision++; customerChose = true; return derive({ ...state, ...INPUTS_CHANGED, postalCode: valueOf(arg) }); },
+    setSubdivision: (state, arg) => { flowRevision++; customerChose = true; return derive({ ...state, ...INPUTS_CHANGED, subdivision: valueOf(arg) }); },
+    setCountry: (state, arg) => { flowRevision++; customerChose = true; return derive({ ...state, ...INPUTS_CHANGED, country: valueOf(arg) }); },
+    checkout: (state) => {
+      // A second tap for the same inputs is a double tap. After an edit (a new revision) the tap is a
+      // new checkout: it queues behind the superseded one, which withdraws at its next check.
+      const revision = flowRevision;
+      if (checkoutPendingAt === revision) return Promise.resolve(state);
+      checkoutPendingAt = revision;
+      return serialized(async () => {
+        // Built from the state when it runs, not when it was tapped: a load that ran first may have
+        // committed a newer cart, which this checkout's answer must not revert.
+        const current = latestState();
+        try {
+          const result = await checkout({ ...current, checkoutHint: "" }, revision);
+          return revision === flowRevision ? result : latestState();
+        } catch {
+          return revision === flowRevision
+            ? derive({ ...latestState(), checkoutHint: copyParam("foodOrders.checkoutFailed", "Checkout could not open. The restaurant may not take online payments yet.") })
+            : latestState();
+        } finally {
+          if (checkoutPendingAt === revision) checkoutPendingAt = -1;
+        }
+      });
+    },
+    // Hosted in a host shell: the member's orders live on the site's own My Orders page.
+    openOrdersOnSite: async (state) => {
+      if (!state.onSite) return state;
+      const member = await orderMember();
+      const opened = await hostedSitePageOpener({ page: "orders" })(async () => {
+        const now = await orderMember();
+        return now.email === member.email && now.scope === member.scope;
+      });
+      // A member who signed out or switched account while the host worked never inherits this
+      // answer (as himi-branded-lite-orders.openOnSite); the next load resets the screen for them.
+      if (memberKey(await orderMember()) !== memberKey(member)) return latestState();
+      // Committed onto the state as it is now: the host round trips above can outlast a quantity
+      // change or a load, whose answer this must not revert.
+      const latest = latestState();
+      return derive({ ...latest, emptyText: opened === false
+        ? copyParam("foodOrders.onSiteFailed", "The site's orders page could not be opened.") : latest.emptyText });
     },
   },
 });
+latestState = () => svc.getState() as S;
 svc.load();
 export { svc };