@wix/agent-skills 1.15.0 → 1.16.0

package/skills/wix-vibe-headless/references/restaurants/app/components/OrderCartButton.jsx

@@ -0,0 +1,21 @@
+// Header order trigger — an icon button with a live item-count badge. Drop into the app header;
+// opens the OrderCartDrawer. Icon-only by design (no text): reads the header's currentColor, so it
+// inherits the brand automatically.
+import { useOrderCart } from "@/context/OrderCartContext";
+
+export default function OrderCartButton() {
+  const { itemCount, setIsOpen } = useOrderCart();
+  return (
+    <button onClick={() => setIsOpen(true)} aria-label={`Open order${itemCount ? `, ${itemCount} item${itemCount > 1 ? "s" : ""}` : ""}`}
+      className="relative inline-flex items-center justify-center w-10 h-10 p-0 cursor-pointer bg-transparent text-current border-none rounded-sm">
+      <svg width="22" height="22" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="1.8" strokeLinecap="round" strokeLinejoin="round" aria-hidden="true">
+        <path d="M6 2 3 6v14a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2V6l-3-4Z" />
+        <path d="M3 6h18" />
+        <path d="M16 10a4 4 0 0 1-8 0" />
+      </svg>
+      {itemCount > 0 && (
+        <span className="absolute -top-0.5 -right-0.5 min-w-[18px] h-[18px] px-[5px] inline-flex items-center justify-center text-[11px] font-semibold bg-primary text-primary-foreground rounded-full">{itemCount}</span>
+      )}
+    </button>
+  );
+}

package/skills/wix-vibe-headless/references/restaurants/app/components/OrderCartDrawer.jsx

@@ -0,0 +1,60 @@
+// Slide-over order cart. Reads everything from useOrderCart(); mutate by lineItem.id (NOT the menu
+// item id), check out via the context (redirect-session URL). The eCom cart price
+// (line.price.formattedAmount) DOES include the currency symbol, unlike menu prices. Styled with
+// base44 design tokens (shadcn Tailwind classes). Mount it once in the Layout.
+import { useOrderCart } from "@/context/OrderCartContext";
+
+export default function OrderCartDrawer() {
+  const { cart, isOpen, setIsOpen, removeItem, updateQuantity, checkout, loading } = useOrderCart();
+  const lineItems = cart?.lineItems ?? [];
+  if (!isOpen) return null;
+
+  return (
+    <div onClick={() => setIsOpen(false)} className="fixed inset-0 z-50 bg-black/40 flex justify-end">
+      <aside onClick={(e) => e.stopPropagation()}
+        className="w-[min(420px,100%)] h-full flex flex-col bg-background text-foreground border-l border-border font-body">
+        <header className="flex justify-between items-center p-4 border-b border-border">
+          <strong className="font-display">Your order</strong>
+          <button onClick={() => setIsOpen(false)} aria-label="Close order"
+            className="border-none bg-transparent cursor-pointer text-xl text-muted-foreground">×</button>
+        </header>
+
+        <div className="flex-1 overflow-y-auto p-4">
+          {lineItems.length === 0 ? (
+            <p className="text-muted-foreground">Your order is empty.</p>
+          ) : lineItems.map((line) => (
+            <div key={line.id} className="flex gap-3 py-3 border-b border-border">
+              {/* line.id is the lineItemId for mutations — NOT the menu item id */}
+              <div className="flex-1 flex flex-col gap-1">
+                <span className="font-semibold">{line.productName?.original}</span>
+                <div className="flex items-center gap-2 mt-1">
+                  <QtyButton onClick={() => updateQuantity(line.id, Math.max(1, line.quantity - 1))}>−</QtyButton>
+                  <span className="min-w-[20px] text-center">{line.quantity}</span>
+                  <QtyButton onClick={() => updateQuantity(line.id, line.quantity + 1)}>+</QtyButton>
+                  <button onClick={() => removeItem(line.id)}
+                    className="ml-auto border-none bg-transparent cursor-pointer text-muted-foreground text-[13px] underline">Remove</button>
+                </div>
+              </div>
+              {/* eCom cart price DOES include the currency symbol (unlike menu prices) */}
+              <span className="font-semibold">{line.price?.formattedAmount}</span>
+            </div>
+          ))}
+        </div>
+
+        {lineItems.length > 0 && (
+          <footer className="p-4 border-t border-border">
+            <button disabled={loading} onClick={checkout}
+              className="w-full p-3 cursor-pointer bg-primary text-primary-foreground border-none rounded-sm text-[15px] font-semibold disabled:opacity-60 disabled:cursor-wait">Checkout</button>
+          </footer>
+        )}
+      </aside>
+    </div>
+  );
+}
+
+function QtyButton({ children, onClick }) {
+  return (
+    <button onClick={onClick}
+      className="w-7 h-7 cursor-pointer leading-none bg-card text-foreground border border-border rounded-sm">{children}</button>
+  );
+}

