@wix/agent-skills 1.25.0 → 1.27.0

package/skills/wix-headless-templates/restaurants/project/src/wix/restaurants/order-store.ts

@@ -0,0 +1,141 @@
+// Client-side order-cart state — a module-scope store, deliberately NOT a React context.
+// A context can't span Astro islands (each island is its own React root); a module singleton
+// is shared by every island in the page bundle, and works identically in a single-root SPA.
+// Consume it through useOrderCart() (hooks/), or subscribe directly. Besides the cart it holds
+// the site's ordering gates: the operation's state and each menu's ordering settings, so an add
+// control can read "accepting orders?" and "is THIS menu orderable now?" without a fetch of its own.
+import type { FulfillmentMethodInfo, MenuItem, MenuOrderingInfo, OrderCart, OrderSelection, OrderingStatus } from "./types";
+import { menuOrderable } from "./ordering-core";
+import {
+  addToOrder as apiAdd,
+  fetchFulfillmentMethods,
+  fetchMenuOrdering,
+  fetchOrderCart,
+  orderCheckoutUrl,
+  removeOrderLine as apiRemove,
+  resolveOrdering,
+  updateOrderQuantity as apiUpdate,
+} from "./ordering";
+
+export interface OrderCartState {
+  cart: OrderCart | null;
+  /** null while resolving; true only for an ENABLED operation; false → no ordering, disabled, or paused. */
+  ordering: boolean | null;
+  /** The operation's state (why `ordering` is false: NONE / DISABLED / PAUSED_UNTIL + pausedUntilIso). null while resolving. */
+  orderingStatus: OrderingStatus | null;
+  /** Per-menu ordering settings under the operation, keyed by menuId; null while loading or when unreadable. */
+  menuOrdering: Record<string, MenuOrderingInfo> | null;
+  /** The operation's enabled pickup/delivery methods, for display; null while loading. */
+  fulfillment: FulfillmentMethodInfo[] | null;
+  /**
+   * True while any cart operation is in flight — the DRAWER's flag (its steppers, remove and
+   * checkout controls), not a dish card's: a card disables its own add control on `pendingItemId`,
+   * or every dish in the grid dims for every add.
+   */
+  busy: boolean;
+  /** The menu item whose add is in flight, null otherwise — what a dish card's add control binds to. */
+  pendingItemId: string | null;
+  /** Last failed operation's message — render it; a new operation clears it. */
+  error: string | null;
+  /** Order drawer visibility (OrderCartButton opens it, OrderCartDrawer renders by it). */
+  open: boolean;
+}
+
+const EMPTY: OrderCartState = { cart: null, ordering: null, orderingStatus: null, menuOrdering: null, fulfillment: null, busy: false, pendingItemId: null, error: null, open: false };
+
+let state: OrderCartState = EMPTY;
+const listeners = new Set<() => void>();
+let loaded = false;
+
+function setState(patch: Partial<OrderCartState>): void {
+  state = { ...state, ...patch };
+  for (const l of listeners) l();
+}
+
+export function getOrderCartState(): OrderCartState {
+  return state;
+}
+
+export function subscribeOrderCart(listener: () => void): () => void {
+  listeners.add(listener);
+  // First subscriber triggers the initial load (browser only — SSR renders the empty state).
+  if (!loaded && typeof window !== "undefined") {
+    loaded = true;
+    void refreshOrderCart();
+    void resolveOrdering().then((s) => setState({ ordering: s.status === "ENABLED", orderingStatus: s }));
+    void fetchMenuOrdering().then((m) => setState({ menuOrdering: m })).catch(() => setState({ menuOrdering: null }));
+    void fetchFulfillmentMethods().then((f) => setState({ fulfillment: f }));
+  }
+  return () => listeners.delete(listener);
+}
+
+/**
+ * Can dishes of `menuId` be added right now? false when the menu isn't enabled for online
+ * ordering under the operation or is outside its availability window (render no add control);
+ * null while the settings are still loading or could not be read — treat null as "try" (the add
+ * itself is refused server-side with a message).
+ */
+export function isMenuOrderable(menuId: string): boolean | null {
+  return menuOrderable(state.menuOrdering, menuId);
+}
+
+async function run(op: () => Promise<OrderCart>): Promise<void> {
+  setState({ busy: true, error: null });
+  try {
+    setState({ cart: await op(), busy: false });
+  } catch (e) {
+    setState({ busy: false, error: e instanceof Error ? e.message : String(e) });
+    throw e;
+  }
+}
+
+export async function refreshOrderCart(): Promise<void> {
+  try {
+    setState({ cart: await fetchOrderCart() });
+  } catch {
+    /* no cart yet — leave the empty state */
+  }
+}
+
+/**
+ * Add a dish (the MenuItem DTO as rendered, with the menu/section ids it is rendered under and
+ * the visitor's selection) to the order and open the drawer. Throws (and sets .error) on refusal.
+ */
+export async function addOrderLine(
+  item: MenuItem,
+  context: { menuId: string; sectionId: string },
+  quantity = 1,
+  selection?: OrderSelection,
+): Promise<void> {
+  setState({ pendingItemId: item.id });
+  try {
+    await run(() => apiAdd(item, context, quantity, selection));
+  } finally {
+    setState({ pendingItemId: null });
+  }
+  setState({ open: true });
+}
+
+export async function updateOrderLineQuantity(lineItemId: string, quantity: number): Promise<void> {
+  await run(() => apiUpdate(lineItemId, quantity));
+}
+
+export async function removeLineFromOrder(lineItemId: string): Promise<void> {
+  await run(() => apiRemove(lineItemId));
+}
+
+/** Navigate to the Wix-hosted checkout. Never hand-build a checkout URL. */
+export async function goToOrderCheckout(): Promise<void> {
+  setState({ busy: true, error: null });
+  try {
+    const url = await orderCheckoutUrl();
+    window.location.href = url;
+  } catch (e) {
+    setState({ busy: false, error: e instanceof Error ? e.message : String(e) });
+    throw e;
+  }
+}
+
+export function setOrderCartOpen(open: boolean): void {
+  setState({ open });
+}

