@wix/himalaya-cli 0.1392.0 → 0.1393.0

package/templates/gym-fitness-owner/tier5-src/himi-owner-lite-service/index.ts

@@ -7,25 +7,24 @@
 
 import { defineService } from "@himalaya/state";
 import { getService, deleteService, type WixService } from "@himalaya/wix-bookings";
-import { ownerLoadError, isBridgeUnavailable, isOwnerPreviewDemo, shouldQueueOwnerWrite } from "../_shared/owner-load-error.js";
+import { ownerLoadError, isOwnerPreviewDemo, ownerDemoFallback, ownerWriteError, isNotFound } from "../_shared/owner-load-error.js";
 import { DEMO_SERVICES, DEMO_NOTE, DEMO_SAVE_NOTE } from "../_shared/owner-preview-demo.js";
 import { stashCopy, copyParam } from "../_shared/himi-copy.js";
-import { get as dbGet, remove as dbRemove, enqueue as dbEnqueue, type DbEntity } from "../_shared/owner-local-db.js";
+import { get as dbGet, remove as dbRemove, type DbEntity } from "../_shared/owner-local-db.js";
 import { wixMediaUrl, WIX_DETAIL_IMAGE } from "@himalaya/wix-media";
 import { blankFlags } from "../_shared/detail-facts.js";
 
 // Offline-first (data-offline): the service DETAIL falls back to the last-synced
-// local `owner_services` row (put by the service form's write-behind) on a failed
-// fetch, and its delete is WRITE-BEHIND — the local row is dropped OPTIMISTICALLY,
-// then deleteService is attempted; if the bridge/network is unreachable the delete
-// is ENQUEUED for replay on reconnect. Every local-db call is wrapped so a build
-// without the `local_database` grant behaves exactly as before (online-only).
+// local `owner_services` row on a failed fetch. Its delete is SERVER-CONFIRMED: the
+// local row is dropped only after Wix deletes the service; a failed delete leaves it
+// and tells the owner why. No host replays a queued write, so nothing is queued.
+// Every local-db call is wrapped so a build without the `local_database` grant
+// behaves exactly as before (online-only).
 const ENTITY = "owner_services";
 
 
 async function cacheDrop(id: string): Promise<void> { try { await dbRemove(ENTITY, id); } catch { /* capability not granted */ } }
 async function cacheGet(id: string): Promise<DbEntity | null> { try { return await dbGet(ENTITY, id); } catch { return null; } }