package/skills/wix-vibe-headless/references/restaurants/app/context/OrderCartContext.jsx

@@ -0,0 +1,63 @@
+// Order-cart state — mirrors the Wix SERVER cart (never a local copy). Wrap the app in
+// <OrderCartProvider>; every component reads useOrderCart(). It also resolves the ordering
+// Operation once on mount (restaurant lines REQUIRE an operationId) and exposes `ordering` — false
+// when no operation is configured, so the UI shows an "ordering unavailable" state instead of
+// throwing. Data wiring is correct as-is — do not restyle or re-derive it.
+import { createContext, useContext, useState, useEffect, useCallback } from "react";
+import {
+  getCurrentCart,
+  getDefaultOperation,
+  addItemToCart,
+  removeFromCart as apiRemove,
+  updateCartItemQuantity as apiQty,
+  checkout as apiCheckout,
+} from "@/rest/wix-restaurants-ordering";
+
+const OrderCartContext = createContext(null);
+
+export function OrderCartProvider({ children }) {
+  const [cart, setCart] = useState(null);
+  const [operation, setOperation] = useState(null);
+  const [isOpen, setIsOpen] = useState(false);
+  const [loading, setLoading] = useState(false);
+
+  const refreshCart = useCallback(async () => setCart(await getCurrentCart()), []);
+  useEffect(() => {
+    getDefaultOperation().then(setOperation);              // null when no operation is configured
+    refreshCart();
+    const onVisible = () => document.visibilityState === "visible" && refreshCart();
+    document.addEventListener("visibilitychange", onVisible);
+    return () => document.removeEventListener("visibilitychange", onVisible);
+  }, [refreshCart]);
+
+  const itemCount = (cart?.lineItems ?? []).reduce((n, li) => n + (li.quantity || 0), 0);
+
+  // A menu item carries its menuId/sectionId from the getFullMenu tree — the caller passes both.
+  // addItemToCart throws on a missing operation/menu/section or an unavailable line; let it propagate.
+  const addItem = async (item, { menuId, sectionId }, qty = 1) => {
+    if (!operation) throw new Error("Online ordering isn't available for this restaurant right now.");
+    setLoading(true);
+    try {
+      setCart(await addItemToCart(item.id, { operationId: operation.id, menuId, sectionId, quantity: qty }));
+      setIsOpen(true);
+    } finally { setLoading(false); }
+  };
+  const removeItem = async (lineItemId) => { setLoading(true); try { setCart(await apiRemove(lineItemId)); } finally { setLoading(false); } };
+  const updateQuantity = async (lineItemId, qty) => { setLoading(true); try { setCart(await apiQty(lineItemId, qty)); } finally { setLoading(false); } };
+  const checkout = async () => { setLoading(true); try { window.location.href = await apiCheckout(); } finally { setLoading(false); } };
+
+  return (
+    <OrderCartContext.Provider value={{
+      cart, operation, ordering: Boolean(operation), itemCount, isOpen, setIsOpen, loading,
+      addItem, removeItem, updateQuantity, checkout, refreshCart,
+    }}>
+      {children}
+    </OrderCartContext.Provider>
+  );
+}
+
+export function useOrderCart() {
+  const ctx = useContext(OrderCartContext);
+  if (!ctx) throw new Error("useOrderCart must be used within <OrderCartProvider>");
+  return ctx;
+}

package/skills/wix-vibe-headless/references/restaurants/app/hooks/useItemOrder.js

