@wix/himalaya-cli 0.1613.0 → 0.1615.0

package/templates/salon-spa/tier5-src/_shared/branded-lite-hosted.ts

@@ -0,0 +1,278 @@
+// Hosted mode: ONE served Branded Lite that opens any site at runtime, inside a host app such as
+// Spaces Lite, instead of one build per customer.
+//
+// A single-site build decides its verticals at build time from `provisioning.json`. A hosted build
+// declares every vertical and decides at RUNTIME from the site the host opened it for: each
+// vertical's nav row carries a fail-closed `hiddenPath` (`hiddenUntilResolved`: hidden until it resolves), and
+// the app-level nav worker resolves it from the site the host hands over.
+//
+// WHERE THE SITE COMES FROM: the host. A hosted app's Wix capability is pinned to its site and only
+// reaches www.wixapis.com, so it cannot read its own provisioning (the Member View
+// lives on apps.wix.com, the display options on manage.wix.com). The host resolves it with its own
+// account session (the site provisioning mapper) and core injects it into every worker's input under the
+// reserved key `HOST_SITE_INPUT_KEY`, after the nav params are merged — so a deep link's query can
+// never supply or replace it (WorkerPreferenceContext.inject, iOS + Android).
+//
+// PURE and import-free, so the nav and home workers (and the CLI templates that copy them) can
+// bundle it. The app's hosted-mode module re-exports it with the app's types.
+
+/** A Branded Lite vertical id (the app contract's `BrandedLiteVertical`). A plain
+ *  string here: this module is copied into CLI templates, which only allow `_shared` imports. */
+export type BrandedLiteVertical = string;
+
+export type BrandedLiteMode = "single-site" | "hosted";
+
+/** The worker-input key the host's site arrives under. Core owns it: it is set (or blanked) after
+ *  every other input source, so nothing but the host can put a site there. */
+export const HOST_SITE_INPUT_KEY = "__himiHostSite";
+
+/** The host's site from a worker's `himalaya.input`, or null. */
+export function hostSiteFromInput(input: unknown): HostedSite | null {
+  const raw = input && typeof input === "object" ? (input as Record<string, unknown>)[HOST_SITE_INPUT_KEY] : undefined;
+  return readHostedSite(raw);
+}
+
+/** What the host hands a hosted Branded Lite about the site it opened (`himalaya.input[HOST_SITE_INPUT_KEY]`). */
+export interface HostedSite {
+  metaSiteId: string;
+  name: string;
+  installedVerticals: BrandedLiteVertical[];
+  /** #RRGGBB, or "" when the site has none (the build's own brand stays). */
+  primaryColor: string;
+  logoUrl: string;
+}
+
+/** Verticals a hosted build always shows: every member area has a member list, whatever the
+ *  owner installed. (Home, its About section and Profile are not verticals — always there.) */
+export const HOSTED_ALWAYS: readonly BrandedLiteVertical[] = ["members"];
+
+/** The screen each vertical's nav rows open, so a route to an uninstalled vertical can be answered. */
+export const VERTICAL_ROOT_SCREENS: Readonly<Record<string, readonly string[]>> = {
+  store: ["himi_shop"], bookings: ["himi_services", "himi_agenda"], restaurants: ["himi_menu", "himi_reserve"],
+  programs: ["himi_programs"], plans: ["himi_plans"], feed: ["himi_feed"], members: ["himi_members"],
+  forum: ["himi_forum"], coupons: ["himi_coupons"], notifications: ["himi_notifications"],
+  loyalty: ["himi_loyalty"], reviews: ["himi_reviews"], portfolio: ["himi_portfolio"],
+  reservations: ["himi_reservations"], invoices: ["himi_invoices"], badges: ["himi_badges"],
+  notifsettings: ["himi_notif_settings"], events: ["himi_events"], blog: ["himi_blog"],
+  groups: ["himi_groups"], cms: ["himi_cms"], donations: ["himi_donations"], giftCards: ["himi_gift_cards"],
+  videos: ["himi_videos"], podcasts: ["himi_podcasts"], forms: ["himi_forms"], galleries: ["himi_galleries"],
+  inbox: ["himi_business_chat"], faq: ["himi_faq"],
+};
+
+/** Every screen a vertical owns, so a route to ANY of them (a child or action screen as much as the
+ *  root) lands on `NOT_AVAILABLE_SCREEN` when the site does not have it. A screen several verticals
+ *  share opens when any of them is shown. Pinned against the app's screen registry
+ *  (`brandedLiteScreenOwners`, checked by the app's hosted-mode tests), so a screen added
+ *  to a vertical without being listed here fails the build. */
+export const HOSTED_SCREEN_VERTICALS: Readonly<Record<string, readonly BrandedLiteVertical[]>> = {
+  himi_address: ["restaurants", "store"],
+  himi_addresses: ["restaurants", "store"],
+  himi_agenda: ["bookings"],
+  himi_badge: ["badges"],
+  himi_badges: ["badges"],
+  himi_blog: ["blog"],
+  himi_bookings: ["bookings"],
+  himi_cart: ["store"],
+  himi_business_chat: ["inbox"],
+  himi_chat_thread: ["inbox", "members"],
+  himi_cms: ["cms"],
+  himi_collection: ["store"],
+  himi_collections: ["store"],
+  himi_coupon: ["coupons"],
+  himi_coupons: ["coupons"],
+  himi_create_post: ["blog", "forum"],
+  himi_donation: ["donations"],
+  himi_donations: ["donations"],
+  himi_events: ["events"],
+  himi_faq: ["faq"],
+  himi_feed: ["feed"],
+  himi_food_order: ["restaurants"],
+  himi_food_orders: ["restaurants"],
+  himi_form: ["forms"],
+  himi_forms: ["forms"],
+  himi_forum: ["forum"],
+  himi_forum_post: ["forum"],
+  himi_galleries: ["galleries"],
+  himi_gallery: ["galleries"],
+  himi_gift_card: ["giftCards"],
+  himi_gift_cards: ["giftCards"],
+  himi_groups: ["groups"],
+  himi_group_about: ["groups"],
+  himi_my_groups: ["groups"],
+  himi_invoice: ["invoices"],
+  himi_invoices: ["invoices"],
+  himi_loyalty: ["loyalty"],
+  himi_loyalty_reward: ["loyalty"],
+  himi_member: ["members"],
+  himi_members: ["members"],
+  himi_menu: ["restaurants"],
+  himi_my_events: ["events"],
+  himi_my_subscriptions: ["plans"],
+  himi_new_message: ["inbox", "members"],
+  himi_notifications: ["notifications"],
+  himi_orders: ["store"],
+  himi_photo_album: ["galleries"],
+  himi_place_summary: ["bookings", "plans"],
+  himi_plan: ["plans"],
+  himi_plans: ["plans"],
+  himi_podcast: ["podcasts"],
+  himi_podcasts: ["podcasts"],
+  himi_portfolio: ["portfolio"],
+  himi_portfolio_project: ["portfolio"],
+  himi_programs: ["programs"],
+  himi_member_programs: ["programs"],
+  himi_reservations: ["reservations"],
+  himi_reserve: ["restaurants"],
+  himi_review: ["reviews"],
+  himi_reviews: ["reviews"],
+  himi_saved: ["blog"],
+  himi_saved_products: ["store"],
+  himi_services: ["bookings"],
+  himi_shop: ["store"],
+  himi_subscription: ["plans"],
+  himi_video: ["videos"],
+  himi_video_channel: ["videos"],
+  himi_videos: ["videos"],
+  himi_wallet: ["bookings", "plans", "restaurants", "store"],
+};
+
+/** The templated (`<prefix>[_/]<id>`) detail routes each vertical owns, pinned the same way. */
+export const HOSTED_ROUTE_PREFIXES: Readonly<Record<string, readonly BrandedLiteVertical[]>> = {
+  himi_order: ["store"],
+  himi_product: ["store"],
+  himi_service: ["bookings"],
+  himi_time: ["bookings"],
+  himi_menu_item: ["restaurants"],
+  himi_program: ["programs"],
+  himi_event: ["events"],
+  himi_rsvp: ["events"],
+  himi_blog_post: ["blog"],
+  himi_group: ["groups"],
+  himi_cms_collection: ["cms"],
+};
+
+/** The verticals that own [screenId], or undefined for a screen every site has (Home, Profile…). */
+export function screenVerticals(screenId: string): readonly BrandedLiteVertical[] | undefined {
+  const exact = HOSTED_SCREEN_VERTICALS[screenId];
+  if (exact) return exact;
+  // The registry's `^<prefix>(?:[_/](.+))?$`: the bare prefix, or the prefix, a separator and an id.
+  for (const [prefix, verticals] of Object.entries(HOSTED_ROUTE_PREFIXES)) {
+    if (screenId === prefix) return verticals;
+    const sep = screenId.charAt(prefix.length);
+    if (screenId.startsWith(prefix) && (sep === "_" || sep === "/") && screenId.length > prefix.length + 1) return verticals;
+  }
+  return undefined;
+}
+
+/** The drawer's collapsible folders and the verticals in each (config.ts builds them from this).
+ *  A folder header is hidden when none of its verticals shows, so a site never sees an empty one. */
+export const HOSTED_DRAWER_FOLDERS: Readonly<Record<string, readonly BrandedLiteVertical[]>> = {
+  drawer_sec_community: ["feed", "forum", "groups", "members", "reviews", "badges", "blog"],
+  drawer_sec_media: ["videos", "podcasts", "portfolio", "cms", "galleries", "faq"],
+  drawer_sec_offers: ["coupons", "giftCards", "donations", "loyalty"],
+  drawer_sec_activity: ["inbox", "reservations", "invoices", "forms", "notifications", "notifsettings"],
+};
+
+/** The vertical a nav row's screen belongs to, or undefined (Home, Profile, Steps…). */
+export function verticalOfScreen(screenId: string | undefined): BrandedLiteVertical | undefined {
+  if (!screenId) return undefined;
+  for (const [vertical, roots] of Object.entries(VERTICAL_ROOT_SCREENS) as [string, readonly string[]][]) {
+    if (roots.includes(screenId)) return vertical;
+  }
+  return undefined;
+}
+
+/** The screen a route to an uninstalled vertical lands on. */
+export const NOT_AVAILABLE_SCREEN = "himi_not_available";
+
+const HEX = /^#[0-9A-Fa-f]{6}$/;
+const VERTICALS = new Set(Object.keys(VERTICAL_ROOT_SCREENS));
+
+/** The host's site, or null when it is missing or malformed — a hosted build then shows no
+ *  vertical at all (fail closed), never every one. */
+export function readHostedSite(raw: unknown): HostedSite | null {
+  let value = raw;
+  if (typeof value === "string") {
+    try { value = JSON.parse(value); } catch { return null; }
+  }
+  if (!value || typeof value !== "object") return null;
+  const v = value as Record<string, unknown>;
+  const metaSiteId = typeof v.metaSiteId === "string" ? v.metaSiteId.trim() : "";
+  if (!metaSiteId || !Array.isArray(v.installedVerticals)) return null;
+  const installed = v.installedVerticals.filter((x): x is BrandedLiteVertical => typeof x === "string" && VERTICALS.has(x));
+  const color = typeof v.primaryColor === "string" && HEX.test(v.primaryColor) ? v.primaryColor : "";
+  return {
+    metaSiteId,
+    name: typeof v.name === "string" ? v.name : "",
+    installedVerticals: [...new Set(installed)],
+    primaryColor: color,
+    logoUrl: typeof v.logoUrl === "string" && /^https:\/\//.test(v.logoUrl) ? v.logoUrl : "",
+  };
+}
+
+/** The verticals a hosted build shows for [site]: its installed ones plus the always-on ones.
+ *  None at all without a site. */
+export function hostedVerticals(site: HostedSite | null): Set<BrandedLiteVertical> {
+  if (!site) return new Set();
+  return new Set<BrandedLiteVertical>([...site.installedVerticals, ...HOSTED_ALWAYS]);
+}
+
+/** `hiddenPath` flags (true hides the row), for the nav worker to publish: one per vertical, and
+ *  one per drawer folder (hidden when none of its verticals shows). */
+export function hostedHiddenFlags(site: HostedSite | null): Record<string, boolean> {
+  const shown = hostedVerticals(site);
+  const out: Record<string, boolean> = {};
+  for (const v of Object.keys(VERTICAL_ROOT_SCREENS) as BrandedLiteVertical[]) out[v] = !shown.has(v);
+  for (const [folder, verticals] of Object.entries(HOSTED_DRAWER_FOLDERS)) out[folder] = !verticals.some((v) => shown.has(v));
+  return out;
+}
+
+/** Where a route to [screenId] lands for [site]: itself, or the "not available on this site" screen
+ *  when every vertical that owns it is missing from the site. A screen no vertical owns (Home,
+ *  Profile, settings) is on every site and passes through. */
+export function hostedRoute(screenId: string, site: HostedSite | null): string {
+  const owners = screenVerticals(screenId);
+  if (!owners) return screenId;
+  const shown = hostedVerticals(site);
+  return owners.some((v) => shown.has(v)) ? screenId : NOT_AVAILABLE_SCREEN;
+}
+
+/** One hosted Home "Explore" card. The descriptor hands the worker the whole catalog (its copy is
+ *  build-time localized) as `himalaya.input.hostedExplore`; the worker publishes only the site's. */
+export interface HostedExploreCard {
+  vertical: BrandedLiteVertical;
+  icon: string;
+  title: string;
+  body: string;
+  /** Always the vertical's own root screen — never taken from the input. */
+  screenId: string;
+}
+
+/** The Explore cards to show for [site], in catalog order: one per catalog entry whose vertical the
+ *  site shows. Empty without a site or a catalog, so a worker that never boots shows no card at all
+ *  (the grid binds this list — fail closed, unlike a per-card `hiddenPath`, which native renderers
+ *  treat as visible until it resolves). */
+export function hostedExploreCards(catalog: unknown, site: HostedSite | null): HostedExploreCard[] {
+  if (!Array.isArray(catalog)) return [];
+  const shown = hostedVerticals(site);
+  const out: HostedExploreCard[] = [];
+  const seen = new Set<string>();
+  for (const entry of catalog) {
+    if (!entry || typeof entry !== "object") continue;
+    const e = entry as Record<string, unknown>;
+    const vertical = typeof e.vertical === "string" ? e.vertical : "";
+    const screenId = VERTICAL_ROOT_SCREENS[vertical]?.[0];
+    if (!screenId || !shown.has(vertical) || seen.has(vertical)) continue;
+    seen.add(vertical);
+    out.push({
+      vertical, screenId,
+      icon: typeof e.icon === "string" ? e.icon : "grid",
+      title: typeof e.title === "string" ? e.title : "",
+      body: typeof e.body === "string" ? e.body : "",
+    });
+  }
+  return out;
+}
+
+/** The `$service` path a hosted nav row's visibility binds to (a vertical, or a drawer folder id). */
+export const hostedHiddenPath = (key: string): string => `$service:brandedLiteNav.hosted.${key}`;

