@wix/himalaya-cli 0.1527.0 → 0.1529.0

package/templates/branded-lite/tier5-src/_shared/himi-restaurants.ts

@@ -133,15 +133,18 @@ export function itemLabels(value: unknown, limit = 3): string[] {
 }
 
 /** Price-variant rows ({ name, priceLine }) from the item's loose
- *  `priceVariants.variants` payload — [] when the item has a single price. */
-export function itemPriceVariants(item: WixItem): Array<{ id: string; name: string; priceLine: string }> {
+ *  `priceVariants.variants` payload — [] when the item has a single price.
+ *  `variantId` is Wix's own id for the variant (live rows carry `variantId`; older
+ *  fixtures `id`), "" when the payload has none — a synthetic `variant-<n>` row id is
+ *  only for the UI and must never be sent to Wix. `price` is the decimal price. */
+export function itemPriceVariants(item: WixItem): Array<{ id: string; variantId: string; name: string; priceLine: string; price: string }> {
   const raw = item as unknown as { priceVariants?: { variants?: unknown[] } };
   const variants = raw.priceVariants?.variants;
   if (!Array.isArray(variants)) return [];
-  const rows: Array<{ id: string; name: string; priceLine: string }> = [];
+  const rows: Array<{ id: string; variantId: string; name: string; priceLine: string; price: string }> = [];
   for (const [index, entry] of variants.entries()) {
     if (!entry || typeof entry !== "object") continue;
-    const node = entry as { id?: unknown; name?: unknown; priceInfo?: { price?: unknown; currency?: unknown } };
+    const node = entry as { id?: unknown; variantId?: unknown; name?: unknown; priceInfo?: { price?: unknown; currency?: unknown; formattedPrice?: unknown } };
     const name = typeof node.name === "string" ? cleanTitle(node.name) : "";
     const price = node.priceInfo?.price;
     if (price == null || price === "" || Number.isNaN(Number(price))) continue;
@@ -152,7 +155,11 @@ export function itemPriceVariants(item: WixItem): Array<{ id: string; name: stri
         priceLine = formatCurrency(Number(price), currency, "en");
       } catch { /* keep the bare amount */ }
     }
-    rows.push({ id: typeof node.id === "string" && node.id ? node.id : `variant-${index}`, name: name || "Option", priceLine });
+    const formatted = typeof node.priceInfo?.formattedPrice === "string" ? node.priceInfo.formattedPrice.trim() : "";
+    if (formatted) priceLine = normalizeFormattedPrice(formatted);
+    const variantId = typeof node.variantId === "string" && node.variantId ? node.variantId
+      : typeof node.id === "string" && node.id ? node.id : "";
+    rows.push({ id: variantId || `variant-${index}`, variantId, name: name || "Option", priceLine, price: `${price}` });
   }
   return rows;
 }

package/templates/branded-lite/tier5-src/_shared/restaurant-ordering.ts