package/skills/wix-headless-templates/restaurants/project/src/wix/restaurants/ordering-core.ts

@@ -0,0 +1,287 @@
+// Online-ordering rules and DTO mapping — transport-agnostic, imported by both ./ordering.ts (SDK)
+// and the REST twin in templates/restaurants/rest/ordering.ts (fetch). The restaurant cart rides
+// on the eCom current cart (Cart V2); what makes a line a RESTAURANT line is the catalogReference
+// built here: the Orders app id plus options { operationId, menuId, sectionId } and, exactly as
+// Wix's own ordering code sends them, the visitor's choices: options.priceVariant { id,
+// formattedPrice }, options.modifierGroups [{ id, modifiers: [{ id, price, formattedPrice }] }],
+// options.specialRequests. Raw entities carry `_id` (SDK) or `id` (REST). Has its own formatMoney
+// (a copy of ../money.ts) so it stands alone when stripped. Imports are type-only except the zone
+// helpers from ./time-core (deployed beside this file).
+import type { FulfillmentMethodInfo, MenuItem, MenuOrderingInfo, OrderCart, OrderLine, OrderSelection, OrderingStatus, SiteMoney, WeeklyWindow } from "./types";
+import type { ImgSrc, Raw } from "./menu-core";
+import { zonedMinutes, zonedParts } from "./time-core";
+
+/** The Restaurants Orders app id — every restaurant cart line's catalogReference.appId. */
+export const RESTAURANTS_ORDERS_APP_ID = "9a5d83fd-8570-482e-81ab-cfa88942ee60";
+
+export const rawId = (raw: Raw | undefined | null): string => raw?._id ?? raw?.id ?? "";
+
+/**
+ * Cart V2 money is ConvertedMoney { amount, convertedAmount } with NO formatted string, and the
+ * currency lives on the cart, not on the money. "" when the currency is unknown — never a guessed
+ * symbol, never a USD default.
+ */
+export function formatMoney(money: Raw | null | undefined, currencyCode: string | null | undefined): string {
+  const value = money?.convertedAmount ?? money?.amount;
+  if (value == null || value === "" || !currencyCode) return "";
+  try {
+    return new Intl.NumberFormat(undefined, { style: "currency", currency: currencyCode }).format(Number(value));
+  } catch {
+    return `${value} ${currencyCode}`;
+  }
+}
+
+/** A site-currency decimal ("5", "0") formatted for display; "" when zero or the currency is unknown. */
+function formatAmount(amount: string | null | undefined, money: SiteMoney): string {
+  const n = Number(amount ?? 0);
+  if (!Number.isFinite(n) || n <= 0 || !money.currency) return "";
+  try {
+    return new Intl.NumberFormat(money.locale || undefined, { style: "currency", currency: money.currency }).format(n);
+  } catch {
+    return `${n.toFixed(2)} ${money.currency}`;
+  }
+}
+
+export const cartCurrency = (raw: Raw | null | undefined): string =>
+  raw?.customerInfo?.currencyCode ?? raw?.businessInfo?.currencyCode ?? "";
+
+// ---- operation ----------------------------------------------------------------------------------------------
+
+const NO_ORDERING: OrderingStatus = { operationId: null, status: "NONE", pausedUntilIso: null, timeZone: "", fulfillmentIds: [], defaultFulfillmentType: null };
+
+const isoOf = (v: unknown): string | null => {
+  if (!v) return null;
+  const d = v instanceof Date ? v : new Date(String(v));
+  return Number.isNaN(d.getTime()) ? null : d.toISOString();
+};
+
+/**
+ * The operation to order through and its state: an ENABLED one, else the default, else the first.
+ * Only ENABLED accepts orders (Wix: AcceptingOrders = operation.enabled && a fulfillment); DISABLED
+ * and PAUSED_UNTIL (with `pausedUntilOptions.time`) refuse every add — surface the reason.
+ */
+export function resolveOperation(operations: Raw[]): OrderingStatus {
+  const op = operations.find((o) => o.onlineOrderingStatus === "ENABLED") ?? operations.find((o) => o.default) ?? operations[0];
+  if (!op || !rawId(op)) return NO_ORDERING;
+  const raw = String(op.onlineOrderingStatus ?? "");
+  const status: OrderingStatus["status"] = raw === "ENABLED" ? "ENABLED" : raw === "PAUSED_UNTIL" ? "PAUSED_UNTIL" : "DISABLED";
+  return {
+    operationId: rawId(op),
+    status,
+    pausedUntilIso: status === "PAUSED_UNTIL" ? isoOf(op.pausedUntilOptions?.time) : null,
+    timeZone: op.businessLocationDetails?.timeZone ?? "",
+    fulfillmentIds: ((op.fulfillmentIds ?? []) as string[]).filter(Boolean),
+    defaultFulfillmentType: op.defaultFulfillmentType === "DELIVERY" ? "DELIVERY" : op.defaultFulfillmentType === "PICKUP" ? "PICKUP" : null,
+  };
+}
+
+/** Kept for callers that only need the id — null when the site has no operation at all. */
+export function pickOperationId(operations: Raw[]): string | null {
+  return resolveOperation(operations).operationId;
+}
+
+// ---- menu ordering settings (per operation) ---------------------------------------------------------
+
+const DAYS: WeeklyWindow["day"][] = ["SUN", "MON", "TUE", "WED", "THU", "FRI", "SAT"];
+const hhmm = (t: Raw | undefined): string => `${String(t?.hours ?? 0).padStart(2, "0")}:${String(t?.minutes ?? 0).padStart(2, "0")}`;
+
+/** One menu's ordering settings entry → the DTO (availability windows normalised to "HH:mm" / ISO). */
+export function toMenuOrdering(raw: Raw): MenuOrderingInfo {
+  const a: Raw = raw.availability ?? {};
+  const type = String(a.type ?? "");
+  return {
+    menuId: raw.menuId ?? "",
+    enabled: raw.onlineOrderingEnabled !== false,
+    availability: {
+      type: type === "ALWAYS_AVAILABLE" || type === "WEEKLY_SCHEDULE" || type === "TIMESTAMP_RANGES" ? type : "UNSPECIFIED",
+      timeZone: a.timeZone ?? "",
+      weekly: ((a.weeklyScheduleOptions?.availableTimes ?? []) as Raw[]).flatMap((d) =>
+        ((d.timeRanges ?? []) as Raw[]).map((r): WeeklyWindow => ({ day: String(d.dayOfWeek) as WeeklyWindow["day"], start: hhmm(r.startTime), end: hhmm(r.endTime) })),
+      ),
+      ranges: ((a.timestampRangesOptions?.ranges ?? []) as Raw[])
+        .map((r) => ({ startIso: isoOf(r.startTime) ?? "", endIso: isoOf(r.endTime) ?? "" }))
+        .filter((r) => r.startIso && r.endIso),
+    },
+  };
+}
+
+/** The operation's menu settings keyed by menuId. */
+export function toMenuOrderingMap(raws: Raw[]): Record<string, MenuOrderingInfo> {
+  const out: Record<string, MenuOrderingInfo> = {};
+  for (const raw of raws) {
+    const info = toMenuOrdering(raw);
+    if (info.menuId) out[info.menuId] = info;
+  }
+  return out;
+}
+
+const toMinutes = (s: string): number => {
+  const [h, m] = s.split(":").map(Number);
+  return (h || 0) * 60 + (m || 0);
+};
+
+/** Whether the menu's availability window contains `now`, evaluated in the setting's own timezone. */
+export function isMenuAvailable(info: MenuOrderingInfo, now: Date = new Date()): boolean {
+  const { availability: a } = info;
+  if (a.type === "TIMESTAMP_RANGES") {
+    const t = now.getTime();
+    return a.ranges.some((r) => new Date(r.startIso).getTime() <= t && t < new Date(r.endIso).getTime());
+  }
+  if (a.type !== "WEEKLY_SCHEDULE") return true; // ALWAYS_AVAILABLE, or an unspecified type: don't block on it
+  const parts = zonedParts(now, a.timeZone);
+  const minutes = zonedMinutes(now, a.timeZone);
+  const today = DAYS[parts.weekday];
+  const yesterday = DAYS[(parts.weekday + 6) % 7];
+  return a.weekly.some((w) => {
+    const start = toMinutes(w.start), end = toMinutes(w.end);
+    if (w.day === today) return end > start ? start <= minutes && minutes < end : minutes >= start || minutes < end;
+    // a window that wraps past midnight also covers the early hours of the next day
+    return w.day === yesterday && end <= start && minutes < end;
+  });
+}
+
+/**
+ * Can dishes of `menuId` be added right now? true/false once the operation's menu settings are
+ * known; null while they are still loading or could not be read (the add itself is still refused
+ * server-side, with a message). A menu with no entry under the operation is not orderable.
+ */
+export function menuOrderable(map: Record<string, MenuOrderingInfo> | null, menuId: string, now: Date = new Date()): boolean | null {
+  if (!map) return null;
+  const info = map[menuId];
+  return !!info && info.enabled && isMenuAvailable(info, now);
+}
+
+// ---- fulfillment methods ----------------------------------------------------------------------------------
+
+/** The operation's enabled pickup/delivery methods (operation.fulfillmentIds, `enabled`), money formatted. */
+export function toFulfillmentMethods(raws: Raw[], fulfillmentIds: string[], money: SiteMoney): FulfillmentMethodInfo[] {
+  const wanted = new Set(fulfillmentIds);
+  return raws
+    .filter((m) => m.enabled === true && wanted.has(rawId(m)))
+    .map((m): FulfillmentMethodInfo => ({
+      id: rawId(m),
+      type: m.type === "DELIVERY" ? "DELIVERY" : "PICKUP",
+      name: m.name ?? "",
+      fee: formatAmount(m.fee, money),
+      feeAmount: m.fee ?? "0",
+      minOrderPrice: formatAmount(m.minOrderPrice, money),
+      minOrderPriceAmount: m.minOrderPrice ?? "0",
+    }));
+}
+
+// ---- cart --------------------------------------------------------------------------------------------------------
+
+export function toOrderLine(raw: Raw, currency: string, imgSrc: ImgSrc): OrderLine {
+  return {
+    lineItemId: rawId(raw), // the LINE id — what update/remove take, never the menu item id
+    itemName: raw.name?.original ?? "",
+    quantity: raw.quantityInfo?.confirmedQuantity ?? 0,
+    unitPrice: formatMoney(raw.pricing?.unitPrice, currency),
+    linePrice: formatMoney(raw.pricing?.totalPrice, currency),
+    imageUrl: imgSrc(raw.attributes?.image, 300, 300),
+    descriptionLines: ((raw.attributes?.descriptionLines ?? []) as Raw[])
+      .map((d) => {
+        const label = d.name?.original ?? "", value = d.plainText?.original ?? d.colorInfo?.original ?? "";
+        return label && value ? `${label}: ${value}` : value || label;
+      })
+      .filter(Boolean),
+    status: raw.status ?? "IN_STOCK", // not IN_STOCK → the line can't be checked out as-is
+  };
+}
+
+export function toOrderCart(raw: Raw | null, subtotal: string, imgSrc: ImgSrc): OrderCart {
+  const currency = cartCurrency(raw);
+  const lines = ((raw?.lineItems ?? []) as Raw[]).map((l) => toOrderLine(l, currency, imgSrc));
+  return { lines, itemCount: lines.reduce((n, l) => n + l.quantity, 0), subtotal, currency };
+}
+
+/** The after-discount subtotal from a cart estimate; "" when unknown. Fees, tax, delivery resolve at checkout. */
+export function estimateSubtotal(estimate: Raw | null | undefined, raw: Raw): string {
+  return formatMoney(estimate?.summary?.priceSummary?.subtotal, cartCurrency(raw));
+}
+
+/** The line-refusal reasons an add can't recover from — checked before any call. */
+export function assertOrderContext(itemId: string, menuId: string, sectionId: string): void {
+  if (!itemId || !menuId || !sectionId) throw new Error("addToOrder needs the item, menu, and section ids.");
+}
+
+/** Reject a dish that can't be ordered before any call is made — the message is what the visitor reads. */
+export function assertOrderable(item: Pick<MenuItem, "marketPrice" | "soldOut" | "name">): void {
+  if (item.marketPrice) throw new Error(`${item.name || "This dish"} is priced at the counter and can't be ordered online.`);
+  if (item.soldOut) throw new Error(`${item.name || "This dish"} is sold out.`);
+}
+
+/**
+ * The one catalogItems entry of an add — the Orders app id, the three context ids, and the
+ * visitor's choices in the exact option keys Wix's ordering sends: `priceVariant` (id + its
+ * formatted price), `modifierGroups` (the entity ids — a selection KEY resolves back to its id —
+ * each with `price` as the decimal up-charge and `formattedPrice` only when charged), and
+ * `specialRequests` when the item accepts one. Formatted strings are the DTO's (site currency).
+ */
+export function orderCatalogItem(
+  item: MenuItem,
+  ctx: { operationId: string; menuId: string; sectionId: string },
+  quantity: number,
+  selection: OrderSelection,
+): Raw {
+  const variant = item.variants.find((v) => v.variantId === selection.variantId);
+  const modifierGroups = item.modifierGroups
+    .map((g) => ({
+      id: g.id,
+      modifiers: (selection.modifiers[g.id] ?? [])
+        .map((key) => g.modifiers.find((m) => m.key === key))
+        .filter((m): m is MenuItem["modifierGroups"][number]["modifiers"][number] => !!m)
+        .map((m) => ({ id: m.id, price: m.additionalChargeAmount, ...(Number(m.additionalChargeAmount) > 0 && m.additionalCharge ? { formattedPrice: m.additionalCharge } : {}) })),
+    }))
+    .filter((g) => g.modifiers.length > 0);
+  const note = item.acceptsSpecialRequests ? selection.specialRequest.trim() : "";
+  return {
+    quantity,
+    catalogReference: {
+      catalogItemId: item.id,
+      appId: RESTAURANTS_ORDERS_APP_ID,
+      options: {
+        operationId: ctx.operationId,
+        menuId: ctx.menuId,
+        sectionId: ctx.sectionId,
+        ...(variant ? { priceVariant: { id: variant.variantId, formattedPrice: variant.price } } : {}),
+        ...(modifierGroups.length ? { modifierGroups } : {}),
+        ...(note ? { specialRequests: note } : {}),
+      },
+    },
+  };
+}
+
+/** Read the add result — a refused add still returns 200: a line whose status isn't IN_STOCK, or no line, is a refusal. */
+export function assertOrderAdded(cart: Raw | null | undefined, itemId: string): void {
+  // V2 nests the reference under `source` — a top-level lineItem.catalogReference no longer exists.
+  const line = ((cart?.lineItems ?? []) as Raw[]).find((l) => l.source?.catalogReference?.catalogItemId === itemId);
+  if (line?.status && line.status !== "IN_STOCK") {
+    throw new Error(`This dish isn't available right now (${String(line.status).toLowerCase().replace(/_/g, " ")}).`);
+  }
+  if (!line || line.quantityInfo?.confirmedQuantity === 0) {
+    throw new Error("The dish couldn't be added to the order — please try again.");
+  }
+}
+
+/** Refuse checkout for an empty order or any line not IN_STOCK — say which. */
+export function assertOrderCheckoutable(raw: Raw | null): void {
+  const lines: Raw[] = raw?.lineItems ?? [];
+  if (!lines.length) throw new Error("Your order is empty.");
+  const unavailable = lines.filter((l) => l.status && l.status !== "IN_STOCK");
+  if (unavailable.length) {
+    throw new Error(`Some dishes are no longer available: ${unavailable.map((l) => l.name?.original).filter(Boolean).join(", ")}.`);
+  }
+  if (!rawId(raw)) throw new Error("Checkout couldn't start: the order has no id.");
+}
+
+/** The message an add control shows when the operation refuses orders; "" when it accepts them. */
+export function orderingUnavailableReason(status: OrderingStatus | null): string {
+  if (!status) return "";
+  switch (status.status) {
+    case "ENABLED": return "";
+    case "PAUSED_UNTIL": return "Ordering is paused right now";
+    case "DISABLED": return "Ordering unavailable";
+    default: return "Ordering unavailable";
+  }
+}