package/templates/salon-spa/tier5-src/_shared/branded-load-state.ts

@@ -0,0 +1,109 @@
+// Load-state honesty for the branded-lite vertical workers.
+//
+// These workers used to answer every failed or empty query with representative SAMPLE
+// rows — discount codes, gift-card balances, invoices, reservations, inbox messages —
+// under a "Sample content" banner. On a customer build that is invented data presented
+// as the customer's own: a code that does not exist, a balance in the wrong currency, an
+// "Overdue" invoice, a booking labelled "tap to cancel". The banner did not make it
+// honest; the rows were still the first thing a visitor read.
+//
+// The rule now:
+//   • query FAILED     → status "error" with a customer sentence, a Retry, and — when
+//                        Wix refused an anonymous visitor (401) — a Sign in path instead;
+//   • query was EMPTY  → status "ready", no rows, the vertical's own empty sentence;
+//   • sample rows      → ONLY when the host explicitly asked for sample data (the web
+//                        preview's sample data mode, `__himiOwnerPreview: "sample"`).
+//                        Never on a device, never as a fallback.
+//
+// Every field here is flat and boolean-gated because descriptors can only
+// `hiddenWhen(<path>)` on a TRUE value: `notErrored` hides the error card, `noSignIn`
+// hides the sign-in CTA, `signInRequired` hides Retry when retrying cannot help.
+import { copyParam } from "./himi-copy.js";
+
+export interface LoadFlags {
+  status: "loading" | "ready" | "error";
+  /** The customer-facing failure sentence; "" unless status is "error". */
+  error: string;
+  signInRequired: boolean;
+  notErrored: boolean;
+  /** hiddenWhen gate for a loading skeleton. */
+  notLoading: boolean;
+  /** Loading or failed — gates content that has nothing to say in either. */
+  busy: boolean;
+  noSignIn: boolean;
+  isMock: boolean;
+  notMock: boolean;
+  notMockEmpty: boolean;
+  notMockUnavailable: boolean;
+  /** hiddenWhen gate for the empty state: false ONLY when the site answered with no rows
+   *  (`notMockEmpty` is true then — it gates the sample banner, not the empty state). */
+  hideEmpty: boolean;
+}
+
+export const LOADING: LoadFlags = {
+  status: "loading", error: "", signInRequired: false, notErrored: true, notLoading: false, busy: true, noSignIn: true,
+  isMock: false, notMock: true, notMockEmpty: true, notMockUnavailable: true, hideEmpty: true,
+};
+
+const READY: LoadFlags = { ...LOADING, status: "ready", notLoading: true, busy: false };
+
+/** Did the HOST ask for sample data? Only the web preview's sample mode does; a native
+ *  build, a visitor preview and a live owner preview never carry it. */
+export function samplesRequested(): boolean {
+  const input = (globalThis as { himalaya?: { input?: Record<string, unknown> } }).himalaya?.input;
+  return input?.__himiOwnerPreview === "sample";
+}
+
+/** Wix refused an ANONYMOUS visitor: signing in is the fix, not retrying. A 403 is not
+ *  this — it also answers "feature not installed" and a signed-in member without the
+ *  permission, where a Sign in button leads nowhere — so it stays a Retry-able failure. */
+export function needsSignIn(err: unknown): boolean {
+  const msg = String((err as { message?: unknown })?.message ?? err ?? "");
+  return /\b401\b|unauthori[sz]ed|unauthenticated/i.test(msg);
+}
+
+export interface LoadCopy<T> {
+  /** The copy namespace (`giftCards`, `coupons`, …) — keys resolve through copyParam. */
+  prefix: string;
+  /** Shown when the site genuinely has none. */
+  empty: string;
+  /** Shown when the query failed. */
+  error: string;
+  /** Shown when Wix refused the visitor (member-only data). */
+  signIn: string;
+  /** Sample rows for the explicit sample preview ONLY. */
+  sample: () => T[];
+}
+
+type Rows<K extends string, T> = { [P in K]: T[] } & { emptyText: string } & LoadFlags;
+
+/** A query answered. Rows win; an empty answer is a real empty state. */
+export function loaded<K extends string, T>(key: K, rows: T[], copy: LoadCopy<T>): Rows<K, T> {
+  if (rows.length) return { ...READY, [key]: rows, emptyText: "" } as Rows<K, T>;
+  if (samplesRequested()) return sampleRows(key, copy, "empty");
+  return { ...READY, [key]: [], emptyText: copyParam(`${copy.prefix}.emptyText`, copy.empty), hideEmpty: false } as Rows<K, T>;
+}
+
+/** A query threw. Never rows the customer did not create. */
+export function loadFailed<K extends string, T>(key: K, err: unknown, copy: LoadCopy<T>): Rows<K, T> {
+  if (samplesRequested()) return sampleRows(key, copy, "unavailable");
+  const signIn = needsSignIn(err);
+  return {
+    ...READY,
+    status: "error",
+    [key]: [],
+    emptyText: "",
+    error: signIn ? copyParam(`${copy.prefix}.signInText`, copy.signIn) : copyParam(`${copy.prefix}.errorText`, copy.error),
+    signInRequired: signIn,
+    notErrored: false,
+    busy: true,
+    noSignIn: !signIn,
+  } as Rows<K, T>;
+}
+
+function sampleRows<K extends string, T>(key: K, copy: LoadCopy<T>, reason: "empty" | "unavailable"): Rows<K, T> {
+  return {
+    ...READY, [key]: copy.sample(), emptyText: "",
+    isMock: true, notMock: false, notMockEmpty: reason !== "empty", notMockUnavailable: reason !== "unavailable",
+  } as Rows<K, T>;
+}