@@ -0,0 +1,201 @@
+// Restaurants online ordering — Wix's visitor "Place an order from a custom storefront" flow,
+// shared by the dish detail (himi-branded-lite-menu-item: add a dish to the Wix cart) and the
+// order screen (wix-spaces-food-orders: cart → pickup/delivery → hosted checkout → history).
+//
+// The cart is the site's eCom CURRENT cart (Cart V2). It is the same cart the Stores cart screen
+// reads (V1 and V2 answer the same cart id), so a restaurant line is told apart by its catalog
+// app — Restaurants Orders — never assumed. Every call here is visitor-scope; the member's placed
+// orders are read through the eCom orders search the member Orders screen already uses, never
+// through the owner-capable Restaurants Orders API.
+import {
+  getFirstAvailableTimeSlotPerFulfillmentType,
+  listFulfillmentMethods,
+  listOperations,
+  queryMenus,
+  querySections,
+  type WixFulfillmentMethod,
+  type WixFulfillmentTimeSlot,
+  type WixMenu,
+  type WixOperation,
+  type WixRestaurantsAddress,
+  type WixSection,
+} from "@himalaya/wix-restaurants";
+import type { WixCartV2, WixCartV2LineItem, WixCatalogReference } from "@himalaya/wix-ecom";
+import { formatCurrency } from "../_shared/engine-intl.js";
+
+/** Wix Restaurants Orders — the catalog app a restaurant cart line belongs to. */
+export const RESTAURANTS_ORDERS_APP_ID = "9a5d83fd-8570-482e-81ab-cfa88942ee60";
+
+export type FulfillmentType = "PICKUP" | "DELIVERY";
+
+/** The operation a visitor orders from: an `ENABLED` one, the site's default first. None means
+ *  online ordering is closed (`DISABLED`, `PAUSED_UNTIL`, or no operation at all). */
+export function orderingOperation(operations: WixOperation[] | undefined, selection: { businessLocationId?: string; operationId?: string } = {}): WixOperation | undefined {
+  const open = (operations ?? []).filter((operation) => !!operation?.id && operation.onlineOrderingStatus === "ENABLED");
+  if (selection.operationId) return open.find((operation) => operation.id === selection.operationId);
+  if (selection.businessLocationId) return open.find((operation) => operation.businessLocationId === selection.businessLocationId);
+  return open.find((operation) => operation.default === true) ?? open[0];
+}
+
+export async function loadOrderingOperation(selection: { businessLocationId?: string; operationId?: string } = {}): Promise<WixOperation | undefined> {
+  return orderingOperation((await listOperations()).operations, selection);
+}
+
+/** The enabled pickup/delivery methods [operation] offers: the ones its `fulfillmentIds` name. An
+ *  operation that names none falls back only to methods at its own business location — never to
+ *  every method on the site, which on a multi-location site would offer another location's pickup. */
+export function offeredMethods(operation: WixOperation, methods: WixFulfillmentMethod[] | undefined): WixFulfillmentMethod[] {
+  const ids = new Set(operation.fulfillmentIds ?? []);
+  const belongs = (method: WixFulfillmentMethod) => ids.size > 0
+    ? ids.has(method.id)
+    : !!operation.businessLocationId && method.businessLocationId === operation.businessLocationId;
+  return (methods ?? []).filter((method) =>
+    !!method?.id && method.enabled === true && (method.type === "PICKUP" || method.type === "DELIVERY") && belongs(method));
+}
+
+export async function loadOfferedMethods(operation: WixOperation): Promise<WixFulfillmentMethod[]> {
+  const all: WixFulfillmentMethod[] = [];
+  let cursor = "";
+  // A site has a handful of methods; five pages of 100 is a bound, not an expectation.
+  for (let page = 0; page < 5; page++) {
+    const response = await listFulfillmentMethods({ limit: 100, ...(cursor ? { cursor } : {}) });
+    all.push(...(response.fulfillmentMethods ?? []));
+    cursor = response.pagingMetadata?.hasNext ? response.pagingMetadata.cursors?.next ?? "" : "";
+    if (!cursor) break;
+  }
+  return offeredMethods(operation, all);
+}
+
+/** A decimal string from Wix ("6.99", "0") as a number; anything else is 0 (a missing fee is free). */
+export function decimal(value: unknown): number {
+  const n = typeof value === "number" ? value : Number(typeof value === "string" ? value.trim() : NaN);
+  return Number.isFinite(n) ? n : 0;
+}
+
+/** Cart V2 money carries no formatted string: format the decimal with the cart's currency. */
+export function money(amount: unknown, currency: string | undefined): string {
+  return formatCurrency(decimal(amount), (currency ?? "").trim() || "USD", "en");
+}
+
+export function cartCurrency(cart: WixCartV2 | undefined): string {
+  return cart?.businessInfo?.currencyCode || cart?.customerInfo?.currencyCode || "";
+}
+
+/** Where a dish is ordered from. Checkout validates the line against `menuSectionId`, so it must
+ *  be a visible section that lists the dish, inside a visible menu that lists the section. */
+export interface DishPlacement {
+  menuId: string;
+  sectionId: string;
+  businessLocationId?: string;
+}
+
+/** The section the dish was shown under wins when it qualifies; otherwise the first visible
+ *  menu → section that lists it. None → the dish is on no orderable menu. */
+export function pickPlacement(
+  dishId: string,
+  menus: WixMenu[],
+  sections: WixSection[],
+  hint: { menuId?: string; sectionId?: string } = {},
+): DishPlacement | undefined {
+  const listing = new Map(sections
+    .filter((section) => !!section?.id && section.visible !== false && (section.itemIds ?? []).includes(dishId))
+    .map((section) => [section.id, section]));
+  const candidates: DishPlacement[] = [];
+  for (const menu of menus) {
+    if (!menu?.id || menu.visible === false) continue;
+    for (const sectionId of menu.sectionIds ?? []) {
+      if (listing.has(sectionId)) candidates.push({ menuId: menu.id, sectionId, businessLocationId: menu.businessLocationId });
+    }
+  }
+  return candidates.find((c) => c.sectionId === hint.sectionId && (!hint.menuId || c.menuId === hint.menuId)) ?? candidates[0];
+}
+
+export async function loadDishPlacement(dishId: string, hint: { menuId?: string; sectionId?: string }): Promise<DishPlacement | undefined> {
+  const [sections, menus] = await Promise.all([
+    querySections({ paging: { limit: 100 } }),
+    queryMenus({ paging: { limit: 50 } }),
+  ]);
+  return pickPlacement(dishId, menus.menus ?? [], sections.sections ?? [], hint);
+}
+
+/** The catalog reference for one dish line. There is no `variantId` key in `options`. */
+export function dishReference(dishId: string, operationId: string, placement: DishPlacement): WixCatalogReference {
+  return {
+    appId: RESTAURANTS_ORDERS_APP_ID,
+    catalogItemId: dishId,
+    options: {
+      operationId,
+      menuId: placement.menuId,
+      menuSectionId: placement.sectionId,
+      sectionId: placement.sectionId,
+    },
+  };
+}
+
+export function isRestaurantLine(line: WixCartV2LineItem | undefined): boolean {
+  return line?.source?.catalogReference?.appId === RESTAURANTS_ORDERS_APP_ID;
+}
+
+function lineVariantId(line: WixCartV2LineItem): string {
+  const variant = (line.source?.catalogReference?.options as { priceVariant?: { id?: unknown } } | undefined)?.priceVariant;
+  return typeof variant?.id === "string" ? variant.id : "";
+}
+
+/** The cart line Wix kept for [reference] — same dish, operation, menu, section and variant — or
+ *  undefined when Wix dropped it. Wix can refuse an item and still answer 200, so the returned cart
+ *  is the proof. The operation and menu matter: the same dish added from two restaurant locations
+ *  is two lines, and only the one just added proves this add. */
+export function addedLine(cart: WixCartV2 | undefined, reference: WixCatalogReference): WixCartV2LineItem | undefined {
+  type PlacementOptions = { operationId?: unknown; menuId?: unknown; menuSectionId?: unknown };
+  const options = (reference.options ?? {}) as PlacementOptions & { priceVariant?: { id?: unknown } };
+  const variantId = typeof options.priceVariant?.id === "string" ? options.priceVariant.id : "";
+  return (cart?.lineItems ?? []).find((line) => {
+    const ref = line.source?.catalogReference;
+    if (!ref || ref.appId !== reference.appId || ref.catalogItemId !== reference.catalogItemId) return false;
+    const lineOptions = (ref.options ?? {}) as PlacementOptions;
+    if (lineOptions.operationId !== options.operationId || lineOptions.menuId !== options.menuId) return false;
+    if (lineOptions.menuSectionId !== options.menuSectionId) return false;
+    if (lineVariantId(line) !== variantId) return false;
+    if (line.status === "OUT_OF_STOCK" || line.status === "REMOVED_FROM_CATALOG") return false;
+    const confirmed = line.quantityInfo?.confirmedQuantity;
+    return confirmed === undefined || confirmed > 0;
+  });
+}
+
+export function lineQuantity(line: WixCartV2LineItem): number {
+  const q = line.quantityInfo?.confirmedQuantity ?? line.quantityInfo?.requestedQuantity ?? 1;
+  return Number.isFinite(q) && q >= 0 ? Math.floor(q) : 0;
+}
+
+/** How many dishes the cart holds (restaurant lines only). */
+export function restaurantItemCount(cart: WixCartV2 | undefined): number {
+  return (cart?.lineItems ?? []).filter(isRestaurantLine).reduce((total, line) => total + lineQuantity(line), 0);
+}
+
+export function slotFor(slots: WixFulfillmentTimeSlot[] | undefined, type: FulfillmentType): WixFulfillmentTimeSlot | undefined {
+  return (slots ?? []).find((slot) => slot?.fulfilmentType === type);
+}
+
+/** The `deliveryMethod.code` for [type]: `<TYPE>|ASAP`, or the slot's own window for a pre-order.
+ *  An ASAP slot must be sent as ASAP — its start/end window is refused as `DELIVERY_METHOD_NOT_FOUND`. */
+export function deliveryCode(type: FulfillmentType, slot?: WixFulfillmentTimeSlot): string {
+  const window = slot?.timeSlot;
+  if (window?.orderSchedulingType === "PREORDER") {
+    const start = Date.parse(window.startTime ?? ""), end = Date.parse(window.endTime ?? "");
+    if (Number.isFinite(start) && Number.isFinite(end)) return `${type}|${start}|${end}`;
+  }
+  return `${type}|ASAP`;
+}
+
+export async function firstSlots(operationId: string, deliveryAddress?: WixRestaurantsAddress): Promise<WixFulfillmentTimeSlot[]> {
+  return (await getFirstAvailableTimeSlotPerFulfillmentType(operationId, deliveryAddress)).timeslotsPerFulfillmentType ?? [];
+}
+
+/** The pickup address the cart needs before a pickup method can be set: the restaurant's own
+ *  country (and region when Wix gives one) — Wix requires an address even for pickup. */
+export function pickupCartAddress(method: WixFulfillmentMethod | undefined, fallbackCountry = ""): WixRestaurantsAddress | undefined {
+  const address = method?.pickupOptions?.address;
+  const country = (address?.country || fallbackCountry).trim();
+  if (!country) return undefined;
+  return { country, ...(address?.subdivision ? { subdivision: address.subdivision } : {}) };
+}

