@wix/himalaya-cli 0.1252.0 → 0.1254.0

package/templates/owner-lite/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/owner-lite/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/owner-lite/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. */

package/templates/owner-lite/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/podcast-creator-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
                         }
                       }
                     },