package/skills/wix-headless-templates/restaurants/project/src/wix/restaurants/ordering.ts

@@ -0,0 +1,237 @@
+// Online ordering (Restaurants Orders + Wix eCom Cart V2) over the SDK — the only file that
+// touches the raw cart, operation, and settings entities on this transport. Rules and mappers
+// live in ./ordering-core (shared with the REST twin in templates/restaurants/rest/); this file is
+// the transport only. Copy as-is; extend by calling these exports, never by editing them. The
+// request shapes are exact and rewriting them is how carts break:
+//   - the catalogReference appId is the ORDERS app (9a5d83fd-…), never the Stores id;
+//   - options MUST carry operationId + menuId + sectionId (all three);
+//   - the visitor's choices ride in options.priceVariant / options.modifierGroups /
+//     options.specialRequests, the keys Wix's own ordering code sends (built in ordering-core).
+// Failures are loud: throws on a missing or paused ordering operation, an invalid selection,
+// unavailable lines, and an empty order at checkout — surface the message, don't swallow it.
+// docs: https://dev.wix.com/docs/api-reference/business-solutions/restaurants/online-orders/operations/list-operations.md
+// docs: https://dev.wix.com/docs/api-reference/business-solutions/restaurants/online-orders/menu-ordering-settings/query-menu-ordering-settings.md
+// docs: https://dev.wix.com/docs/api-reference/business-solutions/restaurants/online-orders/fulfillment-methods/list-fulfillment-methods.md
+// docs: https://dev.wix.com/docs/api-reference/business-solutions/restaurants/menus/items/items/list-items.md
+// docs: https://dev.wix.com/docs/api-reference/business-solutions/e-commerce/purchase-flow/cart-v2/get-current-cart.md
+// docs: https://dev.wix.com/docs/api-reference/business-solutions/e-commerce/purchase-flow/cart-v2/add-line-items-to-current-cart.md
+// docs: https://dev.wix.com/docs/api-reference/business-solutions/e-commerce/purchase-flow/cart-v2/update-line-items.md
+// docs: https://dev.wix.com/docs/api-reference/business-management/headless/redirects/create-redirect-session.md
+import {
+  operations as operationsModule,
+  fulfillmentMethods as fulfillmentModule,
+  menuOrderingSettings as menuSettingsModule,
+  items as itemsModule,
+} from "@wix/restaurants";
+import { currentCartV2 } from "@wix/ecom";
+import { redirects as redirectsModule } from "@wix/redirects";
+import { wixModule } from "../sdk";
+import { imgSrc } from "../media";
+import { fetchSiteMoney } from "./menu";
+import { initialSelection, nextCursor, validateSelection, type Raw } from "./menu-core";
+import {
+  RESTAURANTS_ORDERS_APP_ID,
+  assertOrderAdded,
+  assertOrderCheckoutable,
+  assertOrderContext,
+  assertOrderable,
+  estimateSubtotal,
+  orderCatalogItem,
+  rawId,
+  resolveOperation,
+  toFulfillmentMethods,
+  toMenuOrderingMap,
+  toOrderCart,
+} from "./ordering-core";
+import type { FulfillmentMethodInfo, MenuItem, MenuOrderingInfo, OrderCart, OrderSelection, OrderingStatus } from "./types";
+
+export { RESTAURANTS_ORDERS_APP_ID };
+
+const operationsApi = wixModule(operationsModule);
+const fulfillmentApi = wixModule(fulfillmentModule);
+const menuSettingsApi = wixModule(menuSettingsModule);
+const itemsApi = wixModule(itemsModule);
+const cartApi = wixModule(currentCartV2);
+const redirects = wixModule(redirectsModule);
+
+// The ordering operation is site config — resolve once, reuse for every add.
+let orderingPromise: Promise<OrderingStatus> | null = null;
+
+/**
+ * The operation to order through and its state (ENABLED, else the default, else the first).
+ * `status` "NONE" when the site has no online ordering configured; DISABLED / PAUSED_UNTIL refuse
+ * every add — the add control reads the reason from it.
+ */
+export function resolveOrdering(): Promise<OrderingStatus> {
+  orderingPromise ??= operationsApi
+    .listOperations()
+    .then((res: Raw) => resolveOperation(res.operations ?? []))
+    .catch(() => {
+      orderingPromise = null; // transient failure — allow a retry on the next call
+      return resolveOperation([]);
+    });
+  return orderingPromise;
+}
+
+/** The id of the operation to order through — null when the site has none. */
+export function resolveOperationId(): Promise<string | null> {
+  return resolveOrdering().then((s) => s.operationId);
+}
+
+/**
+ * Every menu's ordering settings under the operation, keyed by menuId: which menus take online
+ * orders and when (availability windows in their own timezone). A menu absent from the map is
+ * not orderable. {} when there is no operation.
+ */
+export async function fetchMenuOrdering(): Promise<Record<string, MenuOrderingInfo>> {
+  const { operationId } = await resolveOrdering();
+  if (!operationId) return {};
+  const raws: Raw[] = [];
+  let page = await menuSettingsApi.queryMenuOrderingSettings().eq("operationId", operationId).find();
+  raws.push(...(page.items as Raw[]));
+  while (page.hasNext()) {
+    page = await page.next();
+    raws.push(...(page.items as Raw[]));
+  }
+  return toMenuOrderingMap(raws);
+}
+
+/**
+ * The operation's enabled pickup/delivery methods (operation.fulfillmentIds only), fees and
+ * minimums formatted in the site currency — for display; the buyer picks one on the hosted checkout.
+ */
+export async function fetchFulfillmentMethods(): Promise<FulfillmentMethodInfo[]> {
+  try {
+    const [status, money] = await Promise.all([resolveOrdering(), fetchSiteMoney()]);
+    if (!status.fulfillmentIds.length) return [];
+    const raws: Raw[] = [];
+    let cursor: string | null = null;
+    do {
+      const res: Raw = await fulfillmentApi.listFulfillmentMethods(cursor ? { cursorPaging: { cursor } } : {});
+      raws.push(...((res.fulfillmentMethods ?? []) as Raw[]));
+      cursor = nextCursor(res);
+    } while (cursor);
+    return toFulfillmentMethods(raws, status.fulfillmentIds, money);
+  } catch {
+    return []; // display nicety — ordering still works without the list
+  }
+}
+
+// A line's attributes.image may come back absent — join the menu items' images by the line's
+// catalogItemId and cache for the session.
+const lineImageCache = new Map<string, string>();
+async function fillLineImages(cart: OrderCart, raws: Raw[]): Promise<void> {
+  const wanted = new Map<string, number[]>(); // itemId -> line indexes
+  raws.forEach((raw, i) => {
+    if (cart.lines[i].imageUrl) return;
+    const itemId = raw.source?.catalogReference?.catalogItemId;
+    if (!itemId) return;
+    const cached = lineImageCache.get(itemId);
+    if (cached !== undefined) {
+      cart.lines[i].imageUrl = cached;
+      return;
+    }
+    wanted.set(itemId, [...(wanted.get(itemId) ?? []), i]);
+  });
+  if (!wanted.size) return;
+  try {
+    const res: Raw = await itemsApi.listItems({ itemIds: [...wanted.keys()] });
+    for (const item of (res.items ?? []) as Raw[]) {
+      const url = imgSrc(item.image, 300, 300);
+      lineImageCache.set(rawId(item), url);
+      for (const i of wanted.get(rawId(item)) ?? []) cart.lines[i].imageUrl = url;
+    }
+  } catch {
+    /* images are a nicety — the cart stays correct without them */
+  }
+}
+
+async function readCartWithSubtotal(raw: Raw | null): Promise<OrderCart> {
+  // Only estimate a cart WITH lines — on an absent/empty cart the endpoint returns 404.
+  if (!raw?.lineItems?.length) return toOrderCart(raw, "", imgSrc);
+  // The authoritative after-discount subtotal comes from the cart estimate, never from
+  // hand-summing line items (fees, tax, and delivery resolve at checkout).
+  let subtotal = "";
+  try {
+    subtotal = estimateSubtotal(await cartApi.estimateCurrentCart(), raw);
+  } catch {
+    /* estimate is a display nicety — the cart itself is still valid */
+  }
+  const cart = toOrderCart(raw, subtotal, imgSrc);
+  await fillLineImages(cart, raw.lineItems as Raw[]);
+  return cart;
+}
+
+/** Read the visitor's current order cart. An empty cart (not an error) when none exists yet. */
+export async function fetchOrderCart(): Promise<OrderCart> {
+  try {
+    const { cart } = await cartApi.getCurrentCart();
+    return readCartWithSubtotal(cart as Raw);
+  } catch {
+    return toOrderCart(null, "", imgSrc);
+  }
+}
+
+/**
+ * Add a dish to the current order. `item` is the MenuItem DTO as rendered; `menuId` and
+ * `sectionId` are the ids of the menu and section it is RENDERED UNDER — thread them from the
+ * render context (the fetchMenus tree), never re-derive them. `selection` is what the visitor
+ * chose (start from initialSelection(item)); omitted → the item's defaults. Throws when ordering
+ * isn't accepting, the dish can't be ordered, a modifier rule fails, or the line is refused.
+ */
+export async function addToOrder(
+  item: MenuItem,
+  { menuId, sectionId }: { menuId: string; sectionId: string },
+  quantity = 1,
+  selection: OrderSelection = initialSelection(item),
+): Promise<OrderCart> {
+  const { operationId, status } = await resolveOrdering();
+  if (!operationId || status !== "ENABLED") throw new Error("Online ordering isn't available right now.");
+  assertOrderContext(item.id, menuId, sectionId);
+  assertOrderable(item);
+  const check = validateSelection(item, selection);
+  if (!check.ok) throw new Error(Object.values(check.errors)[0]);
+  const { cart } = await cartApi.addLineItemsToCurrentCart({
+    catalogItems: [orderCatalogItem(item, { operationId, menuId, sectionId }, quantity, selection)],
+  });
+  assertOrderAdded(cart as Raw, item.id);
+  return readCartWithSubtotal(cart as Raw);
+}
+
+/** Change a line's quantity. `lineItemId` is OrderLine.lineItemId, never the menu item id. */
+export async function updateOrderQuantity(lineItemId: string, quantity: number): Promise<OrderCart> {
+  const { cart } = await cartApi.updateLineItemsInCurrentCart({
+    lineItems: [{ lineItemId, quantity: { newQuantity: quantity } }],
+  });
+  return readCartWithSubtotal(cart as Raw);
+}
+
+/** Remove a line from the order by OrderLine.lineItemId. */
+export async function removeOrderLine(lineItemId: string): Promise<OrderCart> {
+  const { cart } = await cartApi.removeLineItemsFromCurrentCart([lineItemId]);
+  return readCartWithSubtotal(cart as Raw);
+}
+
+/**
+ * Start the Wix-hosted checkout for the current order and return the URL to navigate to.
+ * The cart's id IS the checkout id — no separate checkout-creation call. Fulfillment
+ * (pickup/delivery + time) and payment are collected on the hosted page. Call from the
+ * browser: the return origin must be window.location.origin (https), never a server-derived
+ * request origin (http behind the proxy → the return redirect 403s).
+ */
+export async function orderCheckoutUrl(): Promise<string> {
+  const { cart } = await cartApi.getCurrentCart();
+  const raw = cart as Raw;
+  assertOrderCheckoutable(raw);
+  const origin = typeof window !== "undefined" ? window.location.origin : "";
+  const session = await redirects.createRedirectSession({
+    ecomCheckout: { checkoutId: rawId(raw) },
+    callbacks: {
+      postFlowUrl: origin ? `${origin}/` : undefined,
+      thankYouPageUrl: origin ? `${origin}/` : undefined,
+    },
+  });
+  const url = session?.redirectSession?.fullUrl;
+  if (!url) throw new Error("Checkout couldn't start: no redirect URL returned.");
+  return url;
+}