@wix/himalaya-cli 0.1487.0 → 0.1489.0

package/templates/branded-lite/himalaya.content.json

@@ -13,6 +13,9 @@
     "himi_addresses": {
       "displayName": "Addresses"
     },
+    "himi_agenda": {
+      "displayName": "Agenda"
+    },
     "himi_app_info": {
       "displayName": "App Info"
     },

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

@@ -48,7 +48,7 @@ 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"], restaurants: ["himi_menu", "himi_reserve"],
+  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"],
@@ -67,6 +67,7 @@ export const VERTICAL_ROOT_SCREENS: Readonly<Record<string, readonly string[]>>
 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"],

package/templates/branded-lite/tier5-src/_shared/business-chat-model.ts

@@ -1,16 +1,18 @@
 import { formatClock } from './engine-intl.js';
 import { mergeMessages, normalizeMessages, type MessageRow } from './business-chat-message-model.js';
 
-export interface BusinessChatIntent { id:string; text:string; roomId:string; principal:string }
+/** `delivery` is what the composer's own row shows while the server catches up: sending, accepted (shown with its
+ *  time) or unconfirmed (the request failed without a definite answer). */
+export interface BusinessChatIntent { id:string; text:string; roomId:string; principal:string; createdDate:string; delivery:'sending'|'sent'|'unconfirmed'; senderName?:string }
 
 export function newBusinessChatIntent(text:string,roomId:string,principal:string,random=Math.random):BusinessChatIntent{
- return {id:'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g,c=>{const r=Math.floor(random()*16);return(c==='x'?r:(r&3)|8).toString(16);}),text,roomId,principal};
+ return {id:'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g,c=>{const r=Math.floor(random()*16);return(c==='x'?r:(r&3)|8).toString(16);}),text,roomId,principal,createdDate:new Date().toISOString(),delivery:'sending'};
 }
 export function businessChatSendRejected(error:unknown):boolean{
  return /\b(400|401|403|404|409|413|422|429)\b|approved first-party|webwix_owner_only|sign_in_required|owner_preview_read_only/i.test(String((error as Error)?.message||error));
 }
 export function draftAfterAcceptedSend(currentDraft:string,sentDraft:string):string{return currentDraft===sentDraft?'':currentDraft;}
-export function pendingIntentWasObserved(messages:MessageRow[],intent:BusinessChatIntent|null):boolean{
+export function pendingIntentWasObserved(messages:{id:string}[],intent:BusinessChatIntent|null):boolean{
  return !!intent&&messages.some(message=>message.id===intent.id);
 }
 export function messageTimeLabel(value:string):string{

package/templates/branded-lite/tier5-src/_shared/business-chat-presenter.ts

@@ -14,7 +14,7 @@ export type BusinessMessagePart = {
 
 export type BusinessTextRun = { text: string; marks?: string[] };
 export type BusinessSuggestion = { id: string; messageId: string; label: string; kind: "postback" | "visitor_option"; appId?: string; interactionId?: string; enabled: boolean; disabled: boolean };
-export type BusinessArticleAction = { id: string; label: string; url: string };
+export type BusinessArticleAction = { id: string; label: string; url: string; style: "primary" | "secondary" };
 export type BusinessVisitorOptions = { answerTo: string; labels: string[] };
 
 export type BusinessMessage = {
@@ -266,8 +266,8 @@ function articleActions(message: RecordValue, messageId: string): BusinessArticl
     const rawUrl = typeof button.cta === "string" ? button.cta.trim() : "";
     if (!label || !rawUrl || button.payload != null) return [];
     // No `URL` global in a worker: accept only a plain https URL whose authority carries no credentials.
-    if (!/^https:\/\/[^\s\\@/?#]+(?:[/?#]\S*)?$/.test(rawUrl)) return [];
-    return [{ id: `${messageId}:article-${index}`, label, url: rawUrl }];
+    if (!isSafeLink(rawUrl)) return [];
+    return [{ id: `${messageId}:article-${index}`, label, url: rawUrl, style: "secondary" as const }];
   });
 }
 
@@ -301,6 +301,59 @@ function hiddenInternalNotice(message: RecordValue): boolean {
     Object.keys(content).length === 0 && !hasActionsOrMedia;
 }
 
+const SAFE_LINK = /^https:\/\/[^\s\\@/?#]+(?:[/?#]\S*)?$/;
+/** Sentence punctuation after a link ("…/page." or "(see …/page)") is not part of it. */
+function cleanLinkUrl(raw: string): string {
+  let url = raw;
+  for (;;) {
+    const last = url[url.length - 1];
+    if (last && (".,;:!?".includes(last) || (last === ")" && !url.includes("(")))) url = url.slice(0, -1); else break;
+  }
+  return url;
+}
+/** A plain https link with no control characters (a null byte would pass `\S`). */
+const isSafeLink = (url: string): boolean => SAFE_LINK.test(url) && !/[\u0000-\u001f\u007f-\u009f]/.test(url);
+
+/** Owner tools (a product, a coupon, a scheduling link) reach a member as plain text: a title, detail
+ *  lines and `Label: https://…` lines. On a phone that is a wall of text with a URL nobody can tap, so a
+ *  link line becomes a button and a coupon code its own block. Only plain https links are lifted. */
+export function extractBusinessMessageExtras(markdown: string): { text: string; links: { label: string; url: string }[]; couponCode: string } {
+  const kept: string[] = [];
+  const links: { label: string; url: string }[] = [];
+  let couponCode = "";
+  // True only when a button was really added: a repeated link, or one past the sixth, stays in the text.
+  const addLink = (label: string, url: string): boolean => {
+    if (links.length >= 6 || links.some((link) => link.url === url)) return false;
+    links.push({ label: label.replace(/[*_`]/g, "").trim().slice(0, 40) || "Open link", url });
+    return true;
+  };
+  for (const line of markdown.split("\n")) {
+    const trimmed = line.trim();
+    const labelled = /^(?:[-*•]\s+)?([^:\n]{1,40}):\s*(https:\/\/\S+)$/.exec(trimmed);
+    const labelledUrl = labelled ? cleanLinkUrl(labelled[2]!) : "";
+    if (labelled && isSafeLink(labelledUrl) && addLink(labelled[1]!, labelledUrl)) continue;
+    const bare = /^(https:\/\/\S+)$/.exec(trimmed);
+    const bareUrl = bare ? cleanLinkUrl(bare[1]!) : "";
+    if (bare && isSafeLink(bareUrl)) {
+      // A bare link is named by the list item above it ("- Settle Into Sleep"), else by its site.
+      const item = /^[-*•]\s+(.{1,60})$/.exec((kept[kept.length - 1] ?? "").trim());
+      if (addLink(item?.[1] ?? `Open ${bareUrl.slice(8).split(/[/?#]/)[0]!.replace(/^www\./, "")}`, bareUrl)) {
+        if (item) kept.pop();
+        continue;
+      }
+    }
+    const code = /^(.*?)[,;]?\s*\b[Cc]ode:\s*([A-Z0-9_-]{3,32})$/.exec(trimmed);
+    if (code && !couponCode) {
+      couponCode = code[2]!;
+      if (code[1]!.trim()) kept.push(code[1]!.trim());
+      continue;
+    }
+    kept.push(line);
+  }
+  // Text with nothing lifted out is returned untouched, trailing newline included.
+  return { text: links.length || couponCode ? kept.join("\n").trim() : markdown, links, couponCode };
+}
+
 /** Adds only Business business-chat presentation fields to the canonical message rows. */
 export function presentBusinessMessages<T extends Pick<BusinessMessage, "id" | "sender" | "mine" | "createdDate" | "plainText" | "parts">>(
   rows: T[],
@@ -326,6 +379,10 @@ export function presentBusinessMessages<T extends Pick<BusinessMessage, "id" | "
   startsDay: boolean;
   scrollAnchor: string;
   notMine: boolean;
+  couponCode: string;
+  noCoupon: boolean;
+  productSlug: string;
+  productName: string;
 })[] {
   const metadata = new Map<string, RecordValue>();
   for (const value of raw) {
@@ -377,7 +434,25 @@ export function presentBusinessMessages<T extends Pick<BusinessMessage, "id" | "
     const bodyRuns = htmlMessageRuns(message) ?? plainTextRuns;
     const bodyMarkdown = markdownFromRuns(bodyRuns);
     const buttons = messageButtons(message, row.id);
-    const articles = articleActions(message, row.id);
+    const extras = mine ? { text: bodyMarkdown, links: [], couponCode: "" } : extractBusinessMessageExtras(bodyMarkdown);
+    // A card is a title and detail lines: Wix sends events as one, and an owner's product, coupon or scheduling link
+    // arrives as plain text of the same shape. Its title leads in bold, and a coupon's title is its code, which
+    // the coupon block already shows.
+    const lines = extras.text.split("\n");
+    const first = lines[0]!.trim();
+    // A title is short, is not a sentence, and carries no markup of its own: bolding a whole paragraph would flip the
+    // meaning of the `**` already inside it.
+    const titleLike = lines.length > 1 && first.length <= 60 && !/[.!?:]$/.test(first) && !first.includes("*");
+    const cardLike = titleLike && (!!standardEventText || extras.links.length > 0 || !!extras.couponCode);
+    const titled = cardLike && extras.couponCode && first === extras.couponCode ? lines.slice(1).join("\n")
+      : cardLike && lines.length > 1 && !first.startsWith("**") ? `**${first}**\n${lines.slice(1).join("\n")}` : extras.text;
+    // A product card links to its store page; the slug lets the worker find the product and show its picture.
+    const productPage = cardLike ? extras.links.map((link) => /^https:\/\/[^/?#]+(?:\/[^/?#]+)*?\/product-page\/([^/?#]+)/i.exec(link.url)?.[1]).find(Boolean) : undefined;
+    // A file, recording or video has no inline player here: it gets a button that opens it.
+    const attachmentLinks = row.parts.filter((part) => (part.kind === "file" || part.kind === "audio" || part.kind === "video") && !!part.url)
+      .map((part, at) => ({ id: `${row.id}:attachment-${at}`, label: (part.fileName || part.caption || `Open ${part.kind}`).slice(0, 40), url: part.url as string, style: "secondary" as const }));
+    const articles = [...articleActions(message, row.id), ...attachmentLinks, ...extras.links.map((link, at) => ({ id: `${row.id}:link-${at}`, label: link.label, url: link.url, style: /\b(view|buy|shop|book|pay|order|checkout|reserve|schedule)\b/i.test(link.label) ? "primary" as const : "secondary" as const }))]
+      .filter((action, at, all) => all.findIndex((other) => other.url === action.url) === at);
 
     return {
       ...row,
@@ -392,7 +467,11 @@ export function presentBusinessMessages<T extends Pick<BusinessMessage, "id" | "
       noImage: !imageUrl,
       bodyText,
       bodyRuns,
-      bodyMarkdown,
+      bodyMarkdown: titled,
+      couponCode: extras.couponCode,
+      noCoupon: !extras.couponCode,
+      productSlug: productPage ?? "",
+      productName: productPage ? first : "",
       isAiGenerated,
       suggestions: buttons,
       articleActions: articles,

package/templates/branded-lite/tier5-src/_shared/himi-bookings.ts

@@ -39,6 +39,20 @@ export function slotStartInstant(slot: { startDate?: string; timezone?: unknown
   return wall - (Number.isFinite(again) ? again : offset);
 }
 
+/** `himi_time` reads the next two weeks. A host's `start` past them (an Agenda session weeks
+ *  ahead) is read on its own — that session's local day only, never everything up to it — so it
+ *  can be preselected while each read stays bounded. `undefined` when the start is inside the two
+ *  weeks. */
+export function availabilityBeyond(now: Date, start = ""): { from: Date; until: Date } | undefined {
+  const end = now.getTime() + 14 * 86_400_000;
+  const at = start ? Date.parse(start) : NaN;
+  if (!Number.isFinite(at) || at < end) return undefined;
+  const d = new Date(at);
+  const dayStart = new Date(d.getFullYear(), d.getMonth(), d.getDate());
+  // Never back into the two weeks already read: a slot in both would be listed twice.
+  return { from: new Date(Math.max(dayStart.getTime(), end)), until: new Date(d.getFullYear(), d.getMonth(), d.getDate() + 1) };
+}
+
 /** The slot a host asked to open at (`himi_time` input `start`, an ISO 8601 instant): the id of the
  *  slot that starts at that same instant, or "" when none does (taken since, or out of the window).
  *  Compared as instants, so `…T16:30:00Z` finds a slot listed as `…T18:30:00+02:00`, or as a local

package/templates/branded-lite/tier5-src/_shared/member-account-routes.ts

@@ -18,7 +18,8 @@ export const MEMBER_ACCOUNT_ROUTES_MIN_BINARY = "1.4.0";
 export const MEMBER_MEDIA_FIELD_MIN_BINARY = "1.5.0";
 export const MEMBER_PASSWORD_ACTIONS_MIN_BINARY = "1.5.0";
 
-function atLeast(version: string, floor: string): boolean {
+/** `version` (a HimalayaCore binary version, pre-release suffix ignored) is `floor` or later. */
+export function atLeast(version: string, floor: string): boolean {
   const parts = (v: string) => v.split("-")[0].split(".").map((p) => Number.parseInt(p, 10) || 0);
   const a = parts(version), b = parts(floor);
   for (let i = 0; i < Math.max(a.length, b.length); i++) {

package/templates/branded-lite/tier5-src/business-chat/index.ts

@@ -2,16 +2,21 @@ import { defineService } from '@himalaya/state';
 import * as chat from '../_shared/business-chat-transport.js';
 import type { ChatIdentity } from '../_shared/business-chat-transport.js';
 import { type MessageRow } from '../_shared/business-chat-message-model.js';
-import { businessChatSendRejected, draftAfterAcceptedSend, pendingIntentWasObserved, chronologicalMessages, newBusinessChatIntent, type BusinessChatIntent } from '../_shared/business-chat-model.js';
+import { businessChatSendRejected, messageTimeLabel, pendingIntentWasObserved, chronologicalMessages, newBusinessChatIntent, type BusinessChatIntent } from '../_shared/business-chat-model.js';
 import { subscribeRealtime, unsubscribeRealtime, getRealtimeStatus, type RealtimeStatus, type RealtimeEventEnvelope } from '@himalaya/wix-chat';
 import { dispatchBusinessSuggestion, businessRealtimeStatusLabel, businessVisitorOptionSuggestions, presentBusinessMessages, selectExistingBusinessRoom, shouldRefreshBusinessHistory, type BusinessSuggestion, type BusinessVisitorOptions, businessVisitorOptionRequest, businessVisitorOptionsFromAiMessages, newBusinessSelectionId} from '../_shared/business-chat-presenter.js';
 import { listMessages, streamMessages } from '@himalaya/wix-ai-site-chat';
 import { hostSiteFromInput } from '../_shared/branded-lite-hosted.js';
+import { productImage, searchStoreProducts } from '../_shared/himi-store.js';
 
 type PendingIntent = BusinessChatIntent;
-type BusinessMessageRow = MessageRow & {
- senderAvatar:string; senderName:string; senderInitials:string; senderBadge:string; imageUrl:string; imageDescription:string; noImage:boolean; bodyText:string; bodyMarkdown:string; bodyRuns:{text:string;marks?:string[]}[]; isAiGenerated:boolean; suggestions:BusinessSuggestion[]; visitorOptions:BusinessVisitorOptions|null; notMine:boolean;
+// Only what the screen reads. This state crosses into the worker on every keystroke, so a row carries no raw
+// parts, plain text or text runs: they would be re-sent each time for nothing.
+type BusinessMessageRow = Pick<MessageRow,'id'|'sender'|'when'|'createdDate'|'mine'> & {
+ senderAvatar:string; senderName:string; senderInitials:string; senderBadge:string; imageUrl:string; imageDescription:string; noImage:boolean; bodyText:string; bodyMarkdown:string; suggestions:BusinessSuggestion[]; articleActions:{id:string;label:string;url:string;style:'primary'|'secondary'}[]; couponCode:string; noCoupon:boolean; notMine:boolean;
  dayLabel:string; dayHidden:boolean; startsDay:boolean; scrollAnchor:string;
+ /** Only the member's own row that the server has not returned yet. */
+ pending?:boolean;
 };
 type State = {
   phase:'loading'|'ready'|'error'|'guest'; error:string; notice:string; member:boolean;
@@ -57,6 +62,14 @@ async function sendBusinessVisitorOption(options:BusinessVisitorOptions|null|und
  return true;
 }
 function liveDescription(state:string,reason:string):string{return businessRealtimeStatusLabel(state,reason);}
+/** The member's own message as it shows the instant they tap Send, before the server has answered. It carries the
+ *  id sent to the server, so the real message replaces it once history returns it. */
+function pendingRow(intent:BusinessChatIntent):BusinessMessageRow{
+ const when=intent.delivery==='sending'?'Sending…':intent.delivery==='unconfirmed'?'Not confirmed':messageTimeLabel(intent.createdDate);
+ return {id:intent.id,sender:'',when,createdDate:intent.createdDate,mine:true,
+  senderAvatar:'',senderName:intent.senderName??'',senderInitials:'',senderBadge:'',imageUrl:'',imageDescription:'',noImage:true,bodyText:intent.text,bodyMarkdown:intent.text,
+  suggestions:[],articleActions:[],couponCode:'',noCoupon:true,notMine:false,dayLabel:'',dayHidden:true,startsDay:false,scrollAnchor:`himi_business_chat.message_${intent.id}`,pending:true};
+}
 function shape(s:State):State{const used=new Set(s.usedSuggestionIds);const messages=s.messages.map(row=>({...row,suggestions:(row.suggestions||[]).map(button=>used.has(button.id)?{...button,enabled:false,disabled:true}:button)}));const quickReplies=(s.quickReplies||[]).map(button=>used.has(button.id)?{...button,enabled:false,disabled:true}:button);const quickEnabled=quickReplies.some(button=>button.enabled);return {...s,messages,quickReplies,hasQuickReplies:quickEnabled,noQuickReplies:!quickEnabled,scrollAnchor:messages[messages.length-1]?.scrollAnchor||'',liveLabel:liveDescription(s.liveState,s.liveReason),hasActiveRoom:!!s.roomId,noActiveRoom:!s.roomId,hasHostedName:!!s.hostedName,noHostedName:!s.hostedName,isGuest:s.phase==='guest',notGuest:s.phase!=='guest',realtimeDiagnostic:`state=${s.liveState}; reason=${s.liveReason||'none'}; events=${s.realtimeEventCount}; lastType=${/^(message|messagesent)$/i.test(s.lastRealtimeEventType)?s.lastRealtimeEventType:'none'}`,errorText:s.error,loadingHidden:s.phase!=='loading'||!!s.error,noError:!s.error,noNotice:!s.notice,noMessages:!messages.length,hasMessages:!!messages.length,noEmpty:s.phase!=='ready'||!!messages.length,
   notLoading:s.phase!=='loading',sendDisabled:!s.member||!s.roomId||s.busy||!s.draft.trim()||!!s.pendingIntent,sendEnabled:!!s.member&&!!s.roomId&&!s.busy&&!!s.draft.trim()&&!s.pendingIntent,noLive:!s.roomId||s.liveState==='connected'};}
 function safeLoadFailure(error:unknown):string{
@@ -67,19 +80,77 @@ function safeLoadFailure(error:unknown):string{
 }
 function value(arg:unknown):string{if(typeof arg==='string')return arg;const a=arg as Record<string,unknown>|null;return typeof a?.value==='string'?a.value:'';}
 function param(arg:unknown,key:string):string{const a=arg as Record<string,unknown>|null;const p=a?.params as Record<string,unknown>|undefined;return typeof a?.[key]==='string'?a[key] as string:typeof p?.[key]==='string'?p[key] as string:'';}
-async function presentMessages(existing:BusinessMessageRow[],raw:unknown[],memberId?:string):Promise<BusinessMessageRow[]>{
- const rows=chronologicalMessages(existing,raw,memberId) as BusinessMessageRow[];
+// A private attachment's download URL costs a round trip and stays valid for minutes, so a refresh reuses it.
+const attachmentUrls=new Map<string,{url:string;at:number}>();
+const ATTACHMENT_URL_TTL_MS=4*60*1000;
+async function privateAttachmentUrl(part:{mediaId?:string;mediaProvider?:string;url?:string;fileName?:string}):Promise<string>{
+ const key=`${currentIdentity?.email??''}|${part.mediaId??''}`;
+ const hit=attachmentUrls.get(key);
+ if(hit&&Date.now()-hit.at<ATTACHMENT_URL_TTL_MS)return hit.url;
+ const url=await chat.attachmentUrl(me(),part);
+ if(url)attachmentUrls.set(key,{url,at:Date.now()});
+ return url;
+}
+// A product card's picture comes from the store: the message carries only the product page link. A found picture is
+// reused for ten minutes and a miss for two, so a refresh never repeats the lookup.
+const productImages=new Map<string,{url:string;at:number}>();
+const productImageLookups=new Map<string,Promise<string>>();
+const PRODUCT_IMAGE_TTL_MS=10*60*1000;
+const PRODUCT_IMAGE_MISS_TTL_MS=2*60*1000;
+function productImageFor(slug:string,name:string):Promise<string>{
+ // Keyed by both: the search runs on the name, so a miss for one name must not hide a hit for another.
+ const key=JSON.stringify([slug,name]);
+ const hit=productImages.get(key);
+ if(hit&&Date.now()-hit.at<(hit.url?PRODUCT_IMAGE_TTL_MS:PRODUCT_IMAGE_MISS_TTL_MS))return Promise.resolve(hit.url);
+ const running=productImageLookups.get(key);
+ if(running)return running;
+ const lookup=(async()=>{
+  let url='';
+  try{
+   // The name first; then the link's own words, for a product renamed since the message was written. The slug is the
+   // identity, so a same-named product with another slug is used only if neither search finds the slug.
+   let sameName:Parameters<typeof productImage>[0]|undefined;
+   let bySlug:Parameters<typeof productImage>[0]|undefined;
+   for(const query of [name,slug.replace(/-/g,' ')]){
+    if(!query.trim())continue;
+    const found=(await searchStoreProducts({query,limit:10})).products??[];
+    bySlug=found.find(product=>product.slug===slug);
+    if(bySlug)break;
+    if(query===name&&!sameName)sameName=found.find(product=>product.name===name);
+   }
+   const match=bySlug??sameName;
+   if(match)url=productImage(match);
+  }catch{url='';}
+  productImages.set(key,{url,at:Date.now()});
+  return url;
+ })().finally(()=>{productImageLookups.delete(key);});
+ productImageLookups.set(key,lookup);
+ return lookup;
+}
+function slimRow(row:Record<string,unknown>):BusinessMessageRow{
+ const pick=(...keys:string[])=>Object.fromEntries(keys.map(key=>[key,row[key]]));
+ return pick('id','sender','when','createdDate','mine','senderAvatar','senderName','senderInitials','senderBadge','imageUrl','imageDescription','noImage','bodyText','bodyMarkdown','suggestions','articleActions','couponCode','noCoupon','notMine','dayLabel','dayHidden','startsDay','scrollAnchor') as unknown as BusinessMessageRow;
+}
+async function presentMessages(existing:MessageRow[],raw:unknown[],memberId?:string):Promise<BusinessMessageRow[]>{
+ const rows=chronologicalMessages(existing,raw,memberId) as MessageRow[];
  const prepared=await Promise.all(rows.map(async row=>{
   const parts=await Promise.all(row.parts.map(async part=>{
-   if(part.kind!=='image')return part;
+   if(part.kind!=='image'&&part.kind!=='file'&&part.kind!=='audio'&&part.kind!=='video')return part;
    if(part.mediaProvider==='WixMediaPrivate'&&part.mediaId){
-    try{return {...part,url:await chat.attachmentUrl(me(),part)};}catch{return {...part,url:''};}
+    try{return {...part,url:await privateAttachmentUrl(part)};}catch{return {...part,url:''};}
    }
    return part;
   }));
   return {...row,parts};
  }));
- return presentBusinessMessages(prepared as unknown as Parameters<typeof presentBusinessMessages>[0],raw,businessParticipantId) as unknown as BusinessMessageRow[];
+ const presented=presentBusinessMessages(prepared as unknown as Parameters<typeof presentBusinessMessages>[0],raw,businessParticipantId) as unknown as Record<string,unknown>[];
+ await Promise.all(presented.map(async row=>{
+  const slug=typeof row.productSlug==='string'?row.productSlug:'';
+  if(!slug||row.imageUrl)return;
+  const url=await productImageFor(slug,String(row.productName||''));
+  if(url)Object.assign(row,{imageUrl:url,noImage:false,imageDescription:String(row.productName||'Product image')});
+ }));
+ return presented.map(slimRow);
 }
 function me():ChatIdentity{
  const identity=currentIdentity;
@@ -104,7 +175,7 @@ function safeError(error:unknown,operation:'load'|'send'|'init'):string{
 }
 async function endSubscription():Promise<void>{const id=subscriptionId;subscriptionId='';if(id)try{await unsubscribeRealtime({subscriptionId:id});}catch{}}
 function clearPrivate(s:State,phase:'guest'|'error'='guest'):State{
- currentIdentity=null;businessParticipantId='';epoch++;void endSubscription();
+ attachmentUrls.clear();productImages.clear();currentIdentity=null;businessParticipantId='';epoch++;void endSubscription();
  return shape({...initial,phase,error:phase==='guest'?'Sign in to send a message.':s.error});
 }
 let refreshTail:Promise<unknown>=Promise.resolve();
@@ -144,7 +215,9 @@ async function refreshHistory(s:State):Promise<State|undefined>{
   const base:State=same?withLiveFields(s,latest,liveDraft):{...s,draft:liveDraft};
   const intentObserved=pendingIntentWasObserved(messages,base.pendingIntent);
   const draft=intentObserved&&base.pendingIntent&&base.draft.trim()===base.pendingIntent.text?'':base.draft;
-  return shape({...base,messages,visitorOptions,quickReplies:businessVisitorOptionSuggestions(visitorOptions),draft,pendingIntent:intentObserved?null:base.pendingIntent,phase:'ready',error:'',loadFailure:''});
+  // A send the server has not returned yet stays on screen until history does.
+  const shown=!intentObserved&&base.pendingIntent?[...messages,pendingRow(base.pendingIntent)]:messages;
+  return shape({...base,messages:shown,visitorOptions,quickReplies:businessVisitorOptionSuggestions(visitorOptions),draft,pendingIntent:intentObserved?null:base.pendingIntent,phase:'ready',error:'',loadFailure:''});
  }catch(error){
   const wrapped=error instanceof Error?error:new Error('load_failed');
   Object.assign(wrapped,{businessLoadFailure:safeLoadFailure(error)});
@@ -160,6 +233,20 @@ function withLiveFields(st:State,latest:State,draft:string):State{
   scrollSend:Math.max(st.scrollSend,latest.scrollSend)};
 }
 function withLiveDraft(st:State):State{const latest=readServiceState();return withLiveFields(st,latest,latest.draft);}
+type SendResult={id:string;outcome:'sent'|'rejected'|'unconfirmed'|'signed_out';draft:string;error?:unknown};
+/** Posts one message and reports how it ended; never throws. The caller already showed the message. */
+async function deliver(pending:BusinessChatIntent,draft:string):Promise<void>{
+ const sendEpoch=epoch;
+ let result:SendResult={id:pending.id,outcome:'sent',draft};
+ try{
+  await Promise.resolve();// the action that started this has returned its state by now
+  await chat.sendMessage(me(),pending.roomId,{id:pending.id,text:pending.text});
+ }catch(error){
+  const lost=/member_sign_in_required|MemberAccessChanged|\b401\b|\b403\b/i.test(String(error));
+  result={id:pending.id,draft,error,outcome:lost?'signed_out':businessChatSendRejected(error)?'rejected':'unconfirmed'};
+ }finally{sendFlight=false;}
+ if(sendEpoch===epoch)void svc.settleSend(result);
+}
 const svc=defineService<State,Record<string,(s:State,a?:unknown)=>State|undefined|Promise<State|undefined>>>('businessChat',{
  state:shape(initial),notHydrated:Object.keys(initial) as (keyof State)[],
  actions:{
@@ -198,33 +285,46 @@ const svc=defineService<State,Record<string,(s:State,a?:unknown)=>State|undefine
   },
   // Runs on every keystroke, so it must not rebuild the message list the way `shape` does.
   setDraft:(s,a)=>{draftRevision++;const draft=value(a);const sendEnabled=!!s.member&&!!s.roomId&&!s.busy&&!!draft.trim()&&!s.pendingIntent;return {...s,draft,sendEnabled,sendDisabled:!sendEnabled};},
-  send:async s=>{
+  // Shows the message and clears the box at once; the network round trip and the history reload that follow
+  // run in the background and settle through `settleSend`.
+  send:s=>{
    const text=s.draft.trim();
    if(!text||sendFlight||!s.roomId||!s.member||s.pendingIntent)return s;
-   sendFlight=true;const pending=newBusinessChatIntent(text,s.roomId,s.principal);
-   const draftAtSend=s.draft;const sendEpoch=epoch;
-   try{
-    await chat.sendMessage(me(),pending.roomId,{id:pending.id,text:pending.text});
-    if(sendEpoch!==epoch)return undefined;
-    const latest=readServiceState();
-    if(latest.roomId!==pending.roomId||latest.principal!==pending.principal)return undefined;
-    draftRevision++;// a refresh that began before this send must not bring the sent text back into the composer
-    s=shape({...latest,draft:draftAfterAcceptedSend(latest.draft,draftAtSend),pendingIntent:null,error:'',notice:'Message sent.',scrollSend:latest.scrollSend+1});
-    try{const loaded=await loadLatest(s,true);return loaded?shape({...loaded,notice:'Message sent.'}):undefined;}catch(error){
-     // A session lost by an older operation says nothing about the member who is signed in now.
-     if(sendEpoch!==epoch)return undefined;
-     if(/member_sign_in_required|MemberAccessChanged|\b401\b|\b403\b/i.test(String(error)))return clearPrivate(s,'guest');
-     return withLiveDraft(s);
-    }
-   }catch(error){
+   // The member's name as their earlier messages show it, so the row keeps its size when the real message replaces it.
+   const ownName=[...s.messages].reverse().find(row=>row.mine&&row.senderName)?.senderName??'';
+   sendFlight=true;const pending={...newBusinessChatIntent(text,s.roomId,s.principal),senderName:ownName};
+   draftRevision++;// a refresh that began before this send must not bring the sent text back into the composer
+   void deliver(pending,s.draft);
+   return shape({...s,draft:'',pendingIntent:pending,messages:[...s.messages,pendingRow(pending)],error:'',notice:'',scrollSend:s.scrollSend+1});
+  },
+  settleSend:async(s,a)=>{
+   const result=a as SendResult|undefined;const pending=s.pendingIntent;
+   if(!result||!pending||pending.id!==result.id)return undefined;
+   const replaceRow=(intent:BusinessChatIntent)=>s.messages.map(row=>row.id===intent.id?pendingRow(intent):row);
+   if(result.outcome==='signed_out')return clearPrivate(s,'guest');
+   if(result.outcome==='rejected'){
+    // The row goes, and the text comes back unless the member has already started something new.
+    return shape({...s,messages:s.messages.filter(row=>row.id!==pending.id),pendingIntent:null,draft:s.draft.trim()?s.draft:result.draft,error:safeError(result.error,'send'),notice:'The message was rejected. Your draft is retained.'});
+   }
+   if(result.outcome==='unconfirmed'){
+    const unconfirmed={...pending,delivery:'unconfirmed' as const};
+    return shape({...s,pendingIntent:unconfirmed,messages:replaceRow(unconfirmed),error:safeError(result.error,'send'),notice:'No automatic retry was made. Reopen the conversation to check whether it arrived.'});
+   }
+   const sent={...pending,delivery:'sent' as const};
+   const accepted=shape({...s,pendingIntent:sent,messages:replaceRow(sent),error:'',notice:''});
+   const sendEpoch=epoch;
+   // The server accepted it, so Send is free again whatever history says; the row stays until history returns it.
+   // A refresh that ran while the committed intent still said sending leaves a 'Sending…' row: swap it for the accepted one.
+   const settled=(st:State):State=>shape({...st,pendingIntent:null,notice:'',messages:st.messages.some(row=>row.id===sent.id)?st.messages.map(row=>row.id===sent.id&&row.pending?pendingRow(sent):row):[...st.messages,pendingRow(sent)]});
+   // While live updates are connected the server's own event brings the message back through one refresh; a second
+   // one here would only queue behind it on the worker, delaying the member's next keystroke or send.
+   if(s.liveState==='connected')return settled(accepted);
+   try{const loaded=await loadLatest(accepted,true);return loaded?settled(loaded):undefined;}catch(error){
+    // A session lost by an older operation says nothing about the member who is signed in now.
     if(sendEpoch!==epoch)return undefined;
-    const lost=/member_sign_in_required|MemberAccessChanged|\b401\b|\b403\b/i.test(String(error));
-    if(lost)return clearPrivate(s,'guest');
-    const definitive=businessChatSendRejected(error);
-    const latest=readServiceState();
-    if(latest.roomId!==pending.roomId||latest.principal!==pending.principal)return undefined;
-    return shape({...latest,pendingIntent:definitive?null:pending,error:safeError(error,'send'),notice:definitive?'The message was rejected. Your draft is retained.':'No automatic retry was made. Reopen the conversation to check whether it arrived.'});
-   }finally{sendFlight=false;}
+    if(/member_sign_in_required|MemberAccessChanged|\b401\b|\b403\b/i.test(String(error)))return clearPrivate(accepted,'guest');
+    return settled(withLiveDraft(accepted));
+   }
   },
   sendSuggestion:async(s,a)=>{
    if(suggestionFlight||!s.member||!s.roomId||!!s.pendingIntent)return s;
@@ -284,7 +384,7 @@ const svc=defineService<State,Record<string,(s:State,a?:unknown)=>State|undefine
    }
    catch(error){if(startEpoch!==epoch)return undefined;const lost=/member_sign_in_required|MemberAccessChanged|\b401\b|\b403\b/i.test(String(error));return lost?clearPrivate(next,'guest'):shape({...withLiveDraft(next),error:safeError(error,'load'),loadFailure:typeof (error as {businessLoadFailure?:unknown})?.businessLoadFailure==='string'?(error as {businessLoadFailure:string}).businessLoadFailure:safeLoadFailure(error)});}
   },
-  dispose:async s=>{epoch++;currentIdentity=null;businessParticipantId='';await endSubscription();return shape({...initial,phase:'guest'});},
+  dispose:async s=>{epoch++;attachmentUrls.clear();productImages.clear();currentIdentity=null;businessParticipantId='';await endSubscription();return shape({...initial,phase:'guest'});},
  }
 });
 readServiceState=()=>svc.getState();

package/templates/branded-lite/tier5-src/himi-booking-time/index.ts

@@ -17,7 +17,7 @@ import { stashCopy, copyParam } from "../_shared/himi-copy.js";
 import { upsert as dbUpsert, remove as dbRemove, enqueue as dbEnqueue, type DbEntity } from "@himalaya/local-db";
 import { isBridgeUnavailable } from "../_shared/owner-load-error.js";
 import { emitHostEvent, hostEventInstant } from "../_shared/host-events.js";
-import { slotIdAt } from "../_shared/himi-bookings.js";
+import { availabilityBeyond, slotIdAt } from "../_shared/himi-bookings.js";
 import { wixMediaUrl, WIX_DETAIL_IMAGE } from "@himalaya/wix-media";
 
 // Offline-first (data-offline): booking a slot is WRITE-BEHIND against the
@@ -167,6 +167,15 @@ let pendingStart = (() => {
   const start = (globalThis as { himalaya?: { input?: { start?: unknown } } }).himalaya?.input?.start;
   return typeof start === "string" && Number.isFinite(Date.parse(start)) ? start : "";
 })();
+/** The exact session a host opened this screen at (`himalaya.input.sessionId`), when it names one:
+ *  two sessions of a class can start at the same instant, and `start` alone picks the first. */
+/** A host's `start` past the two-week window, kept for the life of this worker: a pick on that day
+ *  clears `pendingStart`, yet the reload after the guest sign-in step must still read it. */
+const farStart = pendingStart;
+let pendingSession = (() => {
+  const id = (globalThis as { himalaya?: { input?: { sessionId?: unknown } } }).himalaya?.input?.sessionId;
+  return typeof id === "string" ? id.trim() : "";
+})();
 
 function strOf(arg: unknown): string {
   if (typeof arg === "string") return arg;
@@ -197,12 +206,6 @@ function withTimeout<T>(promise: Promise<T>, ms: number): Promise<T> {
   });
 }
 
-function addDays(date: Date, days: number): Date {
-  const next = new Date(date);
-  next.setUTCDate(next.getUTCDate() + days);
-  return next;
-}
-
 function isoDate(date: Date): string {
   return date.toISOString();
 }
@@ -559,16 +562,21 @@ const svc = defineService<S, {
       let next = derive({ ...s, status: "loading", errored: false, message: "", successMessage: "" });
       next = await probeMember(next);
       try {
-        const [serviceRes, availability] = await Promise.all([
+        const now = new Date();
+        const beyond = availabilityBeyond(now, farStart);
+        const [serviceRes, availability, target] = await Promise.all([
           getService(s.id).catch(() => ({ service: undefined })),
-          queryServiceAvailability(s.id, isoDate(new Date()), isoDate(addDays(new Date(), 14))),
+          queryServiceAvailability(s.id, isoDate(now), isoDate(new Date(now.getTime() + WINDOW_DAYS * 86_400_000))),
+          // A host's start past the window (an Agenda session weeks out): its day alone, so it can
+          // be preselected. Its failure costs only that preselection.
+          beyond ? queryServiceAvailability(s.id, isoDate(beyond.from), isoDate(beyond.until)).catch(() => ({ availabilityEntries: [] })) : undefined,
         ]);
         slotsById = new Map();
         const rows: SlotRow[] = [];
         // Group by LOCAL calendar day, not by the formatted heading: two
         // distinct days can render the same text, and a UTC-derived key can
         // name a different day than the heading beside it.
-        for (const [index, entry] of (availability.availabilityEntries ?? [])
+        for (const [index, entry] of [...(availability.availabilityEntries ?? []), ...(target?.availabilityEntries ?? [])]
           .filter((candidate) => candidate.bookable !== false && candidate.slot?.startDate)
           .entries()) {
           const slot = entry.slot as WixBookingSlotFull;
@@ -595,7 +603,11 @@ const svc = defineService<S, {
         const chosen: S = selectionRevision !== revisionAtStart ? (svc.getState?.() ?? next) : next;
         // A host's `start` (deep entry): that slot preselected, or — taken since — its day.
         const wantedStart = pendingStart;
-        const startRow = wantedStart ? rows.find((r) => r.id === slotIdAt(slotsById, wantedStart)) : undefined;
+        // The named session (a slot row's id IS its session id), else the slot at that instant. A
+        // named session that is gone is "taken since" — never another session at the same time.
+        const startRow = !wantedStart ? undefined
+          : pendingSession ? rows.find((r) => r.id === pendingSession)
+          : rows.find((r) => r.id === slotIdAt(slotsById, wantedStart));
         // The requested day even with no time left on it: "taken since" opens there, nothing selected.
         const startDay = wantedStart ? days.find((d) => d.id === dayKey(wantedStart)) : undefined;
         const selectionAlive = !!startRow || slotsById.has(chosen.selectedSlotId);
@@ -638,6 +650,7 @@ const svc = defineService<S, {
       const day = chosenDay(arg);
       if (!day || !s.days.some((d) => d.id === day)) return derive(s);
       pendingStart = "";
+      pendingSession = "";
       return derive(withDay(s, day));
     },
     refreshMember: (s, arg) => { stashCopy(arg); return probeMember(s); },
@@ -649,6 +662,7 @@ const svc = defineService<S, {
       if (selected) {
         selectionRevision++;
         pendingStart = "";
+        pendingSession = "";
         if (s.isMember) clearPick();
         else rememberPick(s.id, slotId);
       }