package/templates/branded-lite/tier5-src/himi-branded-lite-cart/index.ts

@@ -1,6 +1,7 @@
 import { withOnlineWrites } from "../_shared/online-actions.js";
 import { defineService as registerState } from "@himalaya/state";
 import { getStoreProduct } from "../_shared/himi-store.js";
+import { RESTAURANTS_ORDERS_APP_ID } from "../_shared/restaurant-ordering.js";
 import { iapPriceCopy } from "../_shared/iap-worker.js";
 import { withIapPresentation } from "../_shared/iap-presentation.js";
 import { type IapCommerce, classifyCart } from "@himalaya/iap-checkout";
@@ -523,6 +524,11 @@ const svc = defineService<State, {
         const commerce = cartPricing;
         const items = lines.map(line => (line as WixCartLineItemDetail & { catalogReference?: Row["catalogReference"] }).catalogReference);
         if (items.some(item => !item?.catalogItemId || !item.appId)) return derive({ ...state, checkoutHint: iapPriceCopy("cart").purchaseUnavailable });
+        // Restaurant dishes share this Wix cart but check out on the food order screen; this checkout
+        // takes Stores products only, so say which lines are in the way rather than "unavailable".
+        if (items.some(item => item!.appId === RESTAURANTS_ORDERS_APP_ID)) {
+          return derive({ ...state, checkoutHint: copyParam("cart.restaurantItemsHint", "This cart also has restaurant dishes. Remove them here to check out your store items.") });
+        }
         await commerce.loadPrices(items.map((item, index) => ({ reference: { kind: "storesProduct", id: item!.catalogItemId }, commerceDisplayPrice: lines[index].price?.formattedAmount })));
         const classification = classifyCart(items.map((item, index) => ({ route: commerce.pricing.view({ kind: "storesProduct", id: item!.catalogItemId }).route, quantity: lines[index].quantity ?? 1 })));
         if (classification !== "regular") return derive({ ...state, checkoutHint: classification === "mixedRefused" ? copyParam("cart.iapSingleItemOnly", "Buy digital items individually, with quantity 1 and no options.") : iapPriceCopy("cart").purchaseUnavailable });

package/templates/branded-lite/tier5-src/himi-branded-lite-menu-item/index.ts

@@ -5,40 +5,31 @@
 // read; when the GET path 404s/errors on a drifted gateway the worker falls
 // back to the items QUERY (client-side find by id — correct whether or not the
 // gateway honored the filter). Only both failing lands in the error card.
+//
+// "Add to order" puts the dish in the site's real Wix cart (Restaurants online
+// ordering, _shared/restaurant-ordering.ts) — never a device-local basket. It is
+// offered only when the restaurant takes online orders now and the dish can be
+// ordered as shown: a dish with options to pick (modifier groups) or a sold-out
+// dish says so instead of adding the wrong thing.
 import { defineService } from "@himalaya/state";
-import { getItem, queryItems, type WixItem } from "@himalaya/wix-restaurants";
+import { getItem, queryItems, type WixItem, type WixOperation } from "@himalaya/wix-restaurants";
+import { addLineItemsToCurrentCartV2, ecomApplicationErrorCode, getCurrentCartV2 } from "@himalaya/wix-ecom";
 import { WIX_DETAIL_IMAGE } from "@himalaya/wix-media";
 import { descriptionSnippet, itemImage, itemLabels, itemPriceLine, itemPriceVariants, unwrapItem } from "../_shared/himi-restaurants.js";
+import { addedLine, dishReference, lineQuantity, loadDishPlacement, loadOrderingOperation, restaurantItemCount, type DishPlacement } from "../_shared/restaurant-ordering.js";
 import { cleanTitle, initials } from "../_shared/himi-text.js";
 import { copyParam, copyTemplate, stashCopy } from "../_shared/himi-copy.js";
-import { localPreferences } from "../_shared/local-preferences.js";
-
-interface BasketItem {
-  id: string;
-  name: string;
-  priceLine: string;
-  quantity: number;
-}
 
 interface VariantRow {
   id: string;
+  /** Wix's own variant id ("" when the payload carries none — then it cannot be ordered). */
+  variantId: string;
   name: string;
   priceLine: string;
+  price: string;
   actionLabel: string;
 }
 
-function normalizeBasket(value: unknown): BasketItem[] {
-  if (!Array.isArray(value)) return [];
-  return value.flatMap((entry) => {
-    const item = entry as Partial<BasketItem> | 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;
-    return [{ id: item.id.slice(0, 256), name: item.name.slice(0, 256), priceLine: typeof item.priceLine === "string" ? item.priceLine.slice(0, 128) : "", quantity }];
-  }).slice(0, 50);
-}
-
-const basket = localPreferences<BasketItem[]>("restaurant.basket", normalizeBasket);
-
 interface State {
   status: "loading" | "ready" | "error";
   id: string;
@@ -69,11 +60,32 @@ interface State {
   hasImage: boolean;
   noImage: boolean;
   hideContent: boolean;
-  basketCount: number;
-  basketLabel: string;
-  basketMessage: string;
-  canSaveBasket: boolean;
-  cannotSaveBasket: boolean;
+  /** "Add to order" is offered (ordering open, dish orderable as shown). */
+  canOrder: boolean;
+  cannotOrder: boolean;
+  /** Why it is not offered: ordering closed, sold out, options to choose on the site, … */
+  orderNote: string;
+  noOrderNote: boolean;
+  /** Feedback for the last add. */
+  orderMessage: string;
+  /** Restaurant dishes in the cart, and the "View your order" entry. */
+  cartCount: number;
+  cartLabel: string;
+  hasCart: boolean;
+  noCart: boolean;
+}
+
+/** What load learned about ordering this dish — kept beside the state, never rendered. */
+let operation: WixOperation | undefined;
+let placement: DishPlacement | undefined;
+let adding = false;
+/** Bumped by every confirmed add: a load that an add overtook keeps the add's count and message. */
+let addSeq = 0;
+/** The service's live state (set once the service exists; see wix-spaces-food-orders). */
+let latestState: () => State = () => { throw new Error("service not defined yet"); };
+
+function navInput(): { id?: string; screenId?: string; menuId?: string; sectionId?: string } {
+  return (globalThis as { himalaya?: { input?: { id?: string; screenId?: string; menuId?: string; sectionId?: string } } }).himalaya?.input ?? {};
 }
 
 function inputId(): string {
@@ -81,14 +93,13 @@ function inputId(): string {
   // `id` nav param (himi.open { screenId: "himi_menu_item", id }) into worker input.
   // The screenId-slice below is #570 back-compat for pre-params releases with
   // baked `himi_menu_item_<id>` screenIds — do not author against this.
-  const input = (globalThis as { himalaya?: { input?: { id?: string; screenId?: string } } }).himalaya?.input;
-  if (input?.id) return input.id;
-  return input?.screenId?.startsWith("himi_menu_item_") ? input.screenId.slice("himi_menu_item_".length) : "";
+  const input = navInput();
+  if (input.id) return input.id;
+  return input.screenId?.startsWith("himi_menu_item_") ? input.screenId.slice("himi_menu_item_".length) : "";
 }
 
 function derive(state: State): State {
   const empty = state.status === "ready" && !state.name;
-  const basketCount = normalizeBasket(basket.read()).reduce((total, item) => total + item.quantity, 0);
   return {
     ...state,
     variants: state.variants.map((variant) => ({
@@ -105,25 +116,51 @@ function derive(state: State): State {
     hasImage: !!state.image,
     noImage: !state.image,
     hideContent: state.status !== "ready" || empty,
-    basketCount,
-    basketLabel: basketCount
-      ? copyTemplate("menuItem.basketCount", "{count} {unit} in your basket", {
-          count: basketCount,
-          unit: basketCount === 1 ? "item" : "items",
+    cannotOrder: !state.canOrder,
+    noOrderNote: !state.orderNote,
+    cartLabel: state.cartCount
+      ? copyTemplate("menuItem.cartCount", "{count} {unit} in your order", {
+          count: state.cartCount,
+          unit: state.cartCount === 1 ? "dish" : "dishes",
         })
-      : copyParam("menuItem.basketEmpty", "Your basket is empty"),
-    canSaveBasket: basket.available,
-    cannotSaveBasket: !basket.available,
+      : "",
+    hasCart: state.cartCount > 0,
+    noCart: state.cartCount === 0,
   };
 }
 
-function ready(state: State, item: WixItem | undefined): State {
+const NOT_ORDERING = { canOrder: false, orderNote: "" } as const;
+
+/** Whether this dish can be ordered from the app, and the note shown when it cannot. */
+function orderability(item: WixItem, variants: VariantRow[], orderingOpen: boolean | "unknown"): Pick<State, "canOrder" | "orderNote"> {
+  const raw = item as unknown as { orderSettings?: { inStock?: unknown }; modifierGroups?: unknown; modifierGroupIds?: unknown };
+  if (orderingOpen === "unknown") {
+    return { canOrder: false, orderNote: copyParam("menuItem.orderingUnavailable", "Online ordering isn't available right now.") };
+  }
+  if (!orderingOpen) return { canOrder: false, orderNote: copyParam("menuItem.orderingClosed", "Online ordering is closed right now.") };
+  if (raw.orderSettings?.inStock === false) return { canOrder: false, orderNote: copyParam("menuItem.soldOut", "This dish is sold out.") };
+  const groups = [raw.modifierGroups, raw.modifierGroupIds].some((value) => Array.isArray(value) && value.length > 0);
+  // Options are chosen on the restaurant's website: adding the dish without them could
+  // order something the customer did not pick.
+  if (groups) return { canOrder: false, orderNote: copyParam("menuItem.optionsOnSite", "This dish has options. Order it on the restaurant's website.") };
+  // Wix's documented visitor cart flow does not define a price-variant selection. A storefront
+  // implementation suggests a key, but we cannot safely recover if Wix prices that line wrong
+  // and the cart refuses removal. Keep the choice visible, and send the customer to the site.
+  if (variants.length > 0) {
+    return { canOrder: false, orderNote: copyParam("menuItem.optionsOnSite", "This dish has options. Order it on the restaurant's website.") };
+  }
+  if (!placement) return { canOrder: false, orderNote: copyParam("menuItem.notOrderable", "This dish can't be ordered online.") };
+  return { canOrder: true, orderNote: "" };
+}
+
+function ready(state: State, item: WixItem | undefined, orderingOpen: boolean | "unknown", cartCount: number): State {
   if (!item || item.visible === false) {
     return derive({
       ...state, status: "ready", id: "", name: "", description: "", priceLine: "", image: "", initial: "",
       label1: "", label2: "", label3: "", noLabel1: true, noLabel2: true, noLabel3: true,
       variants: [], hasVariants: false, noVariants: true,
       selectedVariantId: "", selectedVariantLabel: "",
+      ...NOT_ORDERING, orderMessage: "", cartCount,
       emptyText: copyParam("menuItem.emptyText", "This dish is no longer on the menu."),
     });
   }
@@ -151,37 +188,61 @@ function ready(state: State, item: WixItem | undefined): State {
     selectedVariantLabel: "",
     image: itemImage((item as unknown as Record<string, unknown>).image, WIX_DETAIL_IMAGE),
     initial: initials(name),
+    ...orderability(item, variants, orderingOpen),
+    orderMessage: "",
+    cartCount,
   });
 }
 
-async function load(state: State, arg?: unknown): Promise<State> {
-  stashCopy(arg);
-  const id = inputId();
-  if (!id) return ready(state, undefined);
+async function loadDish(id: string): Promise<WixItem | undefined> {
   try {
     // The live GET path 200s with a WRAPPED payload (`{ item: {...} }`) while
     // the generated client types it bare — unwrap defensively (production R1:
     // the raw wrapper rendered a hollow "Dish" shell with loading/error/empty
     // all hidden). An unrecognizable 200 shape falls through to the query.
     const item = unwrapItem(await getItem(id));
-    if (item) return ready(state, item);
+    if (item) return item;
   } catch {
     // Drifted GET path / transient failure → the query fallback below.
   }
   // Client-side find keeps this correct even when the gateway ignores the
-  // filter shape.
+  // filter shape. A failure here throws to the error card.
+  const response = await queryItems({ filter: { id: { $eq: id } }, paging: { limit: 100 } });
+  return (response.items ?? []).find((candidate) => candidate.id === id);
+}
+
+async function load(state: State, arg?: unknown): Promise<State> {
+  stashCopy(arg);
+  const addAt = addSeq;
+  const id = inputId();
+  if (!id) return ready(state, undefined, false, 0);
+  const input = navInput();
+  // Ordering is best-effort beside the dish: a failed ordering read hides the
+  // button with a note, never the dish.
+  const where = loadDishPlacement(id, { menuId: input.menuId, sectionId: input.sectionId }).catch(() => undefined);
+  const count = getCurrentCartV2().then(restaurantItemCount, () => 0);
+  let item: WixItem | undefined;
   try {
-    const response = await queryItems({ filter: { id: { $eq: id } }, paging: { limit: 100 } });
-    return ready(state, (response.items ?? []).find((candidate) => candidate.id === id));
+    item = await loadDish(id);
   } catch {
     return derive({ ...state, status: "error" });
   }
+  const [found, cartCount] = await Promise.all([where, count]);
+  const { op, ok } = await loadOrderingOperation({ businessLocationId: found?.businessLocationId })
+    .then((selected) => ({ op: selected, ok: true }), () => ({ op: undefined, ok: false }));
+  operation = op;
+  placement = found;
+  const next = ready(state, item, ok ? !!op : "unknown", cartCount);
+  if (addSeq === addAt) return next;
+  // An add landed while this (re)load was in flight: its count and "Added" message are newer.
+  const latest = latestState();
+  return derive({ ...next, cartCount: latest.cartCount, orderMessage: latest.orderMessage });
 }
 
 const svc = defineService<State, {
   load: (state: State, arg?: unknown) => Promise<State>;
   selectVariant: (state: State, arg?: unknown) => State;
-  addToBasket: (state: State) => State;
+  addToOrder: (state: State) => Promise<State>;
 }>("himiBrandedMenuItem", {
   state: derive({
     status: "loading",
@@ -211,11 +272,15 @@ const svc = defineService<State, {
     hasImage: false,
     noImage: true,
     hideContent: true,
-    basketCount: 0,
-    basketLabel: "",
-    basketMessage: "",
-    canSaveBasket: basket.available,
-    cannotSaveBasket: !basket.available,
+    canOrder: false,
+    cannotOrder: true,
+    orderNote: "",
+    noOrderNote: true,
+    orderMessage: "",
+    cartCount: 0,
+    cartLabel: "",
+    hasCart: false,
+    noCart: true,
   }),
   actions: {
     load,
@@ -234,36 +299,38 @@ const svc = defineService<State, {
           name: selected.name,
           price: selected.priceLine,
         }),
-        basketMessage: "",
+        orderMessage: "",
       });
     },
-    addToBasket: (state) => {
-      if (!basket.available) {
-        return derive({ ...state, basketMessage: copyParam("menuItem.basketSignIn", "Sign in to save a basket for this business.") });
-      }
+    addToOrder: async (state) => {
       const id = inputId();
-      if (!id || !state.name || state.status !== "ready") return state;
-      const selected = state.hasVariants
-        ? state.variants.find((variant) => variant.id === state.selectedVariantId)
-        : undefined;
-      if (state.hasVariants && !selected) {
-        return derive({ ...state, basketMessage: copyParam("menuItem.chooseVariantFirst", "Choose an option before adding this dish.") });
-      }
-      const basketId = selected ? `${id}::${selected.id}` : id;
-      const basketName = selected ? `${state.name} — ${selected.name}` : state.name;
-      const basketPrice = selected?.priceLine || state.priceLine;
-      const current = basket.read();
-      const existing = current.find((item) => item.id === basketId);
-      const next = existing
-        ? current.map((item) => item.id === basketId ? { ...item, quantity: Math.min(99, item.quantity + 1) } : item)
-        : [...current, { id: basketId, name: basketName, priceLine: basketPrice, quantity: 1 }];
-      basket.write(next);
-      if (!basket.available) {
-        return derive({ ...state, basketMessage: copyParam("menuItem.basketWriteFailed", "Your basket could not be saved. Try again.") });
+      if (adding || !state.canOrder || !operation || !placement || !id || state.status !== "ready") return state;
+      const reference = dishReference(id, operation.id, placement);
+      adding = true;
+      try {
+        const before = await getCurrentCartV2();
+        const prior = addedLine(before, reference);
+        const priorQuantity = prior ? lineQuantity(prior) : 0;
+        const cart = (await addLineItemsToCurrentCartV2([{ catalogReference: reference, quantity: 1 }])).cart ?? await getCurrentCartV2();
+        const line = addedLine(cart, reference);
+        if (!line || lineQuantity(line) <= priorQuantity) {
+          return derive({ ...latestState(), orderMessage: copyParam("menuItem.addRefused", "The restaurant couldn't add this dish right now.") });
+        }
+        addSeq++;
+        // Onto the live state: a reload while the add was in flight (ordering closed, say) stays.
+        return derive({ ...latestState(), orderMessage: copyParam("menuItem.addedToOrder", "Added to your order."), cartCount: restaurantItemCount(cart) });
+      } catch (error) {
+        const code = ecomApplicationErrorCode(error);
+        const orderMessage = code === "ITEM_NOT_FOUND_IN_CATALOG" || code === "INSUFFICIENT_INVENTORY"
+          ? copyParam("menuItem.noLongerOrderable", "This dish can't be ordered right now.")
+          : copyParam("menuItem.addFailed", "Could not add this dish. Try again.");
+        return derive({ ...latestState(), orderMessage });
+      } finally {
+        adding = false;
       }
-      return derive({ ...state, basketMessage: copyParam("menuItem.basketAdded", "Added to your basket.") });
     },
   },
 });
 
+latestState = () => svc.getState() as State;
 export { svc };