@@ -0,0 +1,32 @@
+// useItemOrder — the item-dialog's add-to-cart logic, no markup: gate on stock + whether ordering
+// is available, hold the quantity, and add the line through the order cart. The shipped
+// addItemToCart sends operationId + menuId + sectionId + quantity only — the restaurants
+// catalogReference.options shape for price-variant / modifier selections is NOT documented for
+// client add-to-cart, so modifier groups are DISPLAYED for the diner but not sent (see the dialog
+// and INSTRUCTIONS "Extending"). Keep this gating verbatim; the dialog only renders what it returns.
+import { useState } from "react";
+import { useOrderCart } from "@/context/OrderCartContext";
+
+export function useItemOrder(item, { menuId, sectionId }) {
+  const { addItem, ordering } = useOrderCart();
+  const [quantity, setQuantity] = useState(1);
+  const [adding, setAdding] = useState(false);
+  const [error, setError] = useState(null);
+
+  const inStock = item?.orderSettings?.inStock !== false;
+  const canAdd = ordering && inStock && !adding;
+
+  async function submit() {
+    setError(null);
+    setAdding(true);
+    try {
+      await addItem(item, { menuId, sectionId }, quantity);   // opens the cart drawer on success
+    } catch (e) {
+      setError(e.message);                                     // out-of-stock / no operation surfaces here
+    } finally {
+      setAdding(false);
+    }
+  }
+
+  return { quantity, setQuantity, inStock, ordering, canAdd, adding, error, submit };
+}

package/skills/wix-vibe-headless/references/restaurants/app/hooks/useReservation.js

@@ -0,0 +1,73 @@
+// useReservation — all table-reservation flow logic, no markup. The bug-prone parts are here and
+// must stay verbatim: skip archived locations; offer only AVAILABLE slots; a HELD reservation
+// carries the { id, revision } that reserveReservation NEEDS and expires in 10 minutes; the
+// confirmed status is RESERVED (auto-approved) or REQUESTED (manual approval pending). firstName +
+// phone (E.164, e.g. "+15551234567") are mandatory. The page only renders what this returns.
+import { useState, useEffect, useCallback } from "react";
+import {
+  listReservationLocations,
+  getTimeSlots,
+  createHeldReservation,
+  reserveReservation,
+} from "@/rest/wix-restaurants-reservations";
+
+const today = () => new Date().toISOString().slice(0, 10);   // yyyy-mm-dd for the date input
+
+export function useReservation() {
+  const [locations, setLocations] = useState(null);
+  const [locationId, setLocationId] = useState(null);
+  const [date, setDate] = useState(today());
+  const [partySize, setPartySize] = useState(2);
+  const [slots, setSlots] = useState(null);                  // AVAILABLE slots for the current query
+  const [held, setHeld] = useState(null);                    // { id, revision, ... } after hold
+  const [reservee, setReservee] = useState({ firstName: "", lastName: "", phone: "", email: "" });
+  const [confirmed, setConfirmed] = useState(null);          // reservation after reserve
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+
+  useEffect(() => {
+    listReservationLocations().then((locs) => {
+      const active = locs.filter((l) => l.archived !== true);   // archived locations are hidden
+      setLocations(active);
+      setLocationId(active.find((l) => l.default)?.id ?? active[0]?.id ?? null);
+    });
+  }, []);
+
+  // The chosen slot's ISO datetime is passed to hold (getTimeSlots wants an ISO datetime for `date`).
+  const findSlots = useCallback(async () => {
+    if (!locationId) return;
+    setError(null); setSlots(null); setHeld(null); setConfirmed(null); setLoading(true);
+    try {
+      const iso = new Date(`${date}T19:00:00`).toISOString();
+      const { availableTimeSlots } = await getTimeSlots(locationId, iso, partySize);
+      setSlots(availableTimeSlots);
+    } catch (e) { setError(e.message); } finally { setLoading(false); }
+  }, [locationId, date, partySize]);
+
+  const holdSlot = async (slot) => {
+    setError(null); setLoading(true);
+    try { setHeld(await createHeldReservation(locationId, slot.startDate, partySize)); }
+    catch (e) { setError(e.message); } finally { setLoading(false); }
+  };
+
+  const confirm = async () => {
+    if (!held) return;
+    setError(null); setLoading(true);
+    try {
+      const clean = { firstName: reservee.firstName, phone: reservee.phone };
+      if (reservee.lastName) clean.lastName = reservee.lastName;
+      if (reservee.email) clean.email = reservee.email;
+      setConfirmed(await reserveReservation(held.id, held.revision, clean));
+    } catch (e) { setError(e.message); setHeld(null); } finally { setLoading(false); }
+  };
+
+  const reset = () => { setHeld(null); setConfirmed(null); setSlots(null); setError(null); };
+
+  return {
+    locations, locationId, setLocationId,
+    date, setDate, partySize, setPartySize,
+    slots, findSlots, held, holdSlot,
+    reservee, setReservee, confirm, confirmed, reset,
+    loading, error,
+  };
+}

