@wix/himalaya-cli 0.1253.0 → 0.1254.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wix/himalaya-cli",
-  "version": "0.1253.0",
+  "version": "0.1254.0",
   "type": "module",
   "description": "himi — the Himalaya authoring CLI. Build a Tier-5 content package on your own machine, push it to the production serve as a draft, preview it on web + Himi Player, and read worker logs back — the remote dev loop. Wraps @himalaya/serve-cli for transport.",
   "keywords": [
@@ -67,5 +67,5 @@
       "artifactId": "himalaya-cli"
     }
   },
-  "falconPackageHash": "5e72ddf09c85bb0d681bac09978c72bb32dd0de7357ad33e4135d94c"
+  "falconPackageHash": "9813d2a1e8d42807e3ab7149876a5ba5a51589fc23547f6f8b66174d"
 }

package/templates/beauty-salon-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/beauty-salon-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/beauty-salon-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/beauty-salon-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 }));
+    },
   },
 });
 

package/templates/beauty-salon-owner/tier5-src/himi-owner-lite-home/index.ts

@@ -10,6 +10,7 @@ import { countSites } from "@himalaya/wix-site-list";
 import { searchOrders, type WixOrder } from "@himalaya/wix-ecom";
 import { queryBookings } from "@himalaya/wix-bookings";
 import { UPCOMING_BOOKING_STATUSES, upcomingBookingCount } from "../_shared/owner-bookings.js";
+import { ownerOrderAttentionFilter } from "../_shared/owner-order-attention.js";
 import { queryMembers } from "@himalaya/wix-members";
 import { queryReviews } from "@himalaya/wix-reviews";
 import { queryReservations } from "@himalaya/wix-table-reservations";
@@ -102,8 +103,6 @@ const UPCOMING_RESERVATION_STATUSES = ["HELD", "RESERVED", "REQUESTED"];
 const UPCOMING_EVENT_STATUSES = ["UPCOMING", "SCHEDULED"];
 const ATTENTION_MEMBER_STATUSES = ["PENDING"];
 const ATTENTION_REVIEW_STATUSES = ["IN_MODERATION", "SUBMITTED"];
-const ATTENTION_PAYMENT_STATUSES = ["NOT_PAID", "PARTIALLY_PAID"];
-const ATTENTION_FULFILLMENT_STATUSES = ["NOT_FULFILLED", "PARTIALLY_FULFILLED"];
 const SOURCE_LABELS: Record<HomeSourceId, string> = {
   products: "Products", posts: "Posts", events: "Events", sites: "Sites",
   orders: "Orders", bookings: "Bookings", members: "Members",
@@ -469,14 +468,7 @@ async function loadSourcePart(source: HomeSourceId, part: SourcePart): Promise<S
     case "sites": return countSites({}) as Promise<SourcePayload>;
     case "orders": {
       if (part === "primary") return searchOrders({ search: {
-          filter: {
-            archived: false,
-            status: { $nin: ["CANCELED", "CANCELLED"] },
-            $or: [
-              { paymentStatus: { $in: ATTENTION_PAYMENT_STATUSES } },
-              { paymentStatus: "PAID", fulfillmentStatus: { $in: ATTENTION_FULFILLMENT_STATUSES } },
-            ],
-          },
+          filter: ownerOrderAttentionFilter(),
           sort: [{ fieldName: "createdDate", order: "DESC" }, { fieldName: "id", order: "ASC" }],
           cursorPaging: { limit: TODAY_PAGE },
         } }) as Promise<SourcePayload>;

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

@@ -213,7 +213,10 @@ function copyFromParams(): SearchCopy {
     allFailed: copyParam("ownerSearch.allFailed", DEFAULT_COPY.allFailed),
     loadedOnly: copyParam("ownerSearch.loadedOnly", DEFAULT_COPY.loadedOnly),
     loadingSummary: copyParam("ownerSearch.loading", DEFAULT_COPY.loadingSummary),
-    emptySummary: copyParam("ownerSearch.empty", DEFAULT_COPY.emptySummary),
+    // Keep the pre-worker-heading copy key alive for existing copy packs. The
+    // newer `empty` key takes precedence when present; both flow through the
+    // query interpolator so neither can hide what the owner searched.
+    emptySummary: copyParam("ownerSearch.empty", copyParam("ownerSearch.emptyTitle", DEFAULT_COPY.emptySummary)),
     idleSummary: copyParam("ownerSearch.idle", DEFAULT_COPY.idleSummary),
     permission: copyParam("ownerSearch.permission", DEFAULT_COPY.permission),
     setup: copyParam("ownerSearch.setup", DEFAULT_COPY.setup),
@@ -240,6 +243,7 @@ const IDLE: State = {
   anyLoading: false,
   showEmpty: false,
   hideEmpty: true,
+  emptyTitle: "",
 };
 
 /** Rebuilt on `load`, because the allowlist arrives with the descriptor. */