package/templates/salon-spa/tier5-src/_shared/business-chat-copy.ts

@@ -0,0 +1,40 @@
+// Shared defaults keep descriptor copy and worker fallbacks aligned.
+import { copyParam } from "./himi-copy.js";
+
+export const BUSINESS_CHAT_COPY = {
+  "emptyTitle": "No messages yet",
+  "sending": "Sending…",
+  "unconfirmed": "Not confirmed",
+  "sessionChanged": "Your member session changed. Sign in again to continue.",
+  "hostUnavailable": "This app host cannot reach the inbox yet.",
+  "sendFailed": "Message delivery could not be confirmed. Check the conversation before trying again.",
+  "openFailed": "Couldn’t open the conversation. Try again.",
+  "loadFailed": "Couldn’t load the conversation. Try again.",
+  "signInPrompt": "Sign in to send a message.",
+  "rejected": "The message was rejected. Your draft is retained.",
+  "checkDelivery": "No automatic retry was made. Reopen the conversation to check whether it arrived.",
+  "suggestionSent": "Suggestion sent.",
+  "suggestionRejected": "The suggestion was rejected.",
+  "suggestionUnconfirmed": "Suggestion delivery is unconfirmed; it will not be sent again automatically.",
+  "productImage": "Product image",
+  "connecting": "Connecting to live updates",
+  "reconnecting": "Reconnecting live updates",
+  "liveSessionUnavailable": "Live updates unavailable for this session",
+  "liveHostUnavailable": "Live updates unavailable in this host",
+  "liveSetupFailed": "Live connection setup failed",
+  "liveAuthFailed": "Live connection authentication failed",
+  "liveInterrupted": "Live connection interrupted",
+  "liveUnreadable": "Live update could not be read",
+  "livePaused": "Live updates paused",
+  "liveUnavailable": "Live updates unavailable",
+  "openLink": "Open link",
+  "today": "Today",
+  "yesterday": "Yesterday",
+  "aiAssistant": "AI assistant",
+  "staffResponse": "Staff Response",
+  "imageAttachment": "Image attachment"
+} as const;
+
+export function businessChatCopy(key: keyof typeof BUSINESS_CHAT_COPY): string {
+  return copyParam(`businessChat.${key}`, BUSINESS_CHAT_COPY[key]);
+}