package/skills/wix-vibe-headless/references/restaurants/app/pages/Menu.jsx

@@ -0,0 +1,28 @@
+// Menu page — the restaurant's main render surface. Loads the assembled getFullMenu() tree once,
+// renders it via MenuList, and opens ItemDialog for a tapped dish (add-to-order lives there).
+// Empty state when there are no menus. Styled with base44 design tokens (shadcn Tailwind classes).
+import { useEffect, useState } from "react";
+import { getFullMenu } from "@/rest/wix-restaurants-menu";
+import MenuList from "@/components/MenuList";
+import ItemDialog from "@/components/ItemDialog";
+
+export default function Menu() {
+  const [menus, setMenus] = useState(null);
+  const [active, setActive] = useState(null);   // { item, menuId, sectionId }
+
+  useEffect(() => { getFullMenu().then(({ menus }) => setMenus(menus)); }, []);
+
+  return (
+    <main className="max-w-[1040px] mx-auto p-4">
+      <h1 className="font-display mb-4">Menu</h1>
+      {menus === null
+        ? <p className="text-muted-foreground">Loading…</p>
+        : <MenuList menus={menus} onOpenItem={(item, ctx) => setActive({ item, ...ctx })}
+            empty="No menu yet — add one from your Wix dashboard." />}
+      {active && (
+        <ItemDialog item={active.item} menuId={active.menuId} sectionId={active.sectionId}
+          onClose={() => setActive(null)} />
+      )}
+    </main>
+  );
+}

package/skills/wix-vibe-headless/references/restaurants/app/pages/Reservations.jsx

