@wix/himalaya-cli 0.1253.0 → 0.1254.0

package/templates/beauty-salon-owner/tier5-src/himi-owner-lite-search/logic.ts

@@ -106,6 +106,14 @@ export interface SearchItem {
   /** Stable across refreshes, so a re-fetch cannot re-key a row under the
    *  user's finger: `h:<source>`, `r:<source>:<id>`, `f:<source>`. */
   key: string;
+  /** The row's LIST identity — always equal to `key`, never blank.
+   *
+   *  A bound list keys its rows on `id` (the web BoundList does, verbatim). This
+   *  carried the record id, which left every heading and footer at `""` and let
+   *  two domains that reuse a record id collide — so React reconciled headings
+   *  onto each other as groups landed and painted "Contacts" three times.
+   *  What a record OPENS is `recordId`. */
+  id: string;
   /** The source this row belongs to — a retry or a pager addresses it. */
   sourceId: string;
   // Exactly one kind is true. Pre-negated, because a `hiddenWhen` takes one path.
@@ -122,7 +130,9 @@ export interface SearchItem {
   isLoading: boolean;
   notLoading: boolean;
   // Record.
-  id: string;
+  /** The record this row opens — the destination loads it by this id. Blank on
+   *  headings and footers, which open nothing. */
+  recordId: string;
   title: string;
   subtitle: string;
   statusLabel: string;
@@ -163,6 +173,10 @@ export interface SearchState {
    *  nobody has typed into yet, and again over every result still in flight. */
   showEmpty: boolean;
   hideEmpty: boolean;
+  /** The empty state's heading, naming the query ("No records match “mug”").
+   *  Blank unless `showEmpty` — and while it shows, `summary` is blank, because
+   *  the two sat one above the other saying the same sentence. */
+  emptyTitle: string;
 }
 
 export interface SearchCopy {
@@ -192,7 +206,9 @@ export const DEFAULT_COPY: SearchCopy = {
   allFailed: "No area could be searched",
   loadedOnly: "{n} in loaded records",
   loadingSummary: "Searching…",
-  emptySummary: "No records matched",
+  /** The empty state's heading. `{q}` is the query the owner typed, so the
+   *  state says WHAT matched nothing rather than only that something did not. */
+  emptySummary: "No records match “{q}”",
   idleSummary: "Search your business records",
   permission: "You don’t have access to this area",
   setup: "This area isn’t set up on this site",
@@ -231,6 +247,14 @@ function fill(template: string, n: number, token = "{n}"): string {
   return template.includes(token) ? template.split(token).join(String(n)) : `${template} ${n}`;
 }
 
+/** `{q}` → the query. Custom copy stays query-specific even when it omits the
+ *  placeholder, so the empty state always identifies what was searched. */
+function fillQuery(template: string, query: string): string {
+  return template.includes("{q}")
+    ? template.split("{q}").join(query)
+    : `${template}: “${query}”`;
+}
+
 function idleGroup(adapter: SearchAdapter): SearchGroup {
   return decorate({
     id: adapter.id,
@@ -273,9 +297,9 @@ function baseItem(sourceId: string): SearchItem {
     isHeader: false, notHeader: true,
     isRecord: false, notRecord: true,
     isFooter: false, notFooter: true,
-    label: "", countLabel: "",
+    id: "", label: "", countLabel: "",
     isLoading: false, notLoading: true,
-    id: "", title: "", subtitle: "", statusLabel: "", image: "", screenId: "",
+    recordId: "", title: "", subtitle: "", statusLabel: "", image: "", screenId: "",
     error: "", hasError: false, noError: true,
     canLoadMore: false, cannotLoadMore: true, isLoadingMore: false,
   };
@@ -302,7 +326,7 @@ export function projectItems(groups: SearchGroup[]): SearchItem[] {
     if (silent) continue;
     items.push({
       ...baseItem(group.id),
-      key: `h:${group.id}`,
+      key: `h:${group.id}`, id: `h:${group.id}`,
       isHeader: true, notHeader: false,
       label: group.label,
       // A count is only shown once there is something to count: "0" under a
@@ -313,9 +337,9 @@ export function projectItems(groups: SearchGroup[]): SearchItem[] {
     for (const row of group.rows) {
       items.push({
         ...baseItem(group.id),
-        key: `r:${group.id}:${row.id}`,
+        key: `r:${group.id}:${row.id}`, id: `r:${group.id}:${row.id}`,
         isRecord: true, notRecord: false,
-        id: row.id, title: row.title, subtitle: row.subtitle,
+        recordId: row.id, title: row.title, subtitle: row.subtitle,
         statusLabel: row.statusLabel, image: row.image, screenId: row.screenId,
       });
     }
@@ -325,7 +349,7 @@ export function projectItems(groups: SearchGroup[]): SearchItem[] {
     if (group.hasError || group.problem !== "" || group.canLoadMore) {
       items.push({
         ...baseItem(group.id),
-        key: `f:${group.id}`,
+        key: `f:${group.id}`, id: `f:${group.id}`,
         isFooter: true, notFooter: false,
         error: group.error,
         hasError: group.error !== "", noError: group.error === "",
@@ -393,7 +417,9 @@ export function createGroupedSearch(
       : anyLoading && total === 0
         ? copy.loadingSummary
         : total === 0
-          ? (anyAnswered ? copy.emptySummary : copy.allFailed)
+          // Empty and answered: the empty block carries the sentence, so the
+          // summary line above it steps aside rather than repeating it.
+          ? (anyAnswered ? "" : copy.allFailed)
           : total === 1
             ? copy.resultsOne
             : areas === 1
@@ -416,6 +442,7 @@ export function createGroupedSearch(
       anyLoading,
       showEmpty: emptyAndAnswered,
       hideEmpty: !emptyAndAnswered,
+      emptyTitle: emptyAndAnswered ? fillQuery(copy.emptySummary, query) : "",
     };
   };
 

package/templates/community-club-owner/dev/index.ts

@@ -52895,7 +52895,7 @@ const SCREENS = runtimeSetting({
       "contentType": "application/javascript+ts-bundle",
       "declaredCapabilities": [
         "wix_api",
-        "local_database"
+        "wix_platform"
       ],
       "minBinaryVersion": "0.1.0",
       "bundleVersion": "0.0.1"
@@ -52980,7 +52980,8 @@ const SCREENS = runtimeSetting({
                 "props": {
                   "text": "$service:himiOwnerLiteSearch.summary",
                   "style": "caption",
-                  "color": "textSecondary"
+                  "color": "textSecondary",
+                  "collapseWhenEmpty": true
                 }
               }
             },
@@ -53095,7 +53096,7 @@ const SCREENS = runtimeSetting({
                                     "actionId": "himi.open",
                                     "params": {
                                       "screenId": "$item.screenId",
-                                      "id": "$item.id"
+                                      "id": "$item.recordId"
                                     }
                                   }
                                 }
@@ -53201,8 +53202,9 @@ const SCREENS = runtimeSetting({
                         "package": "himalaya",
                         "type": "Text",
                         "props": {
-                          "text": "No records matched",
-                          "style": "bodyEmphasis"
+                          "text": "$service:himiOwnerLiteSearch.emptyTitle",
+                          "style": "bodyEmphasis",
+                          "maxLines": 2
                         }
                       }
                     },

package/templates/community-club-owner/tier5-src/_shared/owner-module-data.ts

@@ -49,6 +49,76 @@ function siteZone(): Promise<string | undefined> {
   return zoneLookup;
 }
 
+/** A subscription order stores its buyer as an internal member/contact id. Resolve the
+ *  display name so the owner can search subscriptions by the same person name shown in
+ *  the dedicated subscriptions screen. Fetch member ids directly, and page the member
+ *  directory only for contact ids. This is best-effort: missing member access must not
+ *  hide otherwise readable plan orders. */
+async function subscriptionMemberNames(orders: unknown[]): Promise<Map<string, string>> {
+  const memberIds = [...new Set(orders.map(order => field(order, 'buyer.memberId')).filter(Boolean))];
+  const unresolvedContacts = new Set(orders.map(order => field(order, 'buyer.contactId')).filter(Boolean));
+  const names = new Map<string, string>();
+  const remember = (member: unknown) => {
+    const emails = at(member, 'contact.emails');
+    const email = Array.isArray(emails) ? scalar(emails[0]) : '';
+    const displayName = name(member, 'contact.firstName', 'contact.lastName')
+      || field(member, 'profile.nickname') || email || field(member, 'loginEmail');
+    if (!displayName) return;
+    const id = field(member, 'id'), contactId = field(member, 'contactId');
+    if (id) names.set(id, displayName);
+    if (contactId) {
+      names.set(contactId, displayName);
+      unresolvedContacts.delete(contactId);
+    }
+  };
+
+  // The first directory page is useful for buyers already in view. For a buyer outside
+  // that page, fetch the known member ID directly instead of walking the whole directory.
+  const pageSize = 100;
+  let offset = 0;
+  let canPageDirectory = false;
+  try {
+    const response = await queryMembers({ query: { paging: { limit: pageSize, offset } } });
+    const members = response.members ?? [];
+    for (const member of members) remember(member);
+    offset += members.length;
+    const total = response.metadata?.total;
+    canPageDirectory = members.length > 0
+      && (typeof total === 'number' ? offset < total : members.length === pageSize);
+  } catch {
+    // Member details below can still work when the directory query is unavailable.
+  }
+
+  const unresolvedMembers = memberIds.filter(id => !names.has(id));
+  for (let start = 0; start < unresolvedMembers.length; start += 10) {
+    const members = await Promise.all(unresolvedMembers.slice(start, start + 10).map(async id => {
+      try { return (await getMember(id)).member; } catch { return undefined; }
+    }));
+    for (const member of members) if (member) remember(member);
+  }
+
+  if (!unresolvedContacts.size || !canPageDirectory) return names;
+  try {
+    while (unresolvedContacts.size) {
+      const response = await queryMembers({ query: { paging: { limit: pageSize, offset } } });
+      const members = response.members ?? [];
+      for (const member of members) remember(member);
+      if (!members.length) break;
+      offset += members.length;
+      const total = response.metadata?.total;
+      if (typeof total === 'number' ? offset >= total : members.length < pageSize) break;
+    }
+  } catch {
+    // A later page can fail after earlier pages already resolved some buyers.
+    // Keep those names; this is best-effort context, never a reason to hide an order.
+  }
+  return names;
+}
+
+function subscriptionBuyerName(order: unknown, names: Map<string, string>): string {
+  return names.get(field(order, 'buyer.memberId')) || names.get(field(order, 'buyer.contactId')) || '';
+}
+
 /** A Wix date value as an instant. A calendar date with no time ("2026-11-07") is a DAY, not an
  *  instant: it is built at local midnight and formatted with no zone, so it never shifts across
  *  one — including on engines without Intl, where a zone could not be applied anyway. */
@@ -99,7 +169,8 @@ export async function queryOwnerModule(module: OwnerModuleId, cursor = ''): Prom
   // The zone lookup runs beside the query, not after it: the two are independent, and serial
   // they would double the time to a first paint.
   const [raw, zone] = await Promise.all([queryRawOwnerModule(module, cursor), siteZone()]);
-  return { ...raw, items: raw.items.map(row => ownerRecord(module, row, zone)) };
+  const subscribers = module === 'subscriptions' ? await subscriptionMemberNames(raw.items) : new Map<string, string>();
+  return { ...raw, items: raw.items.map(row => ownerRecord(module, row, zone, subscriptionBuyerName(row, subscribers))) };
 }
 
 async function queryRawOwnerModule(module: OwnerModuleId, cursor: string): Promise<CollectionPage<unknown>> {
@@ -171,7 +242,7 @@ async function queryRawOwnerModule(module: OwnerModuleId, cursor: string): Promi
   }
 }
 
-export function ownerRecord(module: OwnerModuleId, raw: unknown, zone?: string): OwnerRecord {
+export function ownerRecord(module: OwnerModuleId, raw: unknown, zone?: string, subscriberName = ''): OwnerRecord {
   const when = (path: string, style?: DateStyle) => ownerDate(field(raw, path), zone, style);
   const id = field(raw, 'id');
   if (!id) throw new Error('Wix returned a record without an identity. Refresh this view.');
@@ -239,14 +310,13 @@ export function ownerRecord(module: OwnerModuleId, raw: unknown, zone?: string):
       details = [['Price', join(field(raw, 'pricing.price.value'), field(raw, 'pricing.price.currency'))], ['Free trial days', field(raw, 'pricing.freeTrialDays')]];
       break;
     case 'subscriptions':
-      // The buyer is only a member UUID here — not something an owner can read — so the
-      // row says when the plan started instead of echoing an internal id.
       title = field(raw, 'planName'); statusLabel = words(field(raw, 'status'));
       {
         const started = when('startDate', 'short');
-        subtitle = started ? copyTemplate('ownerModules.startedOn', 'Started {date}', { date: started }) : '';
+        const startedLabel = started ? copyTemplate('ownerModules.startedOn', 'Started {date}', { date: started }) : '';
+        subtitle = join(subscriberName, startedLabel);
       }
-      details = [['Started', when('startDate')], ['Ends', when('endDate')], ['Payment', words(field(raw, 'lastPaymentStatus'))]];
+      details = [['Subscriber', subscriberName], ['Started', when('startDate')], ['Ends', when('endDate')], ['Payment', words(field(raw, 'lastPaymentStatus'))]];
       break;
     case 'programs':
       title = field(raw, 'description.title') || field(raw, 'details.title') || field(raw, 'name');
@@ -344,7 +414,8 @@ export async function getOwnerRecord(module: OwnerModuleId, id: string): Promise
     }
     case 'donationCampaigns': raw = (await getDonationCampaign(id)).donationCampaign; break;
   }
-  const record = ownerRecord(module, raw, await zone);
+  const subscribers = module === 'subscriptions' ? await subscriptionMemberNames([raw]) : new Map<string, string>();
+  const record = ownerRecord(module, raw, await zone, subscriptionBuyerName(raw, subscribers));
   if (record.id !== id) throw new Error('The returned record does not match this link. Refresh the collection.');
   return record;
 }

package/templates/community-club-owner/tier5-src/_shared/owner-order-attention.ts

@@ -0,0 +1,18 @@
+/** The Home dashboard's canonical Orders attention filter. Keep drawer reminders on
+ * the same definition so the two surfaces never disagree about what needs review. */
+export function ownerOrderAttentionFilter(updatedAfter?: string): Record<string, unknown> {
+  const filter: Record<string, unknown> = {
+    archived: false,
+    status: { $nin: ["CANCELED", "CANCELLED"] },
+    $or: [
+      { paymentStatus: { $in: ["NOT_PAID", "PARTIALLY_PAID"] } },
+      { paymentStatus: "PAID", fulfillmentStatus: { $in: ["NOT_FULFILLED", "PARTIALLY_FULFILLED"] } },
+    ],
+  };
+  return updatedAfter
+    ? { $and: [filter, { $or: [
+        { createdDate: { $gt: updatedAfter } },
+        { updatedDate: { $gt: updatedAfter } },
+      ] }] }
+    : filter;
+}

package/templates/community-club-owner/tier5-src/himi-owner-lite-drawer/index.ts

@@ -19,8 +19,277 @@
 
 import { defineService } from "@himalaya/state";
 import { serializeForAgent } from "@himalaya/agent";
+import { searchOrders } from "@himalaya/wix-ecom";
+import { queryBookings, type WixBooking } from "@himalaya/wix-bookings";
+import { site } from "@himalaya/wix-platform";
 import { activeScreenFromInput, attentionRow, navRow, withDerived, type DrawerState } from "./logic.js";
-import { fallbackNameFrom, selectedSiteName } from "../_shared/owner-selected-site.js";
+import { UPCOMING_BOOKING_STATUSES, upcomingBookingCount } from "../_shared/owner-bookings.js";
+import { ownerOrderAttentionFilter } from "../_shared/owner-order-attention.js";
+import { fallbackNameFrom, readSelectedSite, selectedSiteName } from "../_shared/owner-selected-site.js";
+
+const ATTENTION_PAGE = 50;
+const DISMISSED_AT_KEY = "himi.ownerLite.drawer.attentionDismissedAt.v1";
+const OBSERVED_ACTIVITY_AT_KEY = "himi.ownerLite.drawer.latestObservedActivityAt.v1";
+const DISMISSED_BOOKINGS_KEY = "himi.ownerLite.drawer.dismissedBookings.v1";
+const OBSERVED_BOOKINGS_KEY = "himi.ownerLite.drawer.observedBookings.v1";
+const DISMISSED_ORDERS_KEY = "himi.ownerLite.drawer.dismissedOrders.v1";
+const OBSERVED_ORDERS_KEY = "himi.ownerLite.drawer.observedOrders.v1";
+let refreshRevision = 0;
+
+type DrawerStorage = { getItem(key: string): string | null; setItem(key: string, value: string): void };
+type DrawerHost = typeof globalThis & { himalaya?: { storage?: DrawerStorage; input?: Record<string, unknown> } };
+
+function currentSiteId(): string {
+  const selected = readSelectedSite()?.id;
+  if (selected) return selected;
+  const business = (globalThis as DrawerHost).himalaya?.input?.business;
+  return typeof business === "string" && business.trim() !== "default" ? business.trim() : "";
+}
+
+function dismissalKey(siteId = currentSiteId()): string {
+  const input = (globalThis as DrawerHost).himalaya?.input;
+  const key = siteId || (typeof input?.business === "string" ? input.business.trim() : "") || "default";
+  return DISMISSED_AT_KEY + ":" + encodeURIComponent(key);
+}
+
+function dismissedAt(key = dismissalKey()): string {
+  // If persistence is unavailable, fail the refresh instead of treating a failed
+  // read as “not dismissed” and unexpectedly restoring hidden reminders.
+  const value = (globalThis as DrawerHost).himalaya?.storage?.getItem(key) ?? "";
+  return value && Number.isFinite(Date.parse(value)) ? value : "";
+}
+
+function latestActivityAt(record: { createdDate?: unknown; updatedDate?: unknown }): string {
+  const timestamps = [record.createdDate, record.updatedDate]
+    .filter((value): value is string => typeof value === "string" && Number.isFinite(Date.parse(value)))
+    .sort((a, b) => Date.parse(b) - Date.parse(a));
+  return timestamps[0] ?? "";
+}
+
+function newerActivity(left: string, right: string): string {
+  return !left || (right && Date.parse(right) > Date.parse(left)) ? right : left;
+}
+
+function rememberObservedActivity(siteKey: string, value: string): void {
+  if (!value) return;
+  try {
+    const storage = (globalThis as DrawerHost).himalaya?.storage;
+    const key = `${OBSERVED_ACTIVITY_AT_KEY}:${encodeURIComponent(siteKey)}`;
+    const previous = storage?.getItem(key) ?? "";
+    const latest = newerActivity(previous, value);
+    if (latest) storage?.setItem(key, latest);
+  } catch { /* best-effort local preference */ }
+}
+
+type RecordSnapshot = Record<string, string>;
+type BookingSnapshot = RecordSnapshot;
+type OrderSnapshot = RecordSnapshot;
+
+function bookingSnapshotKey(prefix: string, siteKey: string): string {
+  return `${prefix}:${encodeURIComponent(siteKey)}`;
+}
+
+function readRecordSnapshot(key: string): RecordSnapshot | undefined {
+  const raw = (globalThis as DrawerHost).himalaya?.storage?.getItem(key);
+  if (raw === null || raw === undefined) return undefined;
+  const value = JSON.parse(raw) as unknown;
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("Stored drawer reminder snapshot must be an object");
+  }
+  const entries = Object.entries(value);
+  if (entries.some((entry) => typeof entry[1] !== "string")) {
+    throw new Error("Stored drawer reminder snapshot values must be strings");
+  }
+  return Object.fromEntries(entries) as RecordSnapshot;
+}
+
+const readBookingSnapshot = (key: string): BookingSnapshot | undefined => readRecordSnapshot(key);
+
+function orderSignature(order: {
+  archived?: unknown;
+  status?: unknown;
+  paymentStatus?: unknown;
+  fulfillmentStatus?: unknown;
+  createdDate?: unknown;
+  updatedDate?: unknown;
+}): string {
+  return JSON.stringify({
+    archived: order.archived ?? null,
+    status: order.status ?? "",
+    paymentStatus: order.paymentStatus ?? "",
+    fulfillmentStatus: order.fulfillmentStatus ?? "",
+    createdDate: order.createdDate ?? "",
+    updatedDate: order.updatedDate ?? "",
+  });
+}
+
+function orderSnapshot(orders: Array<{ id?: string } & Parameters<typeof orderSignature>[0]>): OrderSnapshot {
+  return Object.fromEntries(orders.filter((order) => order.id)
+    .map((order) => [order.id!, orderSignature(order)]));
+}
+
+function rememberObservedOrders(siteKey: string, snapshot: OrderSnapshot): void {
+  try {
+    (globalThis as DrawerHost).himalaya?.storage?.setItem(
+      bookingSnapshotKey(OBSERVED_ORDERS_KEY, siteKey), JSON.stringify(snapshot),
+    );
+  } catch { /* best-effort local preference */ }
+}
+
+function bookingSignature(booking: WixBooking): string {
+  return JSON.stringify({
+    status: booking.status ?? "",
+    paymentStatus: booking.paymentStatus ?? "",
+    startDate: booking.startDate ?? "",
+    endDate: booking.endDate ?? "",
+    slotStartDate: booking.bookedEntity?.slot?.startDate ?? "",
+    slotEndDate: booking.bookedEntity?.slot?.endDate ?? "",
+    totalParticipants: booking.totalParticipants ?? null,
+    serviceId: booking.bookedEntity?.slot?.serviceId ?? "",
+    serviceTitle: booking.bookedEntity?.title ?? "",
+  });
+}
+
+function bookingSnapshot(bookings: WixBooking[]): BookingSnapshot {
+  return Object.fromEntries(bookings.filter((booking) => booking.id)
+    .map((booking) => [booking.id, bookingSignature(booking)]));
+}
+
+function rememberObservedBookings(siteKey: string, snapshot: BookingSnapshot): void {
+  try {
+    (globalThis as DrawerHost).himalaya?.storage?.setItem(
+      bookingSnapshotKey(OBSERVED_BOOKINGS_KEY, siteKey), JSON.stringify(snapshot),
+    );
+  } catch { /* best-effort local preference */ }
+}
+
+function rememberDismissal(siteKey: string): void {
+  try {
+    const storage = (globalThis as DrawerHost).himalaya?.storage;
+    const observedKey = bookingSnapshotKey(OBSERVED_BOOKINGS_KEY, siteKey);
+    const dismissedKey = bookingSnapshotKey(DISMISSED_BOOKINGS_KEY, siteKey);
+    storage?.setItem(dismissedKey, storage?.getItem(observedKey) ?? "{}");
+    const observedOrdersKey = bookingSnapshotKey(OBSERVED_ORDERS_KEY, siteKey);
+    const dismissedOrdersKey = bookingSnapshotKey(DISMISSED_ORDERS_KEY, siteKey);
+    storage?.setItem(dismissedOrdersKey, storage?.getItem(observedOrdersKey) ?? "{}");
+  } catch { /* best-effort local preference */ }
+  try {
+    const storage = (globalThis as DrawerHost).himalaya?.storage;
+    const observed = storage?.getItem(`${OBSERVED_ACTIVITY_AT_KEY}:${encodeURIComponent(siteKey)}`) ?? "";
+    // Wix record timestamps are server-generated. Do not substitute device time:
+    // an ahead clock can hide later Wix activity. Order snapshots cover records
+    // without timestamps.
+    const previous = dismissedAt(siteKey);
+    storage?.setItem(siteKey, observed || previous);
+  } catch { /* best-effort local preference */ }
+}
+
+async function countAttentionOrders(
+  filter: Record<string, unknown>, siteId: string, dismissed: string, dismissedSnapshot: OrderSnapshot | undefined,
+): Promise<{ count: number; latestActivity: string; snapshot: OrderSnapshot }> {
+  const orders: Array<{ id?: string } & Parameters<typeof orderSignature>[0]> = [];
+  let latestActivity = "";
+  let cursor = "";
+  const seenIds = new Set<string>();
+  const seen = new Set<string>();
+  while (true) {
+    const response = await searchOrders({ search: {
+      filter,
+      sort: [{ fieldName: "createdDate", order: "DESC" }, { fieldName: "id", order: "ASC" }],
+      cursorPaging: { limit: ATTENTION_PAGE, ...(cursor ? { cursor } : {}) },
+    } }, siteId ? site.forSite(siteId) : undefined);
+    for (const order of response.orders ?? []) {
+      latestActivity = newerActivity(latestActivity, latestActivityAt(order));
+      if (order.id && seenIds.has(order.id)) continue;
+      if (order.id) seenIds.add(order.id);
+      orders.push(order);
+    }
+    const metadata = response.metadata as { hasNext?: boolean; cursors?: { next?: string | null } } | undefined;
+    const next = metadata?.cursors?.next ?? "";
+    if (metadata?.hasNext === false) break;
+    // Keep the count already observed if the API advertises another page without
+    // giving us a usable cursor. This is a lower bound, but still alerts the owner.
+    if (!next || seen.has(next)) break;
+    seen.add(next);
+    cursor = next;
+  }
+  const snapshot = orderSnapshot(orders);
+  const hasDismissal = Boolean(dismissed) || dismissedSnapshot !== undefined;
+  const count = hasDismissal
+    ? orders.filter((order) => {
+      const activity = latestActivityAt(order);
+      if (dismissed && activity) return Date.parse(activity) > Date.parse(dismissed);
+      if (dismissedSnapshot !== undefined) {
+        return !order.id || dismissedSnapshot[order.id] === undefined
+          || dismissedSnapshot[order.id] !== orderSignature(order);
+      }
+      return activity !== "" && Date.parse(activity) > Date.parse(dismissed);
+    }).length
+    : orders.length;
+  return { count, latestActivity, snapshot };
+}
+
+async function countUpcomingBookings(
+  filter: Record<string, unknown>, now: number, dismissed: string, dismissedSnapshot: BookingSnapshot | undefined, siteId: string,
+): Promise<{ count: number; latestActivity: string; snapshot: BookingSnapshot }> {
+  const bookings: WixBooking[] = [];
+  const seenIds = new Set<string>();
+  const seenPages = new Set<string>();
+  let offset = 0;
+  let latestActivity = "";
+  const result = () => {
+    const hasDismissal = Boolean(dismissed) || dismissedSnapshot !== undefined;
+    const visible = hasDismissal
+      ? bookings.filter((booking) => {
+        const createdAfterDismissal = dismissed !== ""
+          && Date.parse(booking.createdDate ?? "") > Date.parse(dismissed);
+        if (createdAfterDismissal) return true;
+        if (!dismissedSnapshot) return false; // Legacy timestamp-only dismissal.
+        if (!booking.id) return false;
+        return dismissedSnapshot[booking.id] === undefined
+          || dismissedSnapshot[booking.id] !== bookingSignature(booking);
+      })
+      : bookings;
+    return {
+      count: upcomingBookingCount(visible, now),
+      latestActivity,
+      snapshot: bookingSnapshot(bookings),
+    };
+  };
+  while (true) {
+    const response = await queryBookings({ query: {
+      filter,
+      sort: [{ fieldName: "startDate", order: "ASC" }, { fieldName: "id", order: "ASC" }],
+      paging: { limit: ATTENTION_PAGE, offset },
+    } }, siteId ? site.forSite(siteId) : undefined);
+    const page = response.bookings ?? [];
+    const pageSignature = page.map((booking) => booking.id
+      ? `id:${booking.id}`
+      : `record:${JSON.stringify(booking)}`).sort().join("\0");
+    if (pageSignature && seenPages.has(pageSignature)) {
+      return result();
+    }
+    if (pageSignature) seenPages.add(pageSignature);
+    for (const booking of page) {
+      latestActivity = newerActivity(latestActivity, latestActivityAt(booking));
+      if (booking.id && seenIds.has(booking.id)) continue;
+      if (booking.id) seenIds.add(booking.id);
+      bookings.push(booking);
+    }
+    // Some Wix responses mark a total as too large to count even though the
+    // committed SDK metadata type does not include that wire field.
+    const metadata = response.pagingMetadata as (typeof response.pagingMetadata & { tooManyToCount?: boolean }) | undefined;
+    const total = metadata?.total;
+    if (typeof total === "number" && Number.isFinite(total) && metadata?.tooManyToCount !== true) {
+      const expected = Math.max(0, Math.floor(total));
+      if (bookings.length >= expected || page.length === 0) return result();
+      offset += page.length;
+      continue;
+    }
+    if (page.length < ATTENTION_PAGE) return result();
+    offset += page.length;
+  }
+}
 
 /** The shell passes the screen it is showing as worker input, so the drawer can mark
  *  that destination selected the way the declarative drawer does. */
@@ -35,7 +304,7 @@ const currentSiteName = () => selectedSiteName(fallbackBusinessName);
 const drawer = defineService<DrawerState, {
   /** The panel opened (root onAppear): re-read the live site and the active screen.
    *  `arg.businessName` is the cold-start fallback for the site name. */
-  refresh: (s: DrawerState, arg?: unknown) => DrawerState;
+  refresh: (s: DrawerState, arg?: unknown) => Promise<DrawerState>;
   /** Re-read the active screen from host input. An explicit
    *  `{ screenId }` wins, for a host that pushes the change instead. */
   syncActive: (s: DrawerState, args?: { screenId?: string }) => DrawerState;
@@ -57,20 +326,59 @@ const drawer = defineService<DrawerState, {
       navRow("drawer_manage", "Manage", "grid", "himi_owner_lite_manage"),
       navRow("drawer_account", "Account", "person", "himi_owner_lite_account"),
     ],
-    attention: [
-      attentionRow("att_orders", "Orders", "cart", "himi_owner_lite_orders", 3),
-      attentionRow("att_appts", "Appointments", "calendar", "himi_owner_lite_appointments", 1),
-    ],
+    // Live rows arrive only after refresh. A cold/failed read never invents reminders.
+    attention: [],
     confirmingClear: false,
     activeScreenId: hostActiveScreen(),
   }),
   actions: {
-    refresh: (s, arg) => {
+    refresh: async (s, arg): Promise<DrawerState> => {
       fallbackBusinessName = fallbackNameFrom(arg, fallbackBusinessName);
       const screenId = (arg as { screenId?: unknown } | undefined)?.screenId;
+      const now = Date.now();
+      // Invalidate older work before any read that can fail, including persistence.
+      const revision = ++refreshRevision;
+      const siteId = currentSiteId();
+      const siteKey = dismissalKey(siteId);
+      const dismissed = dismissedAt(siteKey);
+      const dismissedSnapshot = readBookingSnapshot(bookingSnapshotKey(DISMISSED_BOOKINGS_KEY, siteKey));
+      const dismissedOrders = readRecordSnapshot(bookingSnapshotKey(DISMISSED_ORDERS_KEY, siteKey));
+      // Only the newest same-site refresh may apply, so a slower earlier request
+      // cannot replace a result from a newer refresh.
+      const [ordersResult, bookingsResult] = await Promise.allSettled([
+        countAttentionOrders(ownerOrderAttentionFilter(), siteId, dismissed, dismissedOrders),
+        countUpcomingBookings({
+          startDate: { $gte: new Date(now).toISOString() },
+          status: { $in: UPCOMING_BOOKING_STATUSES },
+        }, now, dismissed, dismissedSnapshot, siteId),
+      ]);
+      // A user may dismiss while either request is in flight. Do not let this
+      // older result put the dismissed rows back into the current state.
+      if (revision !== refreshRevision || siteKey !== dismissalKey()) return drawer.getState();
+      const latestActivity = newerActivity(
+        ordersResult.status === "fulfilled" ? ordersResult.value.latestActivity : "",
+        bookingsResult.status === "fulfilled" ? bookingsResult.value.latestActivity : "",
+      );
+      rememberObservedActivity(siteKey, latestActivity);
+      if (ordersResult.status === "fulfilled") rememberObservedOrders(siteKey, ordersResult.value.snapshot);
+      if (bookingsResult.status === "fulfilled") rememberObservedBookings(siteKey, bookingsResult.value.snapshot);
+      const attention: DrawerState["attention"] = [];
+      if (ordersResult.status === "fulfilled") {
+        const count = ordersResult.value.count;
+        if (count > 0) attention.push(attentionRow("att_orders", "Orders", "cart", "himi_owner_lite_orders", count));
+      }
+      if (bookingsResult.status === "fulfilled") {
+        const count = bookingsResult.value.count;
+        if (count > 0) attention.push(attentionRow("att_appts", "Appointments", "calendar", "himi_owner_lite_appointments", count));
+      }
+      // Other synchronous drawer actions (such as opening the clear-confirmation
+      // prompt) may run while the requests are in flight. Keep those latest fields
+      // when committing the refreshed data instead of restoring this action's snapshot.
+      const latest = drawer.getState();
       return snap(withDerived({
-        ...s,
+        ...latest,
         siteName: currentSiteName(),
+        attention,
         activeScreenId: typeof screenId === "string" ? screenId : hostActiveScreen(),
       }));
     },
@@ -80,7 +388,11 @@ const drawer = defineService<DrawerState, {
     })),
     askClearAttention: (s) => snap(withDerived({ ...s, confirmingClear: true })),
     cancelClearAttention: (s) => snap(withDerived({ ...s, confirmingClear: false })),
-    clearAttention: (s) => snap(withDerived({ ...s, attention: [], confirmingClear: false })),
+    clearAttention: (s) => {
+      refreshRevision += 1;
+      rememberDismissal(dismissalKey());
+      return snap(withDerived({ ...s, attention: [], confirmingClear: false }));
+    },
   },
 });