@wix/agent-skills 1.20.1 → 1.22.0

package/skills/wix-headless-fast/references/restaurants/app/wix/restaurants/order-store.ts

@@ -1,103 +0,0 @@
-// 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.
-import type { OrderCart } from "./types";
-import {
-  addToOrder as apiAdd,
-  fetchOrderCart,
-  orderCheckoutUrl,
-  removeOrderLine as apiRemove,
-  resolveOperationId,
-  updateOrderQuantity as apiUpdate,
-} from "./ordering";
-
-export interface OrderCartState {
-  cart: OrderCart | null;
-  /** null while resolving; false → no ordering operation configured (show "unavailable"). */
-  ordering: boolean | null;
-  /** True while any cart operation is in flight. */
-  busy: boolean;
-  /** 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, busy: false, 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 resolveOperationId().then((id) => setState({ ordering: id !== null }));
-  }
-  return () => listeners.delete(listener);
-}
-
-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 menu item to the order and open the drawer. Throws (and sets .error) on refusal. */
-export async function addOrderLine(
-  itemId: string,
-  context: { menuId: string; sectionId: string },
-  quantity = 1,
-): Promise<void> {
-  await run(() => apiAdd(itemId, context, quantity));
-  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-fast/references/restaurants/app/wix/restaurants/ordering-core.ts

@@ -1,124 +0,0 @@
-// Online-ordering rules and DTO mapping — transport-agnostic, imported by both ./ordering.ts (SDK)
-// and the REST twin in references/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 } — all three, and
-// no variantId. 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.
-import type { FulfillmentMethodInfo, OrderCart, OrderLine } from "./types";
-import type { ImgSrc, Raw } from "./menu-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. Never hardcode a symbol or assume USD.
- */
-export function formatMoney(money: Raw | null | undefined, currencyCode: string | null | undefined): string {
-  const value = money?.convertedAmount ?? money?.amount;
-  if (value == null || value === "") return "";
-  const currency = currencyCode || "USD";
-  try {
-    return new Intl.NumberFormat(undefined, { style: "currency", currency }).format(Number(value));
-  } catch {
-    return `${value} ${currency}`;
-  }
-}
-
-export const cartCurrency = (raw: Raw | null | undefined): string =>
-  raw?.customerInfo?.currencyCode ?? raw?.businessInfo?.currencyCode ?? "";
-
-/** The operation to order through: ENABLED, else the default, else the first; null when none exists. */
-export function pickOperationId(operations: Raw[]): string | null {
-  const op = operations.find((o) => o.onlineOrderingStatus === "ENABLED") ?? operations.find((o) => o.default) ?? operations[0];
-  return op ? rawId(op) || null : null;
-}
-
-/** Enabled pickup/delivery methods, for display — fees and minimums as decimal strings. */
-export function toFulfillmentMethods(raws: Raw[]): FulfillmentMethodInfo[] {
-  return raws
-    .filter((m) => m.enabled === true)
-    .map((m): FulfillmentMethodInfo => ({
-      id: rawId(m),
-      type: m.type === "DELIVERY" ? "DELIVERY" : "PICKUP",
-      name: m.name ?? "",
-      fee: m.fee ?? "0",
-      minOrderPrice: m.minOrderPrice ?? "0",
-    }))
-    .filter((m) => m.id);
-}
-
-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.");
-}
-
-/**
- * The one catalogItems entry of an add: the Orders app id and the three context ids — the
- * restaurant analog of the store's variantId. Modifier/variant selections are NOT sent (that
- * options shape isn't documented for a client add); quantity only.
- */
-export function orderCatalogItem(itemId: string, ctx: { operationId: string; menuId: string; sectionId: string }, quantity: number): Raw {
-  return {
-    quantity,
-    catalogReference: {
-      catalogItemId: itemId,
-      appId: RESTAURANTS_ORDERS_APP_ID,
-      options: { operationId: ctx.operationId, menuId: ctx.menuId, sectionId: ctx.sectionId },
-    },
-  };
-}
-
-/** 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.");
-}

package/skills/wix-headless-fast/references/restaurants/app/wix/restaurants/ordering.ts

@@ -1,185 +0,0 @@
-// Online ordering (Restaurants Orders + Wix eCom Cart V2) over the SDK — the only file that
-// touches the raw cart and operation entities on this transport. Rules and mappers live in
-// ./ordering-core (shared with the REST twin in references/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) — no variantId;
-//   - modifier/variant selections are NOT sent on the line (undocumented for a client add).
-// Failures are loud: throws on a missing ordering operation, 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/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, 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 {
-  RESTAURANTS_ORDERS_APP_ID,
-  assertOrderAdded,
-  assertOrderCheckoutable,
-  assertOrderContext,
-  estimateSubtotal,
-  orderCatalogItem,
-  pickOperationId,
-  rawId,
-  toFulfillmentMethods,
-  toOrderCart,
-} from "./ordering-core";
-import type { Raw } from "./menu-core";
-import type { FulfillmentMethodInfo, OrderCart } from "./types";
-
-export { RESTAURANTS_ORDERS_APP_ID };
-
-const operationsApi = wixModule(operationsModule);
-const fulfillmentApi = wixModule(fulfillmentModule);
-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 operationIdPromise: Promise<string | null> | null = null;
-
-/**
- * The id of the operation to order through (ENABLED, else default, else first) — null when
- * the site has no online ordering configured (show an "ordering unavailable" state).
- */
-export function resolveOperationId(): Promise<string | null> {
-  operationIdPromise ??= operationsApi
-    .listOperations()
-    .then((res: Raw) => pickOperationId(res.operations ?? []))
-    .catch(() => {
-      operationIdPromise = null; // transient failure — allow a retry on the next call
-      return null;
-    });
-  return operationIdPromise;
-}
-
-/** Enabled pickup/delivery methods, for display — the buyer picks one on the hosted checkout. */
-export async function fetchFulfillmentMethods(): Promise<FulfillmentMethodInfo[]> {
-  try {
-    const res: Raw = await fulfillmentApi.listFulfillmentMethods();
-    return toFulfillmentMethods(res.fulfillmentMethods ?? []);
-  } 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 menu item to the current order. `menuId` and `sectionId` are the ids of the menu and
- * section the item is RENDERED UNDER — thread them from the render context (the fetchMenus
- * tree), never re-derive them. Throws when ordering isn't configured or the line is refused.
- */
-export async function addToOrder(
-  itemId: string,
-  { menuId, sectionId }: { menuId: string; sectionId: string },
-  quantity = 1,
-): Promise<OrderCart> {
-  const operationId = await resolveOperationId();
-  if (!operationId) throw new Error("Online ordering isn't available right now.");
-  assertOrderContext(itemId, menuId, sectionId);
-  const { cart } = await cartApi.addLineItemsToCurrentCart({
-    catalogItems: [orderCatalogItem(itemId, { operationId, menuId, sectionId }, quantity)],
-  });
-  assertOrderAdded(cart as Raw, itemId);
-  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;
-}

package/skills/wix-headless-fast/references/restaurants/app/wix/restaurants/reservation-store.ts

@@ -1,193 +0,0 @@
-// The table-reservation state machine as a framework-free store — the logic behind useReservation,
-// usable from React (useReservation wraps it), from a static page or Vue/Svelte, or as the
-// specification for a port. Location, date + party size, AVAILABLE slots, the 10-minute hold, the
-// details form, and confirm. All correctness (AVAILABLE-only slots, hold → reserve with the
-// revision, firstName + E.164 phone, RESERVED vs REQUESTED) lives in the data layer; this store
-// orchestrates. Browser-only: availability is timezone-specific. One store per mounted surface:
-// createReservationStore(), `start()` when mounted.
-import { completeReservation, fetchReservationLocations, fetchReservationSlots, holdReservation } from "./reservations";
-import type { ReservationConfirmation, ReservationHold, ReservationLocationInfo, ReservationReservee, ReservationSlot } from "./types";
-
-const todayKey = (): string => {
-  const d = new Date();
-  const pad = (n: number) => String(n).padStart(2, "0");
-  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())}`;
-};
-
-/** Everything a reservation surface renders from. Read it with getState() or through a subscription. */
-export interface ReservationState {
-  /** null while loading; [] when Table Reservations isn't set up (honest empty state). */
-  locations: ReservationLocationInfo[] | null;
-  /** The active location (default first). Render a picker only when locations.length > 1. */
-  location: ReservationLocationInfo | null;
-  /** "YYYY-MM-DD" for a date input. */
-  date: string;
-  /** "HH:mm" anchor for the slot fan-out. */
-  time: string;
-  /** Clamped to the location's partySizeMin/Max. */
-  partySize: number;
-  /** AVAILABLE slots for the current query; null until findSlots ran. */
-  slots: ReservationSlot[] | null;
-  /** Set after holdSlot — the visitor has 10 minutes to confirm. */
-  held: ReservationHold | null;
-  reservee: ReservationReservee;
-  /** True when a slot is held and firstName + phone are filled — gate the confirm CTA. */
-  canConfirm: boolean;
-  /** Set on success. REQUESTED → tell the visitor approval is pending, not confirmed. */
-  confirmed: ReservationConfirmation | null;
-  loading: boolean;
-  error: string | null;
-}
-
-export interface ReservationStore {
-  getState(): ReservationState;
-  subscribe(listener: () => void): () => void;
-  /** Load the locations. Call once when mounted (a browser). */
-  start(): void;
-  stop(): void;
-  setLocationId(id: string): void;
-  setDate(date: string): void;
-  setTime(time: string): void;
-  setPartySize(size: number): void;
-  findSlots(): Promise<void>;
-  holdSlot(slot: ReservationSlot): Promise<void>;
-  setReserveeField(field: keyof ReservationReservee, value: string): void;
-  confirm(): Promise<void>;
-  /** Back to slot picking (keeps date/party). */
-  reset(): void;
-}
-
-export function createReservationStore(): ReservationStore {
-  let locations: ReservationLocationInfo[] | null = null;
-  let locationId: string | null = null;
-  let date = todayKey();
-  let time = "19:00";
-  let partySize = 2;
-  let slots: ReservationSlot[] | null = null;
-  let held: ReservationHold | null = null;
-  let reservee: ReservationReservee = { firstName: "", phone: "" };
-  let confirmed: ReservationConfirmation | null = null;
-  let loading = false;
-  let error: string | null = null;
-  let started = false;
-  const listeners = new Set<() => void>();
-  let snapshot: ReservationState | null = null;
-  const emit = () => {
-    snapshot = null;
-    for (const fn of listeners) fn();
-  };
-
-  const currentLocation = (): ReservationLocationInfo | null => locations?.find((l) => l.id === locationId) ?? locations?.[0] ?? null;
-
-  function getState(): ReservationState {
-    if (snapshot) return snapshot;
-    snapshot = {
-      locations,
-      location: currentLocation(),
-      date,
-      time,
-      partySize,
-      slots,
-      held,
-      reservee,
-      canConfirm: !!held && reservee.firstName.trim().length > 0 && reservee.phone.trim().length > 0 && !loading,
-      confirmed,
-      loading,
-      error,
-    };
-    return snapshot;
-  }
-
-  const fail = (e: unknown) => (e instanceof Error ? e.message : String(e));
-
-  return {
-    getState,
-    subscribe(fn) {
-      listeners.add(fn);
-      return () => listeners.delete(fn);
-    },
-    start() {
-      if (started) return;
-      started = true;
-      fetchReservationLocations()
-        .then((locs) => {
-          if (!started) return;
-          locations = locs;
-          locationId ??= locs[0]?.id ?? null;
-          emit();
-        })
-        .catch((e) => {
-          if (!started) return;
-          locations = [];
-          error = fail(e);
-          emit();
-        });
-    },
-    stop() {
-      started = false;
-    },
-    setLocationId(id) { locationId = id; emit(); },
-    setDate(next) { date = next; emit(); },
-    setTime(next) { time = next; emit(); },
-    setPartySize(size) {
-      const loc = currentLocation();
-      const min = loc?.partySizeMin ?? 1;
-      const max = loc?.partySizeMax ?? 20;
-      partySize = Math.min(Math.max(size, min), max);
-      emit();
-    },
-    async findSlots() {
-      const loc = currentLocation();
-      if (!loc) return;
-      error = null; slots = null; held = null; confirmed = null; loading = true;
-      emit();
-      try {
-        const aroundIso = new Date(`${date}T${time}:00`).toISOString();
-        slots = await fetchReservationSlots(loc.id, aroundIso, partySize);
-      } catch (e) {
-        slots = [];
-        error = fail(e);
-      } finally {
-        loading = false;
-        emit();
-      }
-    },
-    async holdSlot(slot) {
-      const loc = currentLocation();
-      if (!loc) return;
-      error = null; loading = true;
-      emit();
-      try {
-        held = await holdReservation(loc.id, slot.startIso, partySize);
-      } catch (e) {
-        error = fail(e);
-      } finally {
-        loading = false;
-        emit();
-      }
-    },
-    setReserveeField(field, value) {
-      reservee = { ...reservee, [field]: value };
-      emit();
-    },
-    async confirm() {
-      if (!held) return;
-      error = null; loading = true;
-      emit();
-      try {
-        confirmed = await completeReservation(held, reservee);
-      } catch (e) {
-        // An expired hold can't be reserved — send the visitor back to slot picking.
-        error = fail(e);
-        held = null;
-      } finally {
-        loading = false;
-        emit();
-      }
-    },
-    reset() {
-      held = null; confirmed = null; slots = null; error = null;
-      emit();
-    },
-  };
-}