@wix/himalaya-cli 0.1311.0 → 0.1313.0

package/templates/retail-store-owner/tier5-src/_shared/collection-contract.ts

@@ -58,6 +58,13 @@ export interface CollectionConfig {
 /** At or below this many records, with no query/filter narrowing them and no further
  * page, the list/grid toggle, Refine, chips, search and count are noise. */
 export const COLLECTION_CHROME_MIN_ITEMS = 4;
+/** The accessible name of a row's overflow menu: `template` with `{title}` filled, or the
+ *  generic `fallback` for a record with no title. */
+export function collectionActionsLabel(title: string, template: string, fallback: string): string {
+  const t = title.trim();
+  return t ? template.replace('{title}', () => t) : fallback;
+}
+
 export const COLLECTIONS: Record<string, CollectionConfig> = {
   himiStoreShop: { rows: 'results', title: 'name', subtitle: 'subtitle', image: 'image', view: 'grid', backendQuery: true, countNoun: ['product', 'products'], favoriteToggle: true },
   himiBookingServices: { rows: 'results', title: 'name', subtitle: 'subtitle', image: 'image', filter: 'category', view: 'grid', backendQuery: true, searchPlaceholder: 'Search services', countNoun: ['service', 'services'], primaryVerb: { label: 'Book', screenId: 'himi_time' } },
@@ -184,6 +191,9 @@ export function projectCollection(source: CollectionRow[], config: CollectionCon
       collectionSelectLabel: prefs.selectedIds.includes(collectionId(row)) ? 'Selected' : 'Select',
       // The save toggle names the action it WILL take (the service localizes it).
       collectionSaveLabel: prefs.savedIds.includes(collectionId(row)) ? 'Remove from saved' : 'Save',
+      // The row's overflow menu, named for its record: out of context (a rotor, a voice
+      // command) a list of identical "Item actions" cannot be told apart.
+      collectionActionsLabel: collectionActionsLabel(collectionTitle(row, config), 'Actions for {title}', 'Item actions'),
       collectionSubtitle: scalar(row[config.subtitle ?? '']) || scalar(row.subtitle) || scalar(row.description) || scalar(row.meta),
       collectionImage: scalar(row[config.image ?? '']), collectionNoImage: !scalar(row[config.image ?? '']), collectionHasImage: !!scalar(row[config.image ?? '']),
       collectionSaved: prefs.savedIds.includes(collectionId(row)), collectionNotSaved: !prefs.savedIds.includes(collectionId(row)), collectionSelected: prefs.selectedIds.includes(collectionId(row)),

package/templates/retail-store-owner/tier5-src/_shared/collection-service.ts

@@ -1,5 +1,5 @@
 import { defineService as register, type ServiceDefinition } from '@himalaya/state';
-import { COLLECTIONS, COLLECTION_CHROME_MIN_ITEMS, initialCollection, normalizeCollection, projectCollection, collectionId, type CollectionRow } from './collection-contract.js';
+import { COLLECTIONS, COLLECTION_CHROME_MIN_ITEMS, initialCollection, normalizeCollection, projectCollection, collectionId, collectionActionsLabel, type CollectionRow } from './collection-contract.js';
 import { localPreferences, type PreferenceRuntime } from './local-preferences.js';
 import { copyParam, stashCopy } from './himi-copy.js';
 import { createCollectionQuery, type CollectionQuerySource, type CollectionQueryState } from './collection-query.js';
@@ -130,6 +130,8 @@ export function decorateCollection(name: string, def: { state: State; actions?:
       // the save toggle names the action it WILL take for this row. The
       // old static "Save / unsave" made the owner work out the row's state.
       row.collectionSaveLabel = row.collectionSaved ? copyParam('collection.unsave', 'Remove from saved') : copyParam('collection.save', 'Save');
+      row.collectionActionsLabel = collectionActionsLabel(String(row.collectionTitle ?? ''),
+        copyParam('collection.itemActionsFor', 'Actions for {title}'), copyParam('collection.itemActions', 'Item actions'));
     });
     if (previewId && !rows.some(row => collectionId(row) === previewId)) previewId = '';
     const filterChoices = [{ id: 'all', label: copyParam('collection.all', 'All') }, { id: 'saved', label: copyParam('collection.saved', 'Saved') },

package/templates/retail-store-owner/tier5-src/_shared/detail-facts.ts

@@ -0,0 +1,26 @@
+// Blank flags for a detail screen's fact rows.
+//
+// A detail screen lists fixed facts (Price, Status, SKU, Inventory…). A fact with no value
+// painted its label beside nothing — "SKU" with a blank, "Registration" with a blank — which
+// reads as a broken screen, or as a value that failed to load. `hiddenWhen` hides on a TRUE
+// scalar only, so the worker publishes `<key>Blank` beside each fact and the descriptor hides
+// the row (and its divider) on it. "—" counts as blank: it is the platform's canonical "no value"
+// marker, which a `collapseWhenEmpty` Text collapses on web, iOS and Android alike — so a "—"
+// value already painted nothing beside its label.
+
+//
+// Beside `<key>Blank`: `<key>NoDivider` (hide the rule above this row — it is blank, or nothing
+// above it shows, so the card cannot open with a stray rule) and `factsBlank` (hide the card).
+export function blankFlags(state: Record<string, unknown>, keys: readonly string[]): Record<string, boolean> {
+  const out: Record<string, boolean> = {};
+  let shownAbove = false;
+  for (const key of keys) {
+    const value = state[key];
+    const blank = typeof value === "number" ? !Number.isFinite(value) : typeof value !== "string" || value.trim() === "" || value.trim() === "—";
+    out[`${key}Blank`] = blank;
+    out[`${key}NoDivider`] = blank || !shownAbove;
+    if (!blank) shownAbove = true;
+  }
+  out.factsBlank = !shownAbove;
+  return out;
+}

package/templates/retail-store-owner/tier5-src/_shared/offset-page.ts

@@ -0,0 +1,10 @@
+/** Offset APIs keep the offset opaque to collection UI. Advance by raw rows,
+ * never by a member/status-filtered projection. A full page without a total is
+ * deliberately incomplete until a subsequent (possibly empty) page confirms it. */
+export function offsetPage(cursor: string, count: number, limit: number, metadata?: { total?: number }) {
+  const offset = cursor ? Number(cursor) : 0;
+  if (!Number.isSafeInteger(offset) || offset < 0) throw new Error("Invalid page offset");
+  const total = typeof metadata?.total === "number" && Number.isFinite(metadata.total) && metadata.total >= 0 ? metadata.total : undefined;
+  const next = offset + count;
+  return { nextCursor: count > 0 && (total === undefined ? count >= limit : next < total) ? String(next) : "", ...(total === undefined ? {} : { total }) };
+}

package/templates/retail-store-owner/tier5-src/himi-owner-lite-ask/blocks.ts

@@ -528,11 +528,15 @@ function listBlock(block: AskBlock, key: string, binding: Binding): Node | null
         },
         pressFeedback: "scale",
         haptic: "light",
-        accessibilityLabel: `${key} ${proposeVerb} row ${i + 1}`,
+        // Its own visible verb. It sits inside a row named for its record, and a block key plus an
+        // index ("b1 delete row 1") is not a name anyone can act on.
+        accessibilityLabel: VERB_LABEL[proposeVerb] ?? proposeVerb,
         padding: { leading: 8, trailing: 8, top: 6, bottom: 6 },
       }));
     }