@@ -0,0 +1,102 @@
+// Reservations page — thin view over useReservation (all flow logic lives in the hook). Location
+// picker → date + party size → AVAILABLE slots → hold → details → confirm. Reads the confirmed
+// reservation's top-level status: RESERVED is confirmed, REQUESTED means the location needs manual
+// approval (pending). Styled with base44 design tokens (shadcn Tailwind classes).
+import { useReservation } from "@/hooks/useReservation";
+
+const field = "w-full py-2.5 px-3 box-border border border-input rounded-sm bg-background text-foreground font-body";
+const primaryBtn = "py-3 px-6 cursor-pointer border-none rounded-sm bg-primary text-primary-foreground text-[15px] font-semibold";
+
+function slotLabel(iso) {
+  return new Date(iso).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" });
+}
+function locationLabel(loc) {
+  return loc.location?.name || loc.location?.address?.formatted || "Main location";
+}
+
+export default function Reservations() {
+  const r = useReservation();
+
+  if (r.locations === null) return <Centered>Loading…</Centered>;
+  if (r.locations.length === 0) return <Centered>Reservations aren't set up yet — enable Table Reservations in your Wix dashboard.</Centered>;
+
+  if (r.confirmed) {
+    const d = r.confirmed.details || {};
+    const pending = r.confirmed.status === "REQUESTED";
+    return (
+      <main className={wrap}>
+        <h1 className="font-display">{pending ? "Reservation requested" : "You're booked!"}</h1>
+        <p className="text-muted-foreground">
+          {pending
+            ? "The restaurant will confirm your request shortly."
+            : "Your table is confirmed. See you soon!"}
+        </p>
+        <p>{d.partySize} guests · {d.startDate && new Date(d.startDate).toLocaleString()}</p>
+        <button className={primaryBtn} onClick={r.reset}>Make another reservation</button>
+      </main>
+    );
+  }
+
+  return (
+    <main className={wrap}>
+      <h1 className="font-display mb-4">Reserve a table</h1>
+
+      <div className="grid gap-4 [grid-template-columns:repeat(auto-fit,minmax(160px,1fr))]">
+        {r.locations.length > 1 && (
+          <label>Location
+            <select value={r.locationId ?? ""} onChange={(e) => r.setLocationId(e.target.value)} className={field}>
+              {r.locations.map((loc) => <option key={loc.id} value={loc.id}>{locationLabel(loc)}</option>)}
+            </select>
+          </label>
+        )}
+        <label>Date
+          <input type="date" value={r.date} onChange={(e) => r.setDate(e.target.value)} className={field} />
+        </label>
+        <label>Guests
+          <input type="number" min={1} value={r.partySize}
+            onChange={(e) => r.setPartySize(Math.max(1, Number(e.target.value) || 1))} className={field} />
+        </label>
+      </div>
+
+      <div className="mt-4">
+        <button className={primaryBtn} disabled={r.loading} onClick={r.findSlots}>Find a table</button>
+      </div>
+
+      {r.error && <p className="text-destructive">{r.error}</p>}
+
+      {r.slots && !r.held && (
+        r.slots.length === 0
+          ? <p className="text-muted-foreground mt-4">No tables available then — try another date or party size.</p>
+          : <div className="flex flex-wrap gap-2 mt-4">
+              {r.slots.map((slot) => (
+                <button key={slot.startDate} onClick={() => r.holdSlot(slot)} disabled={r.loading}
+                  className="py-2.5 px-4 cursor-pointer border border-border rounded-sm bg-card text-foreground font-semibold">{slotLabel(slot.startDate)}</button>
+              ))}
+            </div>
+      )}
+
+      {r.held && (
+        <form onSubmit={(e) => { e.preventDefault(); r.confirm(); }}
+          className="mt-6 flex flex-col gap-3 max-w-[420px]">
+          <p className="m-0 text-muted-foreground">
+            Holding your table for 10 minutes — enter your details to confirm.
+          </p>
+          <input required placeholder="First name *" value={r.reservee.firstName}
+            onChange={(e) => r.setReservee({ ...r.reservee, firstName: e.target.value })} className={field} />
+          <input placeholder="Last name" value={r.reservee.lastName}
+            onChange={(e) => r.setReservee({ ...r.reservee, lastName: e.target.value })} className={field} />
+          <input required placeholder="Phone (e.g. +15551234567) *" value={r.reservee.phone}
+            onChange={(e) => r.setReservee({ ...r.reservee, phone: e.target.value })} className={field} />
+          <input type="email" placeholder="Email" value={r.reservee.email}
+            onChange={(e) => r.setReservee({ ...r.reservee, email: e.target.value })} className={field} />
+          <button type="submit" className={primaryBtn} disabled={r.loading}>Confirm reservation</button>
+        </form>
+      )}
+    </main>
+  );
+}
+
+const wrap = "max-w-[1040px] mx-auto p-4";
+function Centered({ children }) {
+  return <div className="p-12 text-center text-muted-foreground">{children}</div>;
+}

package/skills/wix-vibe-headless/references/restaurants/seed/SEED.md

