@wix/agent-skills 1.35.1 → 1.36.1

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

@@ -1,66 +0,0 @@
-// 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,
-  setOrderFulfillment,
-  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.quantityInfo?.confirmedQuantity || 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); } };
-  // Pickup/delivery + time (+ the delivery address) on the cart — see setOrderFulfillment for the codes.
-  const setFulfillment = async (code, address) => { setLoading(true); try { setCart(await setOrderFulfillment(code, address)); } 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, setFulfillment, 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

@@ -1,32 +0,0 @@
-// 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

@@ -1,73 +0,0 @@
-// 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

@@ -1,28 +0,0 @@
-// 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

@@ -1,102 +0,0 @@
-// 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/app/rest/wix-restaurants-menu.js

@@ -1,224 +0,0 @@
-import { wixApiRequest } from "./wix-client.js";
-
-// Data model reference: see INSTRUCTIONS.md
-
-/**
- * Menu — top of the hierarchy. One per published menu (e.g. Dinner, Drinks).
- *   id {string}, name {string}, description {string}, visible {boolean},
- *   sectionIds {string[]} — ordered Section GUIDs,
- *   urlQueryParam {string} — URL slug fragment, businessLocationId {string}
- * Full model: https://dev.wix.com/docs/api-reference/business-solutions/restaurants/menus/menus/menu-object.md
- *
- * Section — a group of items within a menu (e.g. Appetizers, Mains).
- *   id {string}, name {string}, description {string},
- *   image {object} — { id, url, width, height, altText },
- *   itemIds {string[]} — ordered Item GUIDs, visible {boolean}
- * Full model: https://dev.wix.com/docs/api-reference/business-solutions/restaurants/menus/sections/section-object.md
- *
- * Item — a single dish/drink. Has EITHER priceInfo (single price) OR priceVariants (one-of).
- *   id {string}, name {string}, description {string},
- *   image {object} — { id, url, width, height, altText },
- *   priceInfo.price {string} — decimal string e.g. "12.50" (NO currency symbol),
- *   priceVariants.variants {object[]} — [{ variantId, priceInfo: { price } }],
- *   labels {object[]} — [{ id }] resolve via listLabels,
- *   visible {boolean}, featured {boolean},
- *   orderSettings.inStock {boolean}, orderSettings.acceptSpecialRequests {boolean},
- *   modifierGroups {object[]} — [{ id }] resolve via listModifierGroups
- * Full model: https://dev.wix.com/docs/api-reference/business-solutions/restaurants/menus/items/items/item-object.md
- *
- * PriceVariant (from listVariants): { id, name } — name for the variantId in item.priceVariants.
- * ModifierGroup: { id, name, rule: { required, minSelections, maxSelections },
- *   modifiers: [{ id, preSelected, additionalChargeInfo: { additionalCharge } }] }
- * Modifier (from listModifiers): { id, name, inStock }
- * Label (from listLabels): { id, name, icon: { url } } — e.g. "Vegan", "Spicy"
- *
- * NOTE: Restaurant prices are plain decimal strings with NO currency symbol.
- * getFullMenu() assembles the full tree and is the recommended entry point.
- */
-
-/**
- * Internal: fetch a list endpoint by a set of GUIDs, chunked to avoid long query strings.
- */
-async function fetchAllByIds(path, idParamName, responseKey, ids, extraQuery = {}) {
-  const unique = [...new Set((ids ?? []).filter(Boolean))];
-  if (!unique.length) return [];
-  const out = [];
-  for (let i = 0; i < unique.length; i += 100) {
-    const chunk = unique.slice(i, i + 100);
-    const res = await wixApiRequest(path, {
-      method: "GET",
-      query: { [idParamName]: chunk, ...extraQuery },
-    });
-    out.push(...(res?.[responseKey] ?? []));
-  }
-  return out;
-}
-
-/**
- * List menus (one page). Pass `onlyVisible: true` for visitor-facing menus.
- * GET https://www.wixapis.com/restaurants/menus/v1/menus
- * @param {{ onlyVisible?: boolean, limit?: number, cursor?: string }} [options]
- * @returns {Promise<{ menus: object[], nextCursor: string|null }>}
- */
-export async function listMenus({ onlyVisible = true, limit = 500, cursor } = {}) {
-  const res = await wixApiRequest("/restaurants/menus/v1/menus", {
-    method: "GET",
-    query: {
-      onlyVisible: onlyVisible ? "true" : undefined,
-      "paging.limit": String(limit),
-      "paging.cursor": cursor,
-    },
-  });
-  return { menus: res?.menus ?? [], nextCursor: res?.pagingMetadata?.cursors?.next ?? null };
-}
-
-/**
- * List sections by their GUIDs.
- * @param {string[]} sectionIds
- * @param {{ onlyVisible?: boolean }} [options]
- * @returns {Promise<object[]>}
- */
-export async function listSections(sectionIds, { onlyVisible = true } = {}) {
-  return fetchAllByIds("/restaurants/menus/v1/sections", "sectionIds", "sections", sectionIds, {
-    onlyVisible: onlyVisible ? "true" : undefined,
-  });
-}
-
-/**
- * List items by their GUIDs.
- * @param {string[]} itemIds
- * @param {{ onlyVisible?: boolean }} [options]
- * @returns {Promise<object[]>}
- */
-export async function listItems(itemIds, { onlyVisible = true } = {}) {
-  return fetchAllByIds("/restaurants/menus/v1/items", "itemIds", "items", itemIds, {
-    onlyVisible: onlyVisible ? "true" : undefined,
-  });
-}
-
-/**
- * List price variants by their GUIDs (resolves variantId → name).
- * @param {string[]} variantIds
- * @returns {Promise<object[]>}
- */
-export async function listVariants(variantIds) {
-  return fetchAllByIds("/restaurants/menus/v1/variants", "variantIds", "variants", variantIds);
-}
-
-/**
- * List modifier groups by their GUIDs.
- * @param {string[]} modifierGroupIds
- * @returns {Promise<object[]>}
- */
-export async function listModifierGroups(modifierGroupIds) {
-  return fetchAllByIds(
-    "/restaurants/menus/v1/modifier-groups",
-    "modifierGroupIds",
-    "modifierGroups",
-    modifierGroupIds,
-  );
-}
-
-/**
- * List modifiers by their GUIDs (resolves modifierId → name + inStock).
- * @param {string[]} modifierIds
- * @returns {Promise<object[]>}
- */
-export async function listModifiers(modifierIds) {
-  return fetchAllByIds("/restaurants/item-modifiers/v1/modifiers", "modifierIds", "modifiers", modifierIds);
-}
-
-/**
- * List every item label on the site.
- * @returns {Promise<object[]>}
- */
-export async function listLabels() {
-  const res = await wixApiRequest("/restaurants/menus/v1/labels", { method: "GET" });
-  return res?.labels ?? [];
-}
-
-/**
- * Retrieve the complete assembled menu tree in one call. Walks menus → sections → items,
- * then enriches each item with resolved price variants, modifier groups + modifiers, and labels.
- * This is the recommended entry point for the menu screen.
- *
- * Returns:
- *   { menus: [ { ...menu, sections: [ { ...section, items: [ assembledItem ] } ] } ] }
- * where assembledItem adds:
- *   price          {string|null}  Single price (null when variant-priced)
- *   variants       {object[]}     [{ variantId, name, price }]
- *   modifierGroups {object[]}     [{ id, name, rule, modifiers: [{ id, name, preSelected, additionalCharge, inStock }] }]
- *   labels         {object[]}     [{ id, name, icon }]
- *
- * https://dev.wix.com/docs/api-reference/business-solutions/restaurants/menus/retrieve-a-complete-menu-structure.md
- * @param {{ onlyVisible?: boolean }} [options]
- * @returns {Promise<{ menus: object[] }>}
- */
-export async function getFullMenu({ onlyVisible = true } = {}) {
-  const { menus } = await listMenus({ onlyVisible });
-  if (!menus.length) return { menus: [] };
-
-  const sectionIds = menus.flatMap((m) => m.sectionIds ?? []);
-  const sections = await listSections(sectionIds, { onlyVisible });
-
-  const itemIds = sections.flatMap((s) => s.itemIds ?? []);
-  const items = await listItems(itemIds, { onlyVisible });
-
-  const variantIds = items.flatMap((i) => (i.priceVariants?.variants ?? []).map((v) => v.variantId));
-  const modifierGroupIds = items.flatMap((i) => (i.modifierGroups ?? []).map((g) => g.id));
-
-  const [variants, modifierGroups, labels] = await Promise.all([
-    listVariants(variantIds),
-    listModifierGroups(modifierGroupIds),
-    listLabels(),
-  ]);
-
-  const modifierIds = modifierGroups.flatMap((g) => (g.modifiers ?? []).map((m) => m.id));
-  const modifiers = await listModifiers(modifierIds);
-
-  const variantMap = new Map(variants.map((v) => [v.id, v]));
-  const groupMap = new Map(modifierGroups.map((g) => [g.id, g]));
-  const modifierMap = new Map(modifiers.map((m) => [m.id, m]));
-  const labelMap = new Map(labels.map((l) => [l.id, l]));
-
-  const assembleItem = (item) => ({
-    ...item,
-    price: item.priceInfo?.price ?? null,
-    variants: (item.priceVariants?.variants ?? []).map((v) => ({
-      variantId: v.variantId,
-      name: variantMap.get(v.variantId)?.name ?? null,
-      price: v.priceInfo?.price ?? null,
-    })),
-    modifierGroups: (item.modifierGroups ?? [])
-      .map((ref) => groupMap.get(ref.id))
-      .filter(Boolean)
-      .map((group) => ({
-        id: group.id,
-        name: group.name,
-        rule: group.rule ?? null,
-        modifiers: (group.modifiers ?? []).map((m) => ({
-          id: m.id,
-          name: modifierMap.get(m.id)?.name ?? null,
-          preSelected: m.preSelected ?? false,
-          additionalCharge: m.additionalChargeInfo?.additionalCharge ?? "0",
-          inStock: modifierMap.get(m.id)?.inStock ?? true,
-        })),
-      })),
-    labels: (item.labels ?? []).map((ref) => labelMap.get(ref.id)).filter(Boolean),
-  });
-
-  const itemMap = new Map(items.map((i) => [i.id, assembleItem(i)]));
-  const sectionMap = new Map(
-    sections.map((s) => [
-      s.id,
-      { ...s, items: (s.itemIds ?? []).map((id) => itemMap.get(id)).filter(Boolean) },
-    ]),
-  );
-
-  return {
-    menus: menus.map((m) => ({
-      ...m,
-      sections: (m.sectionIds ?? []).map((id) => sectionMap.get(id)).filter(Boolean),
-    })),
-  };
-}