-    const modifiers: Record<string, unknown> = { fillMaxWidth: true, accessibilityLabel: `${key} row ${i + 1}` };
+    // No label override: the row reads its own title, subtitle, badge and value. It was named
+    // "b1 row 1" — the block key and an index, an internal id spoken in place of all of them.
+    const modifiers: Record<string, unknown> = { fillMaxWidth: true };
     if (tappable) {
       modifiers.onTap = {
         actionId: OPEN_ACTION,
@@ -617,7 +621,7 @@ function timelineBlock(block: AskBlock, key: string, binding: Binding): Node | n
     // title barely a third of a phone's width.
     const badge = rowBadge(result, query, i, idFor(`${key}_r${i}_b`), [titleField, block.subtitleField, timeField]);
     if (badge) detail.push(badge);
-    const modifiers: Record<string, unknown> = { fillMaxWidth: true, accessibilityLabel: `${key} entry ${i + 1}` };
+    const modifiers: Record<string, unknown> = { fillMaxWidth: true };
     if (tappable) {
       modifiers.onTap = { actionId: OPEN_ACTION, params: { id: result.rows[i]?.id ?? "", entity: String(entity) } };
       modifiers.pressFeedback = "scale";

package/templates/retail-store-owner/tier5-src/himi-owner-lite-ask/index.ts

@@ -506,7 +506,7 @@ const ask = defineService<AskState, {
           noAfterAnswer: state.noAnswer && recents.length === 0,
           // A saved link whose question has aged out of the recents list can't
           // be replayed — say so rather than opening a blank screen.
-          ...(id ? { headline: "That saved answer is gone", note: "Ask the question again to bring it back." } : {}),
+          ...(id ? { headline: "That saved answer is gone", note: "Ask the question again to bring it back.", customerNotice: "Ask the question again to bring it back." } : {}),
         };
       }
       return askTurn({ ...state, intent }, intent, false);
@@ -614,7 +614,7 @@ const ask = defineService<AskState, {
       const screenId = DETAIL_SCREEN[entity];
       // No detail screen for this entity is a dead end, not a crash: say so
       // rather than navigating somewhere arbitrary.
-      if (!screenId) return { ...state, note: `${singular(entity)}s have no detail screen yet.` };
+      if (!screenId) { const notice = `${singular(entity)}s have no detail screen yet.`; return { ...state, note: notice, customerNotice: notice }; }
       return navigate(state, { screenId, args: { id } });
     },
   },

package/templates/retail-store-owner/tier5-src/himi-owner-lite-manage/logic.ts

@@ -50,6 +50,8 @@ export interface ManageArea {
   unavailable?: boolean;
   hideCreate?: boolean;
   hideHandoff?: boolean;
+  /** The accessible name of this area's "Open in Wix", which carries the area ("Open in Wix: Store"). */
+  handoffLabel?: string;
 }
 
 export interface ManageSection {
@@ -95,6 +97,7 @@ export function parseAreas(value: unknown): ManageArea[] {
       ...(createScreenId && createLabel ? { createScreenId, createLabel } : {}),
       hideCreate: !(createScreenId && createLabel),
       hideHandoff: !DASHBOARD_PATHS[area.id],
+      handoffLabel: clean(raw.handoffLabel) || `Open in Wix: ${area.title}`,
       metricText: "—",
       statusText: "",
       unavailable: false,

package/templates/retail-store-owner/tier5-src/himi-owner-lite-post/index.ts

@@ -15,6 +15,7 @@ import { DEMO_POSTS, DEMO_NOTE, DEMO_SAVE_NOTE } from "../_shared/owner-preview-
 import { stashCopy, copyParam } from "../_shared/himi-copy.js";
 import { get as dbGet, upsert as dbUpsert, remove as dbRemove, enqueue as dbEnqueue, type DbEntity } from "../_shared/owner-local-db.js";
 import { formatDateMedium } from "../_shared/engine-intl.js";
+import { blankFlags } from "../_shared/detail-facts.js";
 
 // Offline-first (data-offline): owner CRUD is WRITE-BEHIND against the encrypted
 // `owner_posts` entity — publish/unpublish/delete update the local store
@@ -121,7 +122,16 @@ function statusLabel(raw?: string): string {
 
 function coverUrl(raw: any): string { return postCoverUrl(raw); }
 
+/** The fact rows this detail shows (the descriptor"s DETAIL_T5 rows): each publishes
+ *  `<key>Blank`, so a fact with no value hides instead of painting a dangling label. */
+const FACT_KEYS = ["postStatus", "category", "published", "updated"] as const;
+
 function shape(s: Partial<PostState>): PostState {
+  const out = shapeFields(s);
+  return { ...out, ...blankFlags(out as unknown as Record<string, unknown>, FACT_KEYS) };
+}
+
+function shapeFields(s: Partial<PostState>): PostState {
   const status = s.status ?? "ready";
   const raw = s.postStatusRaw ?? "";
   const image = s.image ?? "";

package/templates/retail-store-owner/tier5-src/himi-owner-lite-posts/index.ts

@@ -20,7 +20,19 @@ import { wixMediaUrl } from "@himalaya/wix-media";
 // without the `local_database` grant behaves exactly as today (online-only).
 const ENTITY = "owner_posts";
 async function readCachedRows(): Promise<PostRow[]> {
-  try { return (await getAll(ENTITY)) as unknown as PostRow[]; } catch { return []; }
+  try { return ((await getAll(ENTITY)) as unknown as PostRow[]).map(withStatus); } catch { return []; }
+}
+
+/** A row cached by an older bundle has no `statusLabel`. Its `dateLabel` led with the draft status
+ *  ("Draft · Oct 1", "Scheduled · …") and a published row carried only a date, so derive it. */
+function withStatus(row: PostRow): PostRow {
+  const dateLabel = String(row?.dateLabel ?? "");
+  const lead = dateLabel.split(" · ")[0];
+  const statusLabel = typeof row?.statusLabel === "string" && row.statusLabel
+    ? row.statusLabel
+    : /^(Draft|Scheduled)$/i.test(lead) ? lead : copyParam("ownerPosts.published", "Published");
+  // The offline/seed row paints `dateLabel`, so it must lead with the status too.
+  return { ...row, statusLabel, dateLabel: lead === statusLabel ? dateLabel : [statusLabel, dateLabel].filter(Boolean).join(" · ") };
 }
 async function writeCachedRows(rows: PostRow[]): Promise<void> {
   try { for (const r of rows) await upsert(ENTITY, r as unknown as DbEntity); } catch { /* capability not granted → online-only */ }
@@ -31,6 +43,9 @@ interface PostRow {
   title: string;
   excerpt: string;
   dateLabel: string;
+  /** Draft / Scheduled / Published. The collection row's meta line shows it, so a draft never
+   *  looks like a live post. */
+  statusLabel: string;
   image: string;    // cover image (web URL, "" = none → initial badge)
   initial: string;
   hasImage: boolean;
@@ -81,7 +96,9 @@ function normalize(raw: { id?: string; title?: string; excerpt?: string; firstPu
     id: raw.id || "",
     title,
     excerpt: (raw.excerpt || "").trim(),
-    dateLabel: fmtDate(raw.firstPublishedDate || raw.lastPublishedDate || raw.editedDate || raw.createdDate),
+    // Status first, like a draft's — the offline/seed row shows this line, not the collection meta.
+    dateLabel: [copyParam("ownerPosts.published", "Published"), fmtDate(raw.firstPublishedDate || raw.lastPublishedDate || raw.editedDate || raw.createdDate)].filter(Boolean).join(" · "),
+    statusLabel: copyParam("ownerPosts.published", "Published"),
     image,
     initial: (title.trim()[0] || "?").toUpperCase(),
     hasImage: !!image,
@@ -111,6 +128,7 @@ function normalizeDraft(raw: { id?: string; title?: string; excerpt?: string; st
     title,
     excerpt: (raw.excerpt || "").trim(),
     dateLabel: [draftStatusLabel(raw.status), when].filter(Boolean).join(" · "),
+    statusLabel: draftStatusLabel(raw.status),
     image,
     initial: (title.trim()[0] || "?").toUpperCase(),
     hasImage: !!image,
@@ -163,6 +181,7 @@ function demoList(s: PostsState): PostsState {
     title: d.title,
     excerpt: d.excerpt,
     dateLabel: d.dateLabel,
+    statusLabel: d.postStatus,
     image: "",
     initial: (d.title[0] || "?").toUpperCase(),
     hasImage: false,

package/templates/retail-store-owner/tier5-src/himi-owner-lite-product/index.ts

@@ -11,6 +11,7 @@ import { ownerLoadError, isBridgeUnavailable, isOwnerPreviewDemo, shouldQueueOwn
 import { DEMO_PRODUCTS, DEMO_NOTE, DEMO_SAVE_NOTE } from "../_shared/owner-preview-demo.js";
 import { stashCopy, copyParam } from "../_shared/himi-copy.js";
 import { get as dbGet, upsert as dbUpsert, remove as dbRemove, enqueue as dbEnqueue, type DbEntity } from "../_shared/owner-local-db.js";
+import { blankFlags } from "../_shared/detail-facts.js";
 
 // Offline-first (data-offline): owner CRUD is WRITE-BEHIND against the encrypted
 // `owner_products` entity — the local store is updated OPTIMISTICALLY so the
@@ -109,7 +110,16 @@ function inventoryOf(p: WixProduct): string {
   return status ? status.charAt(0).toUpperCase() + status.slice(1) : "—";
 }
 
+/** The fact rows this detail shows (the descriptor"s DETAIL_T5 rows): each publishes
+ *  `<key>Blank`, so a fact with no value hides instead of painting a dangling label. */
+const FACT_KEYS = ["price", "statusLabel", "sku", "inventory"] as const;
+
 function shape(s: Partial<ProductState>): ProductState {
+  const out = shapeFields(s);
+  return { ...out, ...blankFlags(out as unknown as Record<string, unknown>, FACT_KEYS) };
+}
+
+function shapeFields(s: Partial<ProductState>): ProductState {
   const status = s.status ?? "ready";
   const image = s.image ?? "";
   const visible = s.visibleRaw ?? true;

package/templates/retail-store-owner/tier5-src/himi-owner-lite-search/index.ts

@@ -34,6 +34,7 @@ import {
   type SearchRow,
   type SearchState,
 } from "./logic.js";
+import { verticalAdapter } from "./vertical-sources.js";
 
 /** How many loaded pages one source will walk looking for matches.
  *
@@ -196,7 +197,12 @@ export function adaptersFrom(raw: unknown): SearchAdapter[] {
   const ids = Array.isArray(raw) ? raw : [];
   const seen = new Set<OwnerModuleId>();
   const out: SearchAdapter[] = [];
+  const seenVertical = new Set<string>();
   for (const value of ids) {
+    // A vertical (orders, products, services, events, posts) is its own source with its own
+    // API — not a management module — so it is admitted by its own allowlist.
+    const vertical = typeof value === "string" && !seenVertical.has(value) ? verticalAdapter(value, normalizeQuery, classifyOwnerError) : null;
+    if (vertical) { seenVertical.add(value as string); out.push(vertical); continue; }
     const id = ownerModuleId(value);
     if (!id || seen.has(id)) continue;
     seen.add(id);

package/templates/retail-store-owner/tier5-src/himi-owner-lite-search/vertical-sources.ts

@@ -0,0 +1,178 @@
+// Record search over the __HIMI_APP_NAME__ VERTICALS — orders, products, booking services, events and
+// blog posts. These are the dedicated screens (`himi_owner_lite_orders` …), not management
+// modules, so `queryOwnerModule` cannot read them: each has its own Wix API and its own detail
+// screen. The search screen promised "Search orders, contacts, members…" and never asked for an
+// order; these adapters are what makes that promise true.
+//
+// Same honesty rules as the module sources: matching is over the pages actually read (title and
+// subtitle, exactly what the row shows), the walk is bounded, and no total is claimed. The source
+// id IS the list screen's id, and every row routes to that vertical's own detail screen — the
+// static destination its list rows already use, never a worker-built route.
+
+import { searchOrders, type WixOrder } from "@himalaya/wix-ecom";
+import { queryEvents } from "@himalaya/wix-events";
+import { queryServices, type WixService } from "@himalaya/wix-bookings";
+import { queryPosts, queryDraftPosts } from "@himalaya/wix-blog";
+import { searchStoreProducts, productPrice, type StoreProduct } from "../_shared/himi-store.js";
+import { normalizeEvent } from "../_shared/himi-events.js";
+import { offsetPage } from "../_shared/offset-page.js";
+import { isOwnerPreviewDemo } from "../_shared/owner-load-error.js";
+import { DEMO_ORDERS, DEMO_PRODUCTS, DEMO_EVENTS, DEMO_POSTS, DEMO_SERVICES } from "../_shared/owner-preview-demo.js";
+import { copyParam } from "../_shared/himi-copy.js";
+import type { GroupProblem, SearchAdapter, SearchPage, SearchRow } from "./logic.js";
+
+/** A vertical record before it becomes a row: what the row shows, and nothing else to match on. */
+interface Found { id: string; title: string; subtitle: string; statusLabel?: string }
+
+interface VerticalSource {
+  label: [key: string, fallback: string];
+  icon: string;
+  /** The vertical's detail screen — the one its own list rows open. */
+  detailScreenId: string;
+  /** One page of records. `cursor` is the source's own (an ecom cursor or an offset). */
+  page(query: string, cursor: string): Promise<{ items: Found[]; nextCursor: string }>;
+  demo(): Found[];
+}
+
+const PAGE = 50;
+const MAX_PAGES = 3;
+const join = (...parts: Array<string | undefined>) => parts.map((p) => (p ?? "").trim()).filter(Boolean).join(" · ");
+
+const PAY_LABEL: Record<string, string> = {
+  PAID: "Paid", NOT_PAID: "Unpaid", PARTIALLY_PAID: "Partially paid", PENDING: "Pending",
+  FULLY_REFUNDED: "Refunded", PARTIALLY_REFUNDED: "Partly refunded",
+};
+
+function orderBuyer(raw: WixOrder): string {
+  const r = raw as unknown as { billingInfo?: { contactDetails?: { firstName?: string; lastName?: string } }; recipientInfo?: { contactDetails?: { firstName?: string; lastName?: string } } };
+  const c = r.billingInfo?.contactDetails ?? r.recipientInfo?.contactDetails;
+  return [c?.firstName, c?.lastName].filter(Boolean).join(" ").trim() || (raw.buyerInfo?.email ?? "").trim();
+}
+
+function orderFound(raw: WixOrder): Found {
+  const number = raw.number ? `#${raw.number}` : "";
+  const pay = PAY_LABEL[(raw.paymentStatus ?? "").toUpperCase()] ?? "";
+  // The number rides the SUBTITLE so "10041" finds the order the owner sees as "#10041".
+  return { id: raw.id ?? "", title: orderBuyer(raw) || number || "Order", subtitle: join(number, raw.priceSummary?.total?.formattedAmount, pay), statusLabel: pay };
+}
+
+function serviceFound(raw: WixService): Found {
+  const category = (raw as { category?: { name?: string } }).category?.name;
+  return { id: raw.id ?? "", title: (raw.name ?? "").trim() || "Service", subtitle: join(category) };
+}
+
+export const VERTICAL_SOURCES: Record<string, VerticalSource> = {
+  himi_owner_lite_orders: {
+    label: ["ownerSearch.source.orders", "Orders"],
+    icon: "cart",
+    detailScreenId: "himi_owner_lite_order",
+    async page(_query, cursor) {
+      const response = await searchOrders({ search: {
+        // The Orders list's own filter: an archived order is not one the owner can see there.
+        filter: { archived: false },
+        sort: [{ fieldName: "createdDate", order: "DESC" }],
+        cursorPaging: { limit: PAGE, ...(cursor ? { cursor } : {}) },
+      } });
+      const metadata = response.metadata as { cursors?: { next?: string | null } } | undefined;
+      return { items: (response.orders ?? []).filter((o) => !!o?.id).map(orderFound), nextCursor: metadata?.cursors?.next ?? "" };
+    },
+    demo: () => DEMO_ORDERS.map((d) => ({ id: d.id, title: d.buyer, subtitle: join(`#${d.number}`, d.total, d.paymentLabel), statusLabel: d.paymentLabel })),
+  },
+  himi_owner_lite_products: {
+    label: ["ownerSearch.source.products", "Store"],
+    icon: "bag",
+    detailScreenId: "himi_owner_lite_product",
+    async page(_query, cursor) {
+      // Read the catalog pages, like every other source here, and match locally on what the row
+      // shows. (V3 name search is a different endpoint with its own semantics; mixing a server
+      // match into a "loaded records" group would make its count mean two things.)
+      const response = await searchStoreProducts({ limit: PAGE, ...(cursor ? { cursor } : {}) });
+      const items = (response.products ?? []).filter((p: StoreProduct) => !!p?.id)
+        .map((p: StoreProduct) => ({ id: p.id ?? "", title: (p.name ?? "").trim() || "Untitled product", subtitle: productPrice(p) }));
+      return { items, nextCursor: response.pagingMetadata?.cursors?.next ?? "" };
+    },
+    demo: () => DEMO_PRODUCTS.map((d) => ({ id: d.id, title: d.name, subtitle: d.price })),
+  },
+  himi_owner_lite_services: {
+    label: ["ownerSearch.source.services", "Bookings"],
+    icon: "calendar",
+    detailScreenId: "himi_owner_lite_service",
+    async page(_query, cursor) {
+      const res = await queryServices({ query: { paging: { limit: PAGE, offset: Number(cursor || 0) }, sort: [{ fieldName: "name", order: "ASC" }] } });
+      const raw = res.services ?? [];
+      return { items: raw.filter((s) => !!s?.id).map(serviceFound), ...offsetPage(cursor, raw.length, PAGE, res.pagingMetadata) };
+    },
+    demo: () => DEMO_SERVICES.map((d) => ({ id: d.id, title: d.name, subtitle: join(d.category) })),
+  },
+  himi_owner_lite_events: {
+    label: ["ownerSearch.source.events", "Events"],
+    icon: "calendar",
+    detailScreenId: "himi_owner_lite_event",
+    async page(_query, cursor) {
+      const res = await queryEvents({ limit: PAGE, offset: Number(cursor || 0), query: { sort: [{ fieldName: "dateAndTimeSettings.startDate", order: "ASC" }, { fieldName: "id", order: "ASC" }] } });
+      const raw = res.events ?? [];
+      const items = raw.filter((e) => !!e?.id).map((e) => { const row = normalizeEvent(e); return { id: row.id, title: row.title, subtitle: join(row.dateLine, row.location) }; });
+      return { items, ...offsetPage(cursor, raw.length, PAGE, (res as { pagingMetadata?: { total?: number } }).pagingMetadata) };
+    },
+    demo: () => DEMO_EVENTS.map((d) => ({ id: d.id, title: d.title, subtitle: join(d.dateLine, d.location) })),
+  },
+  himi_owner_lite_posts: {
+    label: ["ownerSearch.source.posts", "Blog"],
+    icon: "newspaper",
+    detailScreenId: "himi_owner_lite_post",
+    async page(_query, cursor) {
+      // One walk over published posts; drafts ride the first page, best-effort, exactly as
+      // the Blog list reads them (a forbidden drafts resource must not fail the group).
+      const offset = Number(cursor || 0);
+      const [pub, draftPage] = await Promise.all([
+        queryPosts({ query: { paging: { limit: PAGE, offset } } }),
+        cursor ? Promise.resolve(null) : queryDraftPosts({ query: { paging: { limit: PAGE, offset: 0 } } }).catch(() => null),
+      ]);
+      const posts = (pub.posts ?? []).filter((p: { id?: string }) => !!p?.id) as Array<{ id: string; title?: string; excerpt?: string }>;
+      const seen = new Set(posts.map((p) => p.id));
+      // Drafts unavailable (missing or forbidden resource) → published only.
+      const drafts = (((draftPage as { draftPosts?: unknown[] } | null)?.draftPosts ?? []) as Array<{ id?: string; status?: string; title?: string; excerpt?: string }>)
+        .filter((p) => p?.id && p.status !== "PUBLISHED" && !seen.has(p.id!)) as Array<{ id: string; title?: string; excerpt?: string }>;
+      const draft = copyParam("ownerSearch.draft", "Draft");
+      const items = [
+        ...drafts.map((p) => ({ id: p.id, title: (p.title ?? "").trim() || "Untitled post", subtitle: join(draft, p.excerpt) })),
+        ...posts.map((p) => ({ id: p.id, title: (p.title ?? "").trim() || "Untitled post", subtitle: join(p.excerpt) })),
+      ];
+      return { items, ...offsetPage(cursor, posts.length, PAGE, (pub as { pagingMetadata?: { total?: number } }).pagingMetadata) };
+    },
+    demo: () => DEMO_POSTS.map((d) => ({ id: d.id, title: d.title, subtitle: join(/draft/i.test(d.postStatus) ? d.postStatus : "", d.excerpt) })),
+  },
+};
+
+const matches = (found: Found, needle: string): boolean =>
+  !!needle && `${found.title} ${found.subtitle}`.toLocaleLowerCase().includes(needle.toLocaleLowerCase());
+
+export function verticalAdapter(id: string, normalizeQuery: (q: unknown) => string, classify: (e: unknown) => GroupProblem): SearchAdapter | null {
+  const source = Object.prototype.hasOwnProperty.call(VERTICAL_SOURCES, id) ? VERTICAL_SOURCES[id] : undefined;
+  if (!source) return null;
+  return {
+    id,
+    label: copyParam(source.label[0], source.label[1]),
+    icon: source.icon,
+    semantics: "loaded",
+    screenId: source.detailScreenId,
+    classify,
+    async search(query, cursor): Promise<SearchPage> {
+      const needle = normalizeQuery(query);
+      const toRow = (found: Found): SearchRow => ({
+        key: `${id}:${found.id}`, id: found.id, sourceId: id, title: found.title, subtitle: found.subtitle,
+        statusLabel: found.statusLabel ?? "", image: "", screenId: source.detailScreenId,
+      });
+      if (isOwnerPreviewDemo()) return { rows: source.demo().filter((f) => matches(f, needle)).map(toRow), nextCursor: "" };
+      const rows: SearchRow[] = [];
+      let next = cursor;
+      for (let page = 0; page < MAX_PAGES; page++) {
+        const result = await source.page(needle, next);
+        for (const found of result.items) if (found.id && matches(found, needle)) rows.push(toRow(found));
+        next = result.nextCursor;
+        if (!next) break;
+      }
+      return { rows, nextCursor: next };
+    },
+  };
+}