@@ -0,0 +1,180 @@
+# Restaurants — seeding
+
+Seed a Wix Restaurants site by **calling `seed-restaurants.js`** — don't hand-write the REST calls.
+It's a build-time module (run via `exec_tool`, not shipped in the app) that abstracts every seed
+operation across the vertical's four recipes: the **menu** (always) plus three on-demand add-ons —
+**online ordering**, **table reservations**, and **experiences**. `require` it and call the functions
+with plain data.
+
+> **NOT yet live-verified — transcribed from `setup-restaurants.md`, `setup-restaurant-orders.md`,
+> `setup-restaurant-reservations.md`, `setup-restaurant-experiences.md`.**
+
+## Default: one call
+
+`setupRestaurants(ctx, plan)` does the whole seed in one call — installs the Menus app and builds the
+menu **bottom-up (items → sections → menu)** with ids kept in memory, so you never hand-thread ids
+across exec calls. Online ordering and table reservations run only when the plan asks for them.
+
+```js
+// build-time exec_tool
+const { accessToken } = await base44.asServiceRole.connectors.getConnection("wix"); // Base44 (generic: use $TOKEN)
+const fs = require("fs");
+// exec_tool's require can return EMPTY exports for these build-time modules — load the file itself:
+const seed = (() => { const m = { exports: {} };
+  new Function("module", "exports", "require", fs.readFileSync("/app/.agents/skills/wix-vibe-headless/references/restaurants/seed/seed-restaurants.js", "utf8"))(m, m.exports, require);
+  return m.exports; })();
+const ctx = { token: accessToken, siteId: WIX_METASITE_ID };
+
+const result = await seed.setupRestaurants(ctx, {
+  menu: {
+    name: "Dinner", description: "Evening menu",
+    sections: [
+      { name: "Antipasti", description: "To start", items: [
+        // imageUrl per item is optional and attached IN this one call. It must be the FINAL
+        // https://media.base44.com/... url from the COMPLETED generate_image (it runs in the background
+        // while you build — wait for it), never a still-generating /__generating__/<id>.png placeholder.
+        { name: "Bruschetta al Pomodoro", description: "Grilled sourdough, San Marzano tomatoes, basil.", price: 9.50, imageUrl: "https://media.base44.com/…" },
+      ] },
+    ],
+  },
+  ordering: { address },                            // omit for menu-only; `true` skips the STEP 0 address (flag it)
+  reservations: { configuration: { onlineReservations: { partySize: { min: 2, max: 10 } } } },
+});
+// → { menuId, sectionIds, itemIds, orderingEnabled, reservationsEnabled, imagesAttached }
+```
+
+**Seeding is additive — never delete or overwrite existing content.** Don't clean up, don't remove
+"sample" data, don't reset. Just add.
+
+## Escape hatch — individual functions
+Reach for the functions below only when the one-call `setupRestaurants` doesn't fit (partial re-seed,
+custom fulfillment methods, experiences). `setupRestaurants` is built from them, in this order
+(items → sections → menu — each child before its parent):
+
+```js
+// ── MENU (always; the seedable core) ────────────────────────────────────────────────────────────
+await seed.installMenusApp(ctx);                    // if the site doesn't have Wix Restaurants Menus yet
+
+const menu = await seed.createMenu(ctx, {           // builds items → sections → menu bottom-up
+  name: "Dinner", description: "Evening menu",
+  sections: [
+    { name: "Antipasti", description: "To start", items: [
+      { name: "Bruschetta al Pomodoro", description: "Grilled sourdough, San Marzano tomatoes, basil.", price: 9.50 },
+    ] },
+  ],
+});                                                 // → { menuId, sectionIds, itemIds }
+
+// optional — import the url to Wix Media (restaurants binds by file id), then attach (full-replace — echo revision + price)
+// const file = await seed.importImage(ctx, imageUrl);   // → { id, url } (Wix Media file id + wixstatic url)
+// await seed.attachItemImages(ctx, [{ id, revision, price, image: { id: file.id, url: file.url, height: 1024, width: 1024 } }]);
+
+// ── ONLINE ORDERING (add-on, on demand; MENU-FIRST) ──────────────────────────────────────────────
+await seed.installOrdersApp(ctx);                   // auto-provisions a working ordering setup
+await seed.setBusinessLocation(ctx, address);       // STEP 0 — REQUIRED (see preconditions)
+const [op] = await seed.listOperations(ctx);        // verify the auto-created operation (never create one)
+// if (op.onlineOrderingStatus !== "ENABLED") await seed.enableOperation(ctx, op.id, op.revision);
+const methods = await seed.listFulfillmentMethods(ctx);      // reshape ONLY what the request names
+// await seed.updateFulfillmentMethod(ctx, methods[0].id, { revision: methods[0].revision, name: "Delivery", fee: "5" });
+const settings = await seed.queryMenuOrderingSettings(ctx);  // confirm each menu is onlineOrderingEnabled
+
+// ── TABLE RESERVATIONS (add-on, on demand; INDEPENDENT of menu/ordering) ─────────────────────────
+await seed.installTableReservationsApp(ctx);        // auto-provisions a default reservation location
+await seed.setBusinessLocation(ctx, address);       // STEP 0 — shared with ordering (do it once if both)
+const [loc] = await seed.listReservationLocations(ctx);      // discover the default (never create one)
+// await seed.updateReservationLocation(ctx, loc.id, loc.revision, { onlineReservations: { partySize: { min: 2, max: 10 } } });
+await seed.enableOnlineReservations(ctx, loc.id, loc.revision);  // PREMIUM-GATED — 428 on a free site (record, don't fail)
+
+// ── EXPERIENCES (add-on WITHIN Table Reservations, on demand) ────────────────────────────────────
+await seed.createExperiences(ctx, loc.id, [{ configuration: { /* per Create-Experience doc */ } }]);
+```
+
+## Functions
+
+**Menu** (`setup-restaurants.md`)
+| fn | does |
+|---|---|
+| `installMenusApp(ctx)` | install the Wix Restaurants Menus app |
+| `createMenu(ctx, {name,description?,sections})` | items → sections → menu bottom-up → `{menuId,sectionIds,itemIds}` |
+| `importImage(ctx, url)` | import an external url into Wix Media → `{id,url}` (file id + wixstatic url); menu items bind by this file id |
+| `attachItemImages(ctx, [{id,revision,price,image}])` | image pass — full-replace PATCH (echo revision + priceInfo); `image.id` = a Wix Media file id from `importImage` |
+
+**Shared** (ordering + reservations STEP 0)
+| fn | does |
+|---|---|
+| `setBusinessLocation(ctx, location)` | full-override Update Location (or create if none) — REQUIRED for ordering |
+
+**Online ordering** (`setup-restaurant-orders.md`) — verify/reshape the auto-provisioned setup
+| fn | does |
+|---|---|
+| `installOrdersApp(ctx)` | install the Orders app (auto-provisions operation + methods + per-menu settings) |
+| `listOperations(ctx)` | the auto-created operation(s) — never create one |
+| `enableOperation(ctx, id, revision)` | PATCH `onlineOrderingStatus:"ENABLED"` (only if not already) |
+| `listFulfillmentMethods(ctx)` | the three auto-created methods |
+| `updateFulfillmentMethod(ctx, id, patch)` | rename / re-fee / disable (partial; `fee`/`minOrderPrice` decimal strings) |
+| `createFulfillmentMethod(ctx, method)` | add one beyond the defaults (NOT auto-attached) |
+| `setOperationFulfillmentIds(ctx, id, revision, ids)` | attach a created method (full array) |
+| `queryMenuOrderingSettings(ctx)` | confirm each menu `onlineOrderingEnabled` + bound to the operation |
+| `updateMenuOrderingSettings(ctx, id, patch)` | flip a menu orderable / display-only |
+
+**Table reservations** (`setup-restaurant-reservations.md`) — configure the auto-provisioned location
+| fn | does |
+|---|---|
+| `installTableReservationsApp(ctx)` | install the app (auto-provisions the default reservation location) |
+| `listReservationLocations(ctx)` | discover the default (never create one — API can't) |
+| `updateReservationLocation(ctx, id, revision, configuration)` | party-size / hours / turnover (config only; `location` immutable) |
+| `enableOnlineReservations(ctx, id, revision)` | turn online reservations on — PREMIUM-GATED (428 on free) |
+
+**Experiences** (`setup-restaurant-experiences.md`) — feature of Table Reservations (no extra install)
+| fn | does |
+|---|---|
+| `createExperiences(ctx, reservationLocationId, experiences)` | one experience per named dining occasion → `[{id,name}]` |
+
+## Ordering rules (do not violate)
+- **Menu is bottom-up: items → sections → menu.** A section is created with its `itemIds`, a menu with
+  its `sectionIds`, so each child must exist before its parent. `createMenu` does this in three phases.
+- **`visible: true` at every level** (item, section, menu) — storefront queries return only visible
+  entities. Baked in by `createMenu`.
+- **Menu before ordering.** Seed the menu first, then the ordering add-on (as one unit) — each menu
+  binds to the operation via a menu-ordering-settings object. Ordering auto-provisions per menu either
+  way, but the verify step needs a menu to confirm against.
+- **`setBusinessLocation` STEP 0 is required for ordering** — without a real address Wix limits ordering
+  to "testing only" and checkout breaks. Shared with reservations (do it once if both add-ons run).
+- **Reservations are independent** — they bind to a location, not a menu; no menu-first rule, nothing to
+  bulk-seed (visitors create reservations at runtime).
+- Operations and reservation locations are **auto-provisioned — never create them**; discover and PATCH.
+
+## Preconditions (record in the handoff, do NOT fail the seed)
+- **Ordering address (STEP 0)** — required; if the brief names none, set a clearly-marked placeholder and
+  flag the owner to set their real business address before ordering works.
+- **Paid checkout** needs a **premium plan + a configured payment method** (dashboard/premium — can't be
+  done headlessly).
+- **`enableOnlineReservations` is premium-only** — throws `428 PREMIUM_ONLY` on a non-premium site;
+  expected and non-fatal, record it and continue (don't retry-spiral).
+- **Booking an experience** is premium-gated the same way (create works on a free site; booking needs
+  premium + online reservations enabled).
+
+## Reference
+If a call returns a shape you didn't expect, or you need an operation this module doesn't cover, use the
+**`wix-docs`** skill to search + read the live Wix API reference — never guess. The **Experiences** create
+payload especially lives in the docs (fields evolve). The authoritative source recipes are
+`wix-headless/references/inline-recipes/setup-restaurants.md`, `setup-restaurant-orders.md`,
+`setup-restaurant-reservations.md`, and `setup-restaurant-experiences.md`.
+
+Read a method's page before writing its call: it carries the exact body shape, the required
+permission scope, and the response envelope.
+- Install a Wix app onto the site: https://dev.wix.com/docs/api-reference/business-management/app-installation/app-installation/install-app.md
+- Import an image into Wix Media: https://dev.wix.com/docs/api-reference/assets/media/media-manager/files/import-file.md
+- Create Menu: https://dev.wix.com/docs/api-reference/business-solutions/restaurants/menus/menus/create-menu.md
+- Create Section: https://dev.wix.com/docs/api-reference/business-solutions/restaurants/menus/sections/create-section.md
+- Bulk Create Sections: https://dev.wix.com/docs/api-reference/business-solutions/restaurants/menus/sections/bulk-create-sections.md
+- Create Item: https://dev.wix.com/docs/api-reference/business-solutions/restaurants/menus/items/items/create-item.md
+- Bulk Create Items: https://dev.wix.com/docs/api-reference/business-solutions/restaurants/menus/items/items/bulk-create-items.md
+- List Operations: https://dev.wix.com/docs/api-reference/business-solutions/restaurants/online-orders/operations/list-operations.md
+- Update Operation: https://dev.wix.com/docs/api-reference/business-solutions/restaurants/online-orders/operations/update-operation.md
+- Create Fulfillment Method: https://dev.wix.com/docs/api-reference/business-solutions/restaurants/online-orders/fulfillment-methods/create-fulfillment-method.md
+- Create Location: https://dev.wix.com/docs/api-reference/business-management/locations/create-location.md
+- List Reservation Locations: https://dev.wix.com/docs/api-reference/business-solutions/restaurants/reservations/reservation-locations/list-reservation-locations.md
+- Update Reservation Location: https://dev.wix.com/docs/api-reference/business-solutions/restaurants/reservations/reservation-locations/update-reservation-location.md
+- Query Menu Ordering Settings: https://dev.wix.com/docs/api-reference/business-solutions/restaurants/online-orders/menu-ordering-settings/query-menu-ordering-settings.md
+- Upsert Menu Ordering Settings By Menu Id: https://dev.wix.com/docs/api-reference/business-solutions/restaurants/online-orders/menu-ordering-settings/upsert-menu-ordering-settings-by-menu-id.md
+- Create Experience: https://dev.wix.com/docs/api-reference/business-solutions/restaurants/reservations/experiences/create-experience.md