package/templates/salon-spa/tier5-src/_shared/business-chat-history.ts

@@ -0,0 +1,48 @@
+/** Smart Chat resolves its conversation from the caller's Wix identity. Its history must not
+ * be replaced by a different conversation returned by the Members chat room list. */
+type Raw = Record<string, unknown>;
+const object = (value: unknown): Raw => value !== null && typeof value === 'object' && !Array.isArray(value) ? value as Raw : {};
+const text = (value: unknown): string => typeof value === 'string' ? value : '';
+
+// Positive lists: navigation, cart events, owner notifications and training messages are not a transcript.
+const VISITOR_TYPES = new Set(['QUESTION', 'VISITOR_MESSAGE', 'VISITOR_OPTION_SELECTED', 'FAQ_QUESTION']);
+const ASSISTANT_TYPES = new Set(['ANSWER', 'INTRO', 'LEGAL', 'OFFLINE', 'OUT_OF_QUOTA', 'FAQ_ANSWER']);
+const STAFF_TYPES = new Set(['USER_ANSWER', 'WIX_USER_CARD', 'WIX_USER_MINIMAL_BODY', 'WIX_USER_MEDIA', 'WIX_USER_FORM']);
+
+/** Adapt the current identity-scoped Smart Chat conversation to the existing presentation pipeline.
+ * `inboxId` identifies an Inbox MESSAGE, never a room. Where that exact message exists in the
+ * member page, keep its rich content; otherwise use the persisted Smart Chat body. No text/id guesses. */
+export function smartChatHistory(aiMessages: unknown[], memberPage: unknown[], participantId: string): { conversationId: string; messages: Raw[] } | null {
+  const dated = aiMessages.map(object)
+    .filter(message => text(message.id) && text(message.conversationId) && Number.isFinite(Date.parse(text(message.createdDate))))
+    .sort((a, b) => Date.parse(text(a.createdDate)) - Date.parse(text(b.createdDate)));
+  const conversationId = text(dated.at(-1)?.conversationId);
+  if (!conversationId) return null;
+  const memberRows = new Map(memberPage.map(object).map(row => [text(row.id), row]));
+  const messages: Raw[] = [];
+  for (const message of dated) {
+    if (message.conversationId !== conversationId) continue;
+    const sender = text(message.sender);
+    const kind = text(message.messageType);
+    const mine = sender === 'SITE_VISITOR' && VISITOR_TYPES.has(kind);
+    if (!mine && !(sender === 'ASSISTANT' && ASSISTANT_TYPES.has(kind)) && !(sender === 'USER' && STAFF_TYPES.has(kind))) continue;
+    const body = object(message.body);
+    const bodyText = [text(body.mainText), text(body.footerText)].filter(Boolean).join('\n');
+    const rich = memberRows.get(text(message.inboxId));
+    // A quick-reply-only metadata answer is not an empty bubble (the options are shown by the composer).
+    if (!bodyText && !rich) continue;
+    messages.push({
+      ...rich,
+      id: `smart-chat:${message.id}`,
+      // Member-room sequence numbers cannot order a different Smart Chat conversation.
+      sequence: undefined,
+      createdDate: message.createdDate,
+      sender: { userId: mine ? participantId : `smart-chat:${sender}` },
+      aiSiteChatSender: sender,
+      messageType: rich?.messageType ?? 'message',
+      data: rich && (Array.isArray(rich.data) && rich.data.length || rich.templateData)
+        ? rich.data : [{ mimeType: 'text/plain', data: { text: bodyText } }],
+    });
+  }
+  return messages.length ? { conversationId, messages } : null;
+}