-async function queueWrite(actionId: string, params: Record<string, string>): Promise<void> { try { await dbEnqueue(actionId, params); } catch { /* capability not granted */ } }
 
 interface ServiceState {
   id: string;
@@ -238,9 +237,10 @@ const svc = defineService<ServiceState, {
         return await refresh(shape({ ...s, id, status: "loading" }), id);
       } catch (e) {
         // Offline: fall back to the last-synced local row before the demo/error paths.
-        const cached = await cacheGet(id);
+        // Wix says it is gone (e.g. a delete whose reply was lost): drop the row, never show it.
+        const cached = isNotFound(e) ? (await cacheDrop(id), null) : await cacheGet(id);
         if (cached) return cachedDetail(s, cached);
-        if (isBridgeUnavailable(e)) {
+        if (ownerDemoFallback(e)) {
           const demo = demoDetail(s, id);
           if (demo) return demo;
         }
@@ -258,9 +258,10 @@ const svc = defineService<ServiceState, {
       try {
         return await refresh(shape({ ...s, status: "loading" }), s.id);
       } catch (e) {
-        const cached = await cacheGet(s.id);
+        // Wix says it is gone (e.g. a delete whose reply was lost): drop the row, never show it.
+        const cached = isNotFound(e) ? (await cacheDrop(s.id), null) : await cacheGet(s.id);
         if (cached) return cachedDetail(s, cached);
-        if (isBridgeUnavailable(e)) {
+        if (ownerDemoFallback(e)) {
           const demo = demoDetail(s, s.id);
           if (demo) return demo;
         }
@@ -270,18 +271,15 @@ const svc = defineService<ServiceState, {
     delete: async (s) => {
       if (isOwnerPreviewDemo() || s.demoNote) return shape({ ...s, actionMessage: copyParam("ownerCommon.demoSaveNote", DEMO_SAVE_NOTE) });
       if (!s.id) return shape({ ...s, actionMessage: copyParam("ownerService.noIdMessage", "No service id.") });
-      // Optimistic local delete — the list drops the row immediately.
-      await cacheDrop(s.id);
       try {
         await deleteService(s.id);
-        return shape({ ...s, status: "deleted", title: "", emptyText: copyParam("ownerService.deletedEmpty", "Service deleted."), actionMessage: "" });
       } catch (e) {
-        if (shouldQueueOwnerWrite(e)) {
-          await queueWrite("tier5.himiOwnerLiteService.delete", { id: s.id });
-          return shape({ ...s, status: "deleted", title: "", emptyText: copyParam("ownerService.deletedEmpty", "Service deleted."), actionMessage: copyParam("ownerCommon.demoSaveNote", DEMO_SAVE_NOTE) });
-        }
-        return shape({ ...s, actionMessage: ownerLoadError(e) });
+        // Nothing replays a queued write: the record stays, and the owner is told why.
+        return shape({ ...s, actionMessage: ownerWriteError(e) });
       }
+      // Only a delete Wix confirmed leaves the local list.
+      await cacheDrop(s.id);
+      return shape({ ...s, status: "deleted", title: "", emptyText: copyParam("ownerService.deletedEmpty", "Service deleted."), actionMessage: "" });
     },
   },
 });

package/templates/gym-fitness-owner/tier5-src/himi-owner-lite-service-form/index.ts

@@ -6,22 +6,20 @@
 
 import { defineService } from "@himalaya/state";
 import { getService, updateService, type WixService } from "@himalaya/wix-bookings";
-import { ownerLoadError, isBridgeUnavailable, isOwnerPreviewDemo, shouldQueueOwnerWrite } from "../_shared/owner-load-error.js";
+import { ownerLoadError, isOwnerPreviewDemo, ownerDemoFallback, ownerWriteError } from "../_shared/owner-load-error.js";
 import { DEMO_SERVICES, DEMO_NOTE, DEMO_SAVE_NOTE, demoRefusalPatch } from "../_shared/owner-preview-demo.js";
 import { stashCopy, copyParam } from "../_shared/himi-copy.js";
-import { get as dbGet, upsert as dbUpsert, enqueue as dbEnqueue, type DbEntity } from "../_shared/owner-local-db.js";
+import { get as dbGet, upsert as dbUpsert, type DbEntity } from "../_shared/owner-local-db.js";
 
-// Offline-first (data-offline): the service edit is WRITE-BEHIND against the
-// encrypted `owner_services` entity — the local store is updated OPTIMISTICALLY so
-// the detail/list repaint from cache immediately, then updateService is attempted;
-// if it can't reach the bridge/network the write is ENQUEUED for replay on
-// reconnect, and load prefills from the last-synced local row when offline. Every
-// local-db call is wrapped (try/catch) so a build that ships without the
-// `local_database` grant behaves exactly as before (online-only, no cache/queue).
+// Offline-first (data-offline): load prefills from the last-synced local
+// `owner_services` row when offline, and the edit is SERVER-CONFIRMED — the local
+// row changes only after Wix accepts it; a failed save leaves it alone, keeps the
+// form, and tells the owner why. No host replays a queued write, so nothing is queued.
+// Every local-db call is wrapped (try/catch) so a build that ships without the
+// `local_database` grant behaves exactly as before (online-only, no cache).
 const ENTITY = "owner_services";
 async function cachePut(row: DbEntity): Promise<void> { try { await dbUpsert(ENTITY, row); } catch { /* capability not granted */ } }
 async function cacheGet(id: string): Promise<DbEntity | null> { try { return await dbGet(ENTITY, id); } catch { return null; } }
-async function queueWrite(actionId: string, params: Record<string, string>): Promise<void> { try { await dbEnqueue(actionId, params); } catch { /* capability not granted */ } }
 
 interface ServiceFormState {
   mode: "edit";
@@ -156,7 +154,7 @@ const svc = defineService<ServiceFormState, {
             status: "idle", error: "", savedMessage: "",
           });
         }
-        if (isBridgeUnavailable(e)) {
+        if (ownerDemoFallback(e)) {
           const d = DEMO_SERVICES.find((x) => x.id === id);
           if (d) {
             return shape({
@@ -178,10 +176,8 @@ const svc = defineService<ServiceFormState, {
       if (!name) return shape({ ...s, status: "error", error: copyParam("ownerServiceForm.nameRequired", "Name is required"), savedMessage: "" });
       if (!targetId) return shape({ ...s, status: "error", error: copyParam("ownerServiceForm.errorNoService", "No service to edit."), savedMessage: "" });
 
-      // Optimistic local write — the detail/list repaint from cache immediately (offline or not).
       const cached = !s.id ? await cacheGet(targetId) : null;
       const localRow: DbEntity = { ...(cached ?? {}), id: targetId, name, title: name, description, category: s.category || String(cached?.category ?? "") };
-      await cachePut(localRow);
       try {
         // v2 PATCH is a masked update requiring the current `revision` (optimistic
         // concurrency), captured from the getService on load. The response wraps
@@ -190,6 +186,8 @@ const svc = defineService<ServiceFormState, {
         // load-time revision and reject.
         const res = await updateService(targetId, { name, ...(description ? { description } : {}), ...(s.revision ? { revision: s.revision } : {}) });
         const bumped = String((res?.service as { revision?: unknown } | undefined)?.revision ?? "");
+        // The local row follows only what Wix confirmed.
+        await cachePut(localRow);
         return shape({
           ...s, id: targetId, name, description,
           revision: bumped || s.revision,
@@ -197,22 +195,11 @@ const svc = defineService<ServiceFormState, {
           savedId: targetId,
         });
       } catch (e) {
-        if (shouldQueueOwnerWrite(e)) {
-          // Demo / web-preview (no owner bridge; the record came from demo sample
-          // data, marked by demoNote): a queued write could never replay, so answer
-          // with the demo save note instead of the real-offline write-behind.
-          if (s.demoNote) return demoRefusal(s);
-          // Real device offline: the optimistic cache row already shows; queue the
-          // write to replay (WriteQueue, idempotent) when connectivity returns.
-          await queueWrite("tier5.himiOwnerLiteServiceForm.submit", { id: targetId, name, description });
-          return shape({
-            ...s, id: targetId, name, description,
-            status: "saved", error: "",
-            savedMessage: copyParam("ownerServiceForm.savedOffline", "Saved offline — will sync when you reconnect."),
-            savedId: targetId,
-          });
-        }
-        return shape({ ...s, status: "error", error: ownerLoadError(e), savedMessage: "" });
+        // Never "saved offline": nothing replays a queued write on any platform. The cache was
+        // not touched, and the typed values stay in the form so a retry is one tap.
+        // Demo / web-preview: the record came from demo sample data (marked by demoNote).
+        if (s.demoNote) return demoRefusal(s);
+        return shape({ ...s, name, description, status: "error", error: ownerWriteError(e), savedMessage: "" });
       }
     },
   },

package/templates/gym-fitness-owner/tier5-src/himi-owner-lite-services/index.ts

@@ -5,7 +5,7 @@
 import { defineBackendCollection } from "../_shared/collection-service.js";
 import { offsetPage } from "../_shared/offset-page.js";
 import { queryServices, type WixService } from "@himalaya/wix-bookings";
-import { ownerLoadError, isBridgeUnavailable, isOwnerPreviewDemo } from "../_shared/owner-load-error.js";
+import { ownerLoadError, isOwnerPreviewDemo, ownerDemoFallback } from "../_shared/owner-load-error.js";
 import { DEMO_SERVICES, DEMO_NOTE } from "../_shared/owner-preview-demo.js";
 import { copyParam } from "../_shared/himi-copy.js";
 import { getAll, upsert, type DbEntity } from "../_shared/owner-local-db.js";
@@ -171,7 +171,7 @@ const svc = defineBackendCollection("himiOwnerLiteServices", {
           const cached = await readCachedRows();
           if (cached.length) return { items: cached, nextCursor: "", complete: false, metadata: { fromCache: true } };
         }
-        if (!cursor && isBridgeUnavailable(error)) return demo();
+        if (!cursor && ownerDemoFallback(error)) return demo();
         throw error;
       }
     },

package/templates/gym-fitness-owner/tier5-src/himi-owner-lite-sites/index.ts

@@ -8,7 +8,7 @@
 
 import { defineService } from "@himalaya/state";
 import { querySites, type WixSite } from "@himalaya/wix-site-list";
-import { ownerLoadError, isBridgeUnavailable, isOwnerPreviewDemo } from "../_shared/owner-load-error.js";
+import { ownerLoadError, isOwnerPreviewDemo, ownerDemoFallback } from "../_shared/owner-load-error.js";
 import { DEMO_SITES, DEMO_NOTE } from "../_shared/owner-preview-demo.js";
 import { stashCopy, copyParam } from "../_shared/himi-copy.js";
 import { getAll, upsert, type DbEntity } from "../_shared/owner-local-db.js";
@@ -165,7 +165,7 @@ async function loadList(s: SitesState): Promise<SitesState> {
   } catch (e) {
     // Offline / fetch failure: keep the last-synced cache BEFORE the demo/error fallbacks.
     if (repairedCache.length) return base;
-    if (isBridgeUnavailable(e)) return demoList(s);
+    if (ownerDemoFallback(e)) return demoList(s);
     return shape({ ...s, status: "error", allSites: [], sites: [], error: ownerLoadError(e) });
   }
 }

package/templates/gym-fitness-owner/tier5-src/himi-owner-lite-today/index.ts

@@ -0,0 +1,315 @@
+// Tier-5 bundle: __HIMI_APP_NAME__ — TODAY. The worker behind the Home Screen widget.
+//
+// A WidgetKit extension (and a Glance receiver) runs no JS and holds no Wix session, and the OTA
+// widget producer has no credential either, so neither can read an owner's business. The PHONE
+// app runs this worker headlessly with its owner Wix bridge, resolves the widget descriptors'
+// `$service:ownerToday.*` leaves to literals (CompanionDescriptorResolver, the same pattern the
+// watch companion uses), and writes the frozen tree to the App Group for the widget to render.
+//
+// One owner glance: "what's next, and what is waiting for me" — the next booking, the booking
+// requests waiting on the owner, and the orders that need attention. Read-only: a widget never
+// writes to the business.
+//
+// Each source degrades on its own. A site without Bookings answers 428/404 on the bookings
+// query, and that must not cost the order count (or the reverse).
+
+import { defineService } from "@himalaya/state";
+import { queryBookings } from "@himalaya/wix-bookings";
+import { searchOrders } from "@himalaya/wix-ecom";
+import { ownerOrderAttentionFilter } from "../_shared/owner-order-attention.js";
+import { readSelectedSite } from "../_shared/owner-selected-site.js";
+
+type Rec = Record<string, unknown>;
+
+/** One booking as the widget shows it. Client FIRST name only: a Home Screen is visible to
+ *  anyone near the phone. */
+export interface TodayBooking {
+  bookingId: string;
+  name: string;
+  service: string;
+  timeLabel: string; // "10:30"
+  dayLabel: string; // "Today" / "Tomorrow" / "Thu 16 Oct"
+  /** "Today 10:30" — the absolute moment, never a countdown: a frozen "in 21 min" is wrong a
+   *  minute later, and nothing re-renders the widget between app foregrounds. */
+  whenLabel: string;
+}
+
+export interface TodayState {
+  status: "loading" | "ready" | "error" | "signedOut";
+  siteName: string;
+  /** Header line: "Today · <site>", or "Today" when the site has no name yet. */
+  header: string;
+  next: TodayBooking;
+  hasNext: boolean;
+  /** Hide the next-booking block: nothing is booked, or Bookings cannot be read. */
+  hideNext: boolean;
+  /** "No upcoming bookings" — shown in place of the block when Bookings has nothing ahead. */
+  nextNote: string;
+  hideNextNote: boolean;
+  requestCount: number;
+  /** "2 requests" / "1 request" / "No requests". At the read cap: "50+ requests". */
+  requestLabel: string;
+  orderCount: number;
+  /** "3 orders to handle" / "1 order to handle" / "No orders waiting". */
+  orderLabel: string;
+  /** Compact counts for the small widget: "2 req · 3 orders". */
+  countsShort: string;
+  bookingsReady: boolean;
+  ordersReady: boolean;
+  hideRequests: boolean;
+  hideOrders: boolean;
+  /** One-line state copy for a degrade (signed out, read failed, nothing installed). */
+  message: string;
+  hideMessage: boolean;
+  /** Epoch SECONDS after which this frame's labels are wrong: the next local midnight ("Today" /
+   *  "Tomorrow" shift) or the next booking's start (it is no longer "next"), whichever is first.
+   *  The phone caps the snapshot's lifetime at it, so a frozen frame never outlives its words. */
+  validUntil: number;
+}
+
+/** Which verticals THIS build provisions — baked into the widget descriptors' `input`. A vertical
+ *  the build does not show is never read: its count must not reach the compact line, and its
+ *  transient failure must not withhold a frame about the sections the build does show. */
+export interface Verticals {
+  bookings: boolean;
+  store: boolean;
+}
+
+export const COPY = {
+  signedOut: "Sign in to Owner to see today",
+  error: "Open Owner to refresh",
+  nothing: "Open Owner to see your business",
+  noneUpcoming: "No upcoming bookings",
+} as const;
+
+const PENDING = ["PENDING", "PENDING_APPROVAL", "WAITING_LIST"];
+/** A glance, not a list: a count at the cap reads as "50+". */
+export const LIMIT = 50;
+
+const WEEKDAYS = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+const MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+
+function str(r: unknown, ...paths: string[]): string {
+  for (const path of paths) {
+    let v: unknown = r;
+    for (const k of path.split(".")) v = v && typeof v === "object" ? (v as Rec)[k] : undefined;
+    if (typeof v === "string" && v) return v;
+    if (typeof v === "number") return String(v);
+  }
+  return "";
+}
+
+function hhmm(d: Date): string {
+  return `${String(d.getHours()).padStart(2, "0")}:${String(d.getMinutes()).padStart(2, "0")}`;
+}
+
+function sameLocalDay(a: Date, b: Date): boolean {
+  return a.getFullYear() === b.getFullYear() && a.getMonth() === b.getMonth() && a.getDate() === b.getDate();
+}
+
+/** The day a booking falls on, as an owner would say it. */
+export function dayLabel(start: Date, now: Date): string {
+  if (sameLocalDay(start, now)) return "Today";
+  const tomorrow = new Date(now.getFullYear(), now.getMonth(), now.getDate() + 1);
+  if (sameLocalDay(start, tomorrow)) return "Tomorrow";
+  return `${WEEKDAYS[start.getDay()]} ${start.getDate()} ${MONTHS[start.getMonth()]}`;
+}
+
+function startOf(b: Rec): string {
+  return str(b, "startDate", "bookedEntity.slot.startDate");
+}
+
+function booking(b: Rec, now: Date): TodayBooking {
+  const start = new Date(startOf(b));
+  const day = dayLabel(start, now);
+  return {
+    bookingId: str(b, "id"),
+    name: str(b, "contactDetails.firstName") || "Client",
+    service: str(b, "bookedEntity.title", "bookedEntity.slot.serviceName") || "Appointment",
+    timeLabel: hhmm(start),
+    dayLabel: day,
+    whenLabel: `${day} ${hhmm(start)}`,
+  };
+}
+
+const EMPTY_BOOKING: TodayBooking = { bookingId: "", name: "", service: "", timeLabel: "", dayLabel: "", whenLabel: "" };
+
+function counted(n: number, capped: boolean, one: string, many: string): string {
+  return `${capped ? `${LIMIT}+` : n} ${n === 1 && !capped ? one : many}`;
+}
+
+export interface Sources {
+  /** Upcoming CONFIRMED bookings, or null when Bookings could not be read. */
+  bookings: Rec[] | null;
+  /** Upcoming booking REQUESTS (pending statuses), read on their own: one page of every status
+   *  would fill with a busy week's confirmed bookings and hide next week's request. */
+  requests: Rec[] | null;
+  /** Orders needing attention, or null when Store could not be read. */
+  orders: Rec[] | null;
+}
+
+function upcoming(rows: Rec[] | null, statuses: string[], now: Date): Rec[] {
+  return (rows ?? [])
+    .filter((b) => str(b, "id") && statuses.includes(str(b, "status").toUpperCase()))
+    .filter((b) => Date.parse(startOf(b)) >= now.getTime())
+    .sort((a, b) => Date.parse(startOf(a)) - Date.parse(startOf(b)) || str(a, "id").localeCompare(str(b, "id")));
+}
+
+/** Pure: shape what was read into the widget state. `now` is injectable for tests. */
+export function shape(sources: Sources, now: Date, siteName: string): TodayState {
+  const bookingsReady = sources.bookings !== null && sources.requests !== null;
+  const ordersReady = sources.orders !== null;
+  // Re-filtered even though the queries filter: a server (or a fixture) that returns a
+  // cancelled or past row must not become an appointment the owner is told to expect.
+  const confirmed = bookingsReady ? upcoming(sources.bookings, ["CONFIRMED"], now) : [];
+  // Today's next CONFIRMED booking first: a request is not an appointment yet. With none left
+  // today, the first confirmed one after today, so "what's next" still has an answer.
+  const next = confirmed.find((b) => sameLocalDay(new Date(startOf(b)), now)) ?? confirmed[0];
+  const requestCount = bookingsReady ? upcoming(sources.requests, PENDING, now).length : 0;
+  const orderCount = (sources.orders ?? []).length;
+  const requestsCapped = (sources.requests ?? []).length >= LIMIT;
+  const ordersCapped = orderCount >= LIMIT;
+
+  const shortParts = [
+    ...(bookingsReady ? [`${requestsCapped ? `${LIMIT}+` : requestCount} req`] : []),
+    ...(ordersReady ? [counted(orderCount, ordersCapped, "order", "orders")] : []),
+  ];
+  const nothing = !bookingsReady && !ordersReady;
+  const nextNote = bookingsReady && !next ? COPY.noneUpcoming : "";
+  const midnight = new Date(now.getFullYear(), now.getMonth(), now.getDate() + 1).getTime();
+  const nextStart = next ? Date.parse(startOf(next)) : Infinity;
+  return {
+    validUntil: Math.floor(Math.min(midnight, nextStart) / 1000),
+    status: "ready",
+    siteName,
+    header: siteName ? `Today · ${siteName}` : "Today",
+    next: next ? booking(next, now) : EMPTY_BOOKING,
+    hasNext: !!next,
+    hideNext: !next,
+    nextNote,
+    hideNextNote: !nextNote,
+    requestCount,
+    requestLabel: requestCount ? counted(requestCount, requestsCapped, "request", "requests") : "No requests",
+    orderCount,
+    orderLabel: orderCount ? `${counted(orderCount, ordersCapped, "order", "orders")} to handle` : "No orders waiting",
+    countsShort: shortParts.join(" · "),
+    bookingsReady,
+    ordersReady,
+    hideRequests: !bookingsReady,
+    hideOrders: !ordersReady,
+    message: nothing ? COPY.nothing : "",
+    hideMessage: !nothing,
+  };
+}
+
+/** A degrade frame: ONE line, no rows. After a sign-out or a business switch the last rows
+ *  belong to someone else's clients, so none of them survive into it. */
+export function degraded(status: "error" | "signedOut" | "loading", siteName: string): TodayState {
+  // A FIXED instant, not the clock: a degrade frame has no rows, so nothing in it depends on
+  // the time — and the initial state must be deterministic (template contract: no worker's
+  // initial state may read the clock).
+  const base = shape({ bookings: null, requests: null, orders: null }, new Date(0), siteName);
+  const message = status === "signedOut" ? COPY.signedOut : status === "error" ? COPY.error : "";
+  // validUntil pinned too: shape() derives it from LOCAL midnight, so even at a fixed instant it
+  // would vary with the build machine's timezone and change the baked services hash.
+  return { ...base, status, message, hideMessage: !message, validUntil: 0 };
+}
+
+/** No usable owner session behind the bridge (the bridge refusing, or a 401). A transient
+ *  5xx is an ordinary error, not a sign-out — and a 403 is a missing PERMISSION for one
+ *  vertical (a collaborator whose role lacks Bookings), not a sign-out either. */
+export function isSignedOut(e: unknown): boolean {
+  const text = String((e as Error)?.message ?? e);
+  return /^HTTP 401\b/.test(text) || /wixApi not enabled|session unavailable|not signed in|webwix_bridge/i.test(text);
+}
+
+/** This section cannot exist for this owner: the vertical is not installed on the site (its
+ *  API answers 428, or 404 for the route), or the owner's role may not read it (403). Hides
+ *  that one section; every other failure is an error for the whole frame.
+ *
+ *  Read from the LEADING status only — the bridges format a failure as `HTTP <status>: <body>`
+ *  or `HTTP <status> [<code>]: <message>` — never from anywhere in the message: a transient
+ *  `HTTP 503: {"message":"upstream returned 404"}` must stay an error, not hide the section. */
+export function isSectionUnavailable(e: unknown): boolean {
+  const text = String((e as Error)?.message ?? e);
+  return /^HTTP (?:403|404|428)\b/.test(text) || /^HTTP \d{3} \[(?:FAILED_PRECONDITION|PERMISSION_DENIED)\]/.test(text);
+}
+
+function siteName(): string {
+  return readSelectedSite()?.name ?? "";
+}
+
+type Read = { ok: true; value: unknown } | { ok: false; error: unknown };
+
+async function attempt(fn: () => Promise<unknown>): Promise<Read> {
+  try {
+    return { ok: true, value: await fn() };
+  } catch (error) {
+    return { ok: false, error };
+  }
+}
+
+function rows(r: Read, key: string): Rec[] | null {
+  if (!r.ok) return null;
+  const list = (r.value as Rec | undefined)?.[key];
+  return Array.isArray(list) ? (list as Rec[]) : [];
+}
+
+/** The build's verticals from the descriptor's baked `input.verticals` ("bookings,store"). A
+ *  host that passes none (an older descriptor) reads both, as before. */
+export function buildVerticals(): Verticals {
+  const raw = (globalThis as { himalaya?: { input?: Record<string, unknown> } }).himalaya?.input?.verticals;
+  if (typeof raw !== "string") return { bookings: true, store: true };
+  const set = new Set(raw.split(",").map((v) => v.trim()));
+  return { bookings: set.has("bookings"), store: set.has("store") };
+}
+
+/** A section this build does not provision: never read, and indistinguishable from "not
+ *  installed" downstream (hidden, out of the compact line, out of the error rule). */
+const NOT_PROVISIONED: Read = { ok: false, error: new Error("HTTP 404: not provisioned in this build") };
+
+async function read(): Promise<TodayState> {
+  const nowIso = new Date().toISOString();
+  const verticals = buildVerticals();
+  const sort = [{ fieldName: "startDate", order: "ASC" }, { fieldName: "id", order: "ASC" }];
+  const bookingsBy = (statuses: string[]) => verticals.bookings ? attempt(() => queryBookings({ query: {
+    filter: { startDate: { $gte: nowIso }, status: { $in: statuses } },
+    sort,
+    paging: { limit: LIMIT, offset: 0 },
+  } })) : Promise.resolve(NOT_PROVISIONED);
+  const reads = await Promise.all([
+    bookingsBy(["CONFIRMED"]),
+    bookingsBy(PENDING),
+    verticals.store ? attempt(() => searchOrders({ search: {
+      filter: ownerOrderAttentionFilter(),
+      sort: [{ fieldName: "createdDate", order: "DESC" }, { fieldName: "id", order: "ASC" }],
+      cursorPaging: { limit: LIMIT },
+    } })) : Promise.resolve(NOT_PROVISIONED),
+  ]);
+  const failures = reads.flatMap((r) => (r.ok ? [] : [r.error]));
+  if (failures.some(isSignedOut)) return degraded("signedOut", "");
+  // A section that cannot exist (not installed, no permission) is hidden. ANY other failure —
+  // a transient 5xx on one read included — makes this an error frame, which the phone does
+  // not publish: the last good frame stays, rather than a frame that silently drops a
+  // section the owner does have and reads as "nothing waiting".
+  if (failures.some((e) => !isSectionUnavailable(e))) return degraded("error", siteName());
+  const [bookings, requests, orders] = reads;
+  return shape({
+    bookings: rows(bookings, "bookings"),
+    requests: rows(requests, "bookings"),
+    orders: rows(orders, "orders"),
+  }, new Date(), siteName());
+}
+
+const svc = defineService<TodayState, {
+  load: (s: TodayState) => Promise<TodayState>;
+  refresh: (s: TodayState) => Promise<TodayState>;
+}>("ownerToday", {
+  state: degraded("loading", ""),
+  actions: {
+    load: async () => read(),
+    refresh: async () => read(),
+  },
+});
+
+export { svc };

package/templates/gym-fitness-owner/tier5-src/himi-owner-lite-wrist/index.ts

@@ -13,7 +13,10 @@
 // render and tap must never confirm another business's booking.
 
 import { defineService } from "@himalaya/state";
-import { queryBookings, confirmBooking, declineBooking } from "@himalaya/wix-bookings";
+import { getBooking, queryBookings } from "@himalaya/wix-bookings";
+import {
+  PENDING_BOOKING_STATUSES as PENDING, isForActiveBusiness, isStaleBookingWrite as isStale, writeBookingResponse, type BookingResponse,
+} from "../_shared/owner-booking-respond.js";
 import { isBridgeUnavailable } from "../_shared/owner-load-error.js";
 import { readSelectedSite, selectedSiteName } from "../_shared/owner-selected-site.js";
 
@@ -80,9 +83,9 @@ export const COPY = {
   changed: "This request changed — check it on your iPhone",
   error: "Open Owner on your iPhone",
   writeFailed: "Couldn't update it — check it on your iPhone",
+  busy: "Still updating the last one — try again",
 } as const;
 
-const PENDING = new Set(["PENDING", "PENDING_APPROVAL", "WAITING_LIST"]);
 const LIMIT = 50;
 
 function str(r: Rec | undefined, ...paths: string[]): string {
@@ -257,25 +260,39 @@ async function fetchInto(s: WristState): Promise<WristState> {
   return shape([...byId.values()], new Date(), site(), s.requestIndex);
 }
 
-function isStale(e: unknown): boolean {
-  return /revision|\b409\b|ABORTED|conflict/i.test(String((e as Error)?.message ?? e));
-}
-
-type Write = (bookingId: string, revision: string) => Promise<unknown>;
-
-async function respond(s: WristState, params: unknown, write: Write): Promise<WristState> {
+async function respond(s: WristState, params: unknown, kind: BookingResponse): Promise<WristState> {
   if (s.inFlight) return s;
   const p = (params && typeof params === "object" ? params : {}) as Rec;
   const bookingId = str(p, "bookingId");
   const siteId = str(p, "siteId");
-  // A press rendered for another business, or for a request that is no longer pending.
-  if (siteId !== site().id) return { ...s, actionError: COPY.changed };
-  const target = s.requests.find((r) => r.bookingId === bookingId);
+  // A press rendered for another business — or naming none, or made while no business is
+  // active (two empty ids are not the same business) — or for a request no longer pending.
+  if (!isForActiveBusiness(siteId, site().id)) return { ...s, actionError: COPY.changed };
+  let target = s.requests.find((r) => r.bookingId === bookingId);
+  if (!target && bookingId) {
+    // Not in the queue this state was read with: a press relayed from a NOTIFICATION
+    // can name a request that arrived after the last read, or one past the queue's first page.
+    // The booking itself, read by id from the business the press names, decides — one that is
+    // not pending there is not written. Guarded like the write, so a second press during the
+    // read cannot start a second one.
+    inFlightNow = true;
+    inFlightBooking = bookingId;
+    try {
+      const booking = ((await getBooking(bookingId, { site: siteId })) as unknown as { booking?: Rec } | undefined)?.booking;
+      if (booking && str(booking, "revision") && PENDING.has(str(booking, "status"))
+        && handled.get(bookingId) !== str(booking, "revision")) target = request({ ...booking, id: bookingId });
+    } catch (e) {
+      inFlightNow = false;
+      return isSignedOut(e) ? failure(s, e) : { ...s, actionError: COPY.changed };
+    }
+    inFlightNow = false;
+  }
   if (!target) return { ...s, actionError: COPY.changed };
   inFlightNow = true;
+  inFlightBooking = bookingId;
   writeGeneration += 1;
   try {
-    await write(target.bookingId, target.revision);
+    await writeBookingResponse(kind, target.bookingId, target.revision, siteId);
     handled.set(target.bookingId, target.revision);
   } catch (e) {
     inFlightNow = false;
@@ -319,6 +336,16 @@ async function read(s: WristState): Promise<WristState> {
 // The state a concurrent action sees is the one it was dispatched with, so a double tap
 // would read `inFlight: false` twice; this module flag is the guard that actually holds.
 let inFlightNow = false;
+/** The request that write is for. */
+let inFlightBooking = "";
+
+/** A press that lands while a write is running. The same request again (a double tap) is that
+ *  write; ANOTHER request — a second notification's Accept relayed from the watch — was not
+ *  written, and must say so rather than come back looking handled. */
+function whileBusy(s: WristState, params: unknown): WristState {
+  const bookingId = str((params && typeof params === "object" ? params : {}) as Rec, "bookingId");
+  return bookingId && bookingId !== inFlightBooking ? { ...s, actionError: COPY.busy } : s;
+}
 
 const svc = defineService<WristState, {
   load: (s: WristState) => Promise<WristState>;
@@ -333,8 +360,8 @@ const svc = defineService<WristState, {
   actions: {
     load: async (s) => read(s),
     refresh: async (s) => read(s),
-    confirm: async (s, params) => (inFlightNow ? s : respond(s, params, (id, rev) => confirmBooking(id, rev))),
-    decline: async (s, params) => (inFlightNow ? s : respond(s, params, (id, rev) => declineBooking(id, rev))),
+    confirm: async (s, params) => (inFlightNow ? whileBusy(s, params) : respond(s, params, "confirm")),
+    decline: async (s, params) => (inFlightNow ? whileBusy(s, params) : respond(s, params, "decline")),
     askDecline: async (s) => (s.current.bookingId ? { ...s, confirmingDecline: true, notConfirmingDecline: false, actionError: "" } : s),
     cancelDecline: async (s) => ({ ...s, confirmingDecline: false, notConfirmingDecline: true }),
     nextRequest: async (s) => {