@wix/himalaya-cli 0.1528.0 → 0.1530.0

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

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

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

@@ -17,6 +17,9 @@ import { copyParam, stashCopy } from "../_shared/himi-copy.js";
 /** One section with its shaped dishes (the source of truth `all` keeps). */
 interface MenuSection {
   id: string;
+  /** The menu that lists this section ("" for the flat fallback) — the dish detail orders
+   *  the dish under this menu + section, which is what Wix checkout validates. */
+  menuId: string;
   name: string;
   items: DishCard[];
 }
@@ -47,6 +50,9 @@ interface MenuRow {
   noLabel2: boolean;
   noLabel3: boolean;
   detailScreenId: string;
+  /** Where the dish is shown — passed to the detail as nav params ("" on header rows). */
+  menuId: string;
+  sectionId: string;
 }
 
 interface State {
@@ -87,10 +93,12 @@ function headerRow(section: MenuSection): MenuRow {
     noLabel2: true,
     noLabel3: true,
     detailScreenId: "",
+    menuId: "",
+    sectionId: "",
   };
 }
 
-function itemRow(item: DishCard): MenuRow {
+function itemRow(item: DishCard, section: MenuSection): MenuRow {
   return {
     id: item.id,
     isHeader: false,
@@ -112,6 +120,8 @@ function itemRow(item: DishCard): MenuRow {
     noLabel2: item.noLabel2,
     noLabel3: item.noLabel3,
     detailScreenId: item.detailScreenId,
+    menuId: section.menuId,
+    sectionId: section.id === "all" ? "" : section.id,
   };
 }
 
@@ -128,7 +138,7 @@ function apply(all: MenuSection[], query: string): MenuRow[] {
         }))
         .filter((section) => section.items.length > 0)
     : all;
-  return filtered.flatMap((section) => [headerRow(section), ...section.items.map(itemRow)]);
+  return filtered.flatMap((section) => [headerRow(section), ...section.items.map((item) => itemRow(item, section))]);
 }
 
 function derive(state: State): State {
@@ -163,9 +173,10 @@ export function composeSections(menus: WixMenu[], sections: WixSection[], dishes
   const sectionById = new Map(sections.filter((section) => section.id).map((section) => [section.id, section]));
   const orderedIds: string[] = [];
   const seen = new Set<string>();
+  const menuOf = new Map<string, string>();
   for (const menu of menus.filter((candidate) => candidate.visible !== false)) {
     for (const sectionId of menu.sectionIds ?? []) {
-      if (sectionId && !seen.has(sectionId)) { seen.add(sectionId); orderedIds.push(sectionId); }
+      if (sectionId && !seen.has(sectionId)) { seen.add(sectionId); orderedIds.push(sectionId); menuOf.set(sectionId, menu.id ?? ""); }
     }
   }
   // Menus query failed / carried no section links → every section, in order.
@@ -182,11 +193,11 @@ export function composeSections(menus: WixMenu[], sections: WixSection[], dishes
       return dish ? [dish] : [];
     });
     if (items.length === 0) return [];
-    return [{ id: section.id, name: cleanTitle(section.name) || copyParam("menu.sectionFallbackName", "Menu"), items }];
+    return [{ id: section.id, menuId: menuOf.get(section.id) ?? "", name: cleanTitle(section.name) || copyParam("menu.sectionFallbackName", "Menu"), items }];
   });
   if (composed.length > 0) return composed;
   // Sections unavailable (or none matched a dish) → flat single-section menu.
-  return dishes.length ? [{ id: "all", name: copyParam("menu.sectionFallbackName", "Menu"), items: dishes }] : [];
+  return dishes.length ? [{ id: "all", menuId: "", name: copyParam("menu.sectionFallbackName", "Menu"), items: dishes }] : [];
 }
 
 function strOf(arg: unknown): string {

package/templates/restaurant/tier5-src/wix-spaces-food-order-detail/index.ts

@@ -1,24 +1,86 @@
-// Tier-5 bundle: Wix Spaces clone — explicit secure-site handoff.
-// The owner-capable Restaurant Orders API must never be queried from a member device.
+// Tier-5 bundle: one placed restaurant order for the signed-in member.
+// Read through the member eCom orders search (filtered to the member's email and the order id),
+// the same path as the order list — never the owner-capable Restaurants Orders API. An order that
+// is not this member's, or has no Restaurants line, is "not found".
 import { defineService } from "@himalaya/state";
+import { searchOrders, type WixOrder } from "@himalaya/wix-ecom";
 import { presence, detailInputId, type PresenceFlags } from "../_shared/detail-presence.js";
+import { assertOrderMember, orderAccessDenied, orderMember } from "../_shared/member-orders.js";
+import { RESTAURANTS_ORDERS_APP_ID } from "../_shared/restaurant-ordering.js";
+import { formatDateMedium } from "../_shared/engine-intl.js";
+import { copyParam, copyTemplate, stashCopy } from "../_shared/himi-copy.js";
 
 interface S extends PresenceFlags { status: "loading" | "ready"; name: string; status_: string; total: string; items: string; message: string }
 
-const svc = defineService<S, { load: (s: S) => Promise<S> }>("spacesFoodOrderDetail", {
-  state: { status: "loading", name: "", status_: "", total: "", items: "", message: "", ...presence("loading") },
-  actions: {
-    // No order id → the shared not-found state; an id → the secure-site handoff.
-    load: async () => (!detailInputId() ? { status: "ready", name: "", status_: "", total: "", items: "", message: "", ...presence("missing") } : {
-      ...presence("found"),
+const EMPTY = { name: "", status_: "", total: "", items: "", message: "" };
+
+function statusLine(order: WixOrder): string {
+  const raw = order as WixOrder & { status?: string };
+  const status = raw.status === "CANCELED" ? copyParam("foodOrders.statusCanceled", "Canceled")
+    : order.fulfillmentStatus === "FULFILLED" ? copyParam("foodOrders.statusCompleted", "Completed")
+    : order.paymentStatus === "NOT_PAID" || order.paymentStatus === "PENDING" ? copyParam("foodOrders.statusAwaitingPayment", "Awaiting payment")
+    : copyParam("foodOrders.statusReceived", "Received");
+  const created = order.createdDate ? new Date(order.createdDate) : undefined;
+  return [status, created && !Number.isNaN(created.getTime()) ? formatDateMedium(created) : ""].filter(Boolean).join(" · ");
+}
+
+function fulfillmentLine(order: WixOrder): string {
+  const title = (order as WixOrder & { shippingInfo?: { title?: string } }).shippingInfo?.title ?? "";
+  return title ? copyTemplate("foodOrderDetail.fulfillment", "Fulfillment: {method}", { method: title }) : "";
+}
+
+/** Bumped by every load. The module-scope load and the screen's on-appear load overlap: only the
+ *  newest commits, so an older, slower answer never replaces a newer one. */
+let loadSeq = 0;
+/** The service's live state (set once the service exists). */
+let latestState: () => S = () => ({ status: "loading", ...EMPTY, ...presence("loading") });
+
+async function read(id: string): Promise<S> {
+  const member = await orderMember();
+  if (!member.email) {
+    return { status: "ready", ...EMPTY, ...presence("found"),
+      message: copyParam("foodOrderDetail.signIn", "Sign in to see this order.") };
+  }
+  try {
+    const response = await searchOrders({ search: {
+      filter: { "buyerInfo.email": { $eq: member.email }, id: { $eq: id } },
+      cursorPaging: { limit: 1 },
+    } });
+    await assertOrderMember(member);
+    const order = (response.orders ?? []).find((candidate) => candidate.id === id
+      && (candidate.buyerInfo?.email ?? "").trim().toLowerCase() === member.email
+      && (candidate.lineItems ?? []).some((line) =>
+        (line as { catalogReference?: { appId?: string } }).catalogReference?.appId === RESTAURANTS_ORDERS_APP_ID));
+    if (!order) return { status: "ready", ...EMPTY, ...presence("missing") };
+    return {
       status: "ready",
-      name: "",
-      status_: "",
-      total: "",
-      items: "",
-      message: "Live order details require a secure connection configured by this business.",
-    }),
+      ...presence("found"),
+      name: copyTemplate("foodOrders.orderTitle", "Order #{number}", { number: order.number || order.id }),
+      status_: statusLine(order),
+      total: order.priceSummary?.total?.formattedAmount ?? "",
+      items: (order.lineItems ?? [])
+        .map((line) => `${line.quantity || 1} × ${line.productName?.translated || line.productName?.original || ""}`.trim())
+        .join("\n"),
+      message: fulfillmentLine(order),
+    };
+  } catch (error) {
+    return { status: "ready", ...EMPTY, ...presence(orderAccessDenied(error) ? "missing" : "failed") };
+  }
+}
+
+const svc = defineService<S, { load: (s: S, arg?: unknown) => Promise<S> }>("spacesFoodOrderDetail", {
+  state: { status: "loading", ...EMPTY, ...presence("loading") },
+  actions: {
+    load: async (_state, arg) => {
+      stashCopy(arg);
+      const id = detailInputId();
+      if (!id) return { status: "ready", ...EMPTY, ...presence("missing") };
+      const seq = ++loadSeq;
+      const next = await read(id);
+      return seq === loadSeq ? next : latestState();
+    },
   },
 });
+latestState = () => svc.getState() as S;
 svc.load();
 export { svc };