@wix/himalaya-cli 0.1614.0 → 0.1615.0

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

@@ -0,0 +1,669 @@
+import { stashCopy } from "../_shared/himi-copy.js";
+import { businessChatCopy, BUSINESS_CHAT_COPY } from "../_shared/business-chat-copy.js";
+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, messageTimeLabel, sendAnchor, pendingIntentWasObserved, chronologicalMessages, newBusinessChatIntent, type BusinessChatIntent } from '../_shared/business-chat-model.js';
+import { subscribeRealtime, unsubscribeRealtime, getRealtimeStatus, type RealtimeStatus, type RealtimeEventEnvelope } from '@himalaya/wix-chat';
+import { businessInAppRoute, type BusinessArticleAction, dispatchBusinessSuggestion, findBusinessSuggestion, 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 { smartChatHistory } from '../_shared/business-chat-history.js';
+import { hostSiteFromInput } from '../_shared/branded-lite-hosted.js';
+import { productImage, searchStoreProducts } from '../_shared/himi-store.js';
+import { queryServices } from '@himalaya/wix-bookings';
+
+type PendingIntent = BusinessChatIntent;
+// 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:BusinessArticleAction[]; couponCode:string; noCoupon:boolean; notMine:boolean;
+ isCard:boolean; notCard:boolean; noSuggestions:boolean; noActions:boolean; cardTitle:string; cardDetail:string; noCardText:boolean;
+ dayLabel:string; dayHidden:boolean; startsDay:boolean; scrollAnchor:string;
+ /** Only the member's own row that the server has not returned yet. */
+ pending?:boolean;
+ /** Confirmed local delivery, retained until the authoritative history returns it. */
+ acceptedIntent?:BusinessChatIntent;
+};
+type State = {
+  phase:'loading'|'ready'|'error'|'guest'; error:string; notice:string; member:boolean;
+  roomId:string; principal:string; scope:string; messages:BusinessMessageRow[]; draft:string; busy:boolean;
+  historySource:'members'|'smart-chat'; historyRevision:number; smartChatEmpty:boolean;
+  /** Actual row namespace, independent of the transport followed after acceptance. */
+  transcriptSource:'members'|'smart-chat';
+  liveState:string; liveReason:string; realtimeEventCount:number; lastRealtimeEventType:string; pendingIntent:PendingIntent|null; scrollAnchor:string; scrollSend:number; usedSuggestionIds:string[]; visitorOptions:BusinessVisitorOptions|null; quickReplies:BusinessSuggestion[]; hasQuickReplies:boolean; noQuickReplies:boolean;
+  liveLabel:string; hasActiveRoom:boolean; noActiveRoom:boolean; isGuest:boolean; notGuest:boolean; realtimeDiagnostic:string; noError:boolean; noNotice:boolean; noMessages:boolean; hasMessages:boolean; noEmpty:boolean; notLoading:boolean;
+  hostedName:string; hasHostedName:boolean; noHostedName:boolean;
+  /** Who signs business messages: the hosted site, else the name the screen's `init` passes. */
+  businessName:string; businessInitials:string;
+  sendDisabled:boolean; sendEnabled:boolean; noLive:boolean; loadingHidden:boolean; errorText:string; loadFailure:string;
+};
+// A hosted build serves many businesses: the title is the site the host opened, not the app's own name.
+const hostedName=hostSiteFromInput((globalThis as {himalaya?:{input?:unknown}}).himalaya?.input)?.name??'';
+/** One or two capitals for a name, as an avatar shows it ("Hush Studio" → "HS"). */
+// What a reader sees as one character: an emoji joined from several code points (👩‍🍳, a flag) stays whole. Code
+// points are the fallback where the engine has no Intl.Segmenter.
+function graphemes(text:string):string[]{
+ // The wrist's engine has no Intl at all, so it is only read behind this check.
+ const Segmenter=typeof Intl!=='undefined'?(Intl as unknown as {Segmenter?:new(locale?:string,options?:{granularity:'grapheme'})=>{segment(input:string):Iterable<{segment:string}>}}).Segmenter:undefined;
+ return Segmenter?Array.from(new Segmenter(undefined,{granularity:'grapheme'}).segment(text),(part)=>part.segment):[...text];
+}
+function initialsOf(name:string):string{
+ const first=(word:string)=>graphemes(word)[0]??'';
+ const words=name.trim().split(/\s+/).filter(Boolean);
+ return (words.length>1?`${first(words[0]!)}${first(words[words.length-1]!)}`:first(words[0]??'')).toUpperCase();
+}
+const initial:State={hostedName,businessName:hostedName,businessInitials:initialsOf(hostedName),hasHostedName:!!hostedName,noHostedName:!hostedName,phase:'loading',error:'',notice:'',member:false,roomId:'',principal:'',scope:'',messages:[],draft:'',busy:false,historySource:'members',historyRevision:0,smartChatEmpty:false,transcriptSource:'members',
+  liveState:'unavailable',liveReason:'',realtimeEventCount:0,lastRealtimeEventType:'',liveLabel:'',hasActiveRoom:false,noActiveRoom:true,isGuest:false,notGuest:true,realtimeDiagnostic:'',pendingIntent:null,scrollAnchor:'',scrollSend:0,usedSuggestionIds:[],visitorOptions:null,quickReplies:[],hasQuickReplies:false,noQuickReplies:true,noError:true,noNotice:true,noMessages:true,hasMessages:false,noEmpty:true,notLoading:false,sendDisabled:true,sendEnabled:false,noLive:true,loadingHidden:false,errorText:'',loadFailure:''};
+let currentIdentity:ChatIdentity|null=null;
+let subscriptionId='';
+let initFlight=false;
+let suggestionFlight=false;
+let refreshFlight=false;
+let refreshQueued=false;
+let epoch=0;
+// Acceptance can precede the async action's state commit. Realtime callbacks in
+// that window must already follow this session's identity-scoped Smart Chat.
+let smartChatAcceptedEpoch=-1;
+let statusSeq=0;
+let eventDuringInit=false;
+let statusDuringInit:{state:string;reason:string}|null=null;
+// Read through functions: a plain read after init's own assignment is narrowed by the compiler to its initial value.
+function takeEventDuringInit():boolean{const seen=eventDuringInit;eventDuringInit=false;return seen;}
+function takeStatusDuringInit():{state:string;reason:string}|null{const seen=statusDuringInit;statusDuringInit=null;return seen;}
+let draftRevision=0;
+let historyRevision=0;
+let businessParticipantId='';
+let loadStage:'room_selection'|'history_request'|'history_normalization'|'ai_enrichment'='room_selection';
+let readServiceState:()=>State=()=>shape(initial);
+
+/** Follow the identity-scoped history cursor: the first page need not contain the latest reply.
+ * Refuse an incomplete transcript rather than silently returning another conversation. */
+async function loadSmartChatMessages():Promise<unknown[]>{
+ const messages:unknown[]=[];
+ const seen=new Set<string>();
+ let cursor:string|undefined;
+ const incomplete=()=>Object.assign(new Error('smart_chat_history_incomplete'),{code:'smart_chat_history_incomplete'});
+ for(let page=0;page<20;page++){
+  let response:Awaited<ReturnType<typeof listMessages>>;
+  try{response=await chat.fence(me(),()=>listMessages({cursorPaging:{limit:100,...(cursor?{cursor}:{})}}));}
+  catch(error){
+   if(/member_sign_in_required|MemberAccessChanged|\b401\b/i.test(String(error))||(page>0&&/\b403\b/.test(String(error))))throw Object.assign(new Error('member_sign_in_required'),{code:'smart_chat_history_incomplete'});
+   // Only an explicit unavailable feature permits the legacy fallback. A timeout or
+   // 5xx says nothing about whether a Smart Chat conversation exists.
+   if(!page&&/\b403\b|\b404\b/.test(String(error)))throw error;
+   throw incomplete();
+  }
+  if(!Array.isArray(response?.messages))throw incomplete();
+  messages.push(...response.messages);
+  const paging=response.pagingMetadata;
+  const next=paging?.cursors?.next;
+  if(paging?.hasNext===false||(!paging?.hasNext&&!next))return messages;
+  if(typeof next!=='string'||!next.trim()||seen.has(next))throw incomplete();
+  seen.add(next);cursor=next;
+ }
+ throw incomplete();
+}
+
+/** Submit a displayed quick reply through the AI endpoint; a label counts only while it is still a current option. */
+async function sendBusinessVisitorOption(options:BusinessVisitorOptions|null|undefined,label:string):Promise<boolean>{
+ const request=businessVisitorOptionRequest(options,label,newBusinessSelectionId());
+ if(!request)return false;
+ await chat.fence(me(),()=>streamMessages(request));
+ 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'?businessChatCopy('sending'):intent.delivery==='unconfirmed'?businessChatCopy('unconfirmed'):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,isCard:false,notCard:true,noSuggestions:true,noActions:true,cardTitle:'',cardDetail:'',noCardText:true,dayLabel:'',dayHidden:true,startsDay:false,scrollAnchor:`himi_business_chat.message_${intent.id}`,pending:true,acceptedIntent:intent.delivery==='sent'?intent:undefined};
+}
+function shape(s:State):State{const used=new Set(s.usedSuggestionIds);const messages=s.messages.map(row=>({...row,noSuggestions:s.phase!=='ready'||!(row.suggestions||[]).length,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=s.phase==='ready'&&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:!canSend(s,s.draft),sendEnabled:canSend(s,s.draft),noLive:!s.roomId||s.liveState==='connected'};}
+/** Smart Chat resolves the conversation from the member identity, including the first message.
+ * History must finish loading before Send is offered so delivery has a reliable anchor. */
+function canSend(s:State,draft:string):boolean{return !!s.member&&s.phase==='ready'&&!s.busy&&!!draft.trim()&&!s.pendingIntent;}
+function safeLoadFailure(error:unknown):string{
+ const name=error instanceof Error?error.name:'UnknownError';
+ const code=(error as {code?:unknown}|null)?.code;
+ const safeCode=typeof code==='string'&&/^[a-z0-9_]{1,48}$/i.test(code)?`:${code}`:'';
+ return `${loadStage}:${/^(TypeError|SyntaxError|ProtocolError|Unsupported|Error)$/.test(name)?name:'OtherError'}${safeCode}`;
+}
+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 hasParam(arg:unknown,key:string):boolean{const a=arg as Record<string,unknown>|null;const p=a?.params as Record<string,unknown>|undefined;return typeof a?.[key]==='string'||typeof p?.[key]==='string';}
+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:'';}
+// 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},identity:ChatIdentity,startEpoch:number):Promise<string>{
+ if(startEpoch!==epoch)throw new Error('MemberAccessChanged');
+ const key=`${identity.email}|${identity.scope}|${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(identity,part);
+ if(startEpoch!==epoch)throw new Error('MemberAccessChanged');
+ 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 product is
+// reused for ten minutes and a miss for two, so a refresh never repeats the lookup. Its id opens it in the app.
+/** `id` is the product the link names (same slug) and opens it in the app; the picture may also come from a product of
+ *  the same name, which never stands in for the link's own product. */
+type FoundProduct={url:string;id:string};
+const productImages=new Map<string,FoundProduct&{at:number}>();
+const productImageLookups=new Map<string,Promise<FoundProduct>>();
+const PRODUCT_IMAGE_TTL_MS=10*60*1000;
+const PRODUCT_IMAGE_MISS_TTL_MS=2*60*1000;
+function productImageFor(slug:string,name:string):Promise<FoundProduct>{
+ // 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.id?PRODUCT_IMAGE_TTL_MS:PRODUCT_IMAGE_MISS_TTL_MS))return Promise.resolve({url:hit.url,id:hit.id});
+ const running=productImageLookups.get(key);
+ if(running)return running;
+ // A reset (sign-out, another member or business) bumps `epoch`: a lookup it overtook must not fill the new cache.
+ const startEpoch=epoch;
+ const lookup:Promise<FoundProduct>=(async()=>{
+  let url='';let id='';
+  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);
+   if(bySlug)id=typeof bySlug.id==='string'?bySlug.id:'';
+  }catch{url='';id='';}
+  if(startEpoch===epoch)productImages.set(key,{url,id,at:Date.now()});
+  return {url,id};
+ })().finally(()=>{if(productImageLookups.get(key)===lookup)productImageLookups.delete(key);});
+ productImageLookups.set(key,lookup);
+ return lookup;
+}
+// A bookings service named by a link's slug, cached like a product (a miss for less time). The first history load
+// routes every row at once, so links to the same service share one lookup while it is running.
+const serviceIds=new Map<string,{id:string;at:number}>();
+const serviceIdLookups=new Map<string,Promise<string>>();
+function serviceIdFor(slug:string):Promise<string>{
+ const hit=serviceIds.get(slug);
+ if(hit&&Date.now()-hit.at<(hit.id?PRODUCT_IMAGE_TTL_MS:PRODUCT_IMAGE_MISS_TTL_MS))return Promise.resolve(hit.id);
+ const running=serviceIdLookups.get(slug);
+ if(running)return running;
+ const startEpoch=epoch;
+ const lookup:Promise<string>=(async()=>{
+  let id='';
+  try{
+   const found=(await queryServices({query:{filter:{'mainSlug.name':{$eq:slug}},paging:{limit:1}}})).services??[];
+   id=typeof found[0]?.id==='string'?found[0].id:'';
+  }catch{id='';}
+  if(startEpoch===epoch)serviceIds.set(slug,{id,at:Date.now()});
+  return id;
+ })().finally(()=>{if(serviceIdLookups.get(slug)===lookup)serviceIdLookups.delete(slug);});
+ serviceIdLookups.set(slug,lookup);
+ return lookup;
+}
+/** A button whose link the app has a screen for opens that screen; a link it cannot place stays a web link. */
+// This app's own site and the screens it has for products and services, as the screen passes them to `init`: only
+// its own site's pages, and only to a screen the app registers, are opened in the app.
+let ownSiteUrl='';
+const ownScreens={product:'',service:''};
+async function routeAction(action:BusinessArticleAction,productName:string):Promise<BusinessArticleAction>{
+ const route=action.routable?businessInAppRoute(action.url,ownSiteUrl):undefined;
+ const screenId=route?ownScreens[route.kind]:'';
+ if(!route||!screenId)return action;
+ const id=route.kind==='product'?(await productImageFor(route.slug,productName)).id:await serviceIdFor(route.slug);
+ return id?{...action,screenId,targetId:id,inApp:true,web:false}:action;
+}
+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','isCard','notCard','noSuggestions','noActions','cardTitle','cardDetail','noCardText','dayLabel','dayHidden','startsDay','scrollAnchor') as unknown as BusinessMessageRow;
+}
+async function presentMessages(existing:MessageRow[],raw:unknown[],memberId?:string,participantId=businessParticipantId||'smart-chat:visitor'):Promise<BusinessMessageRow[]>{
+ const identity=me();const presentationEpoch=epoch;
+ 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'&&part.kind!=='file'&&part.kind!=='audio'&&part.kind!=='video')return part;
+   if(part.mediaProvider==='WixMediaPrivate'&&part.mediaId){
+    try{return {...part,url:await privateAttachmentUrl(part,identity,presentationEpoch)};}catch{return {...part,url:''};}
+   }
+   return part;
+  }));
+  return {...row,parts};
+ }));
+ const presented=presentBusinessMessages(prepared as unknown as Parameters<typeof presentBusinessMessages>[0],raw,participantId) as unknown as Record<string,unknown>[];
+ await Promise.all(presented.map(async row=>{
+  const slug=typeof row.productSlug==='string'?row.productSlug:'';
+  const name=String(row.productName||'');
+  if(slug&&!row.imageUrl){
+   const {url}=await productImageFor(slug,name);
+   if(url)Object.assign(row,{imageUrl:url,noImage:false,imageDescription:name||businessChatCopy('productImage')});
+  }
+  row.articleActions=await Promise.all((row.articleActions as BusinessArticleAction[]).map(action=>routeAction(action,name)));
+ }));
+ return presented.map(slimRow);
+}
+function me():ChatIdentity{
+ const identity=currentIdentity;
+ if(!identity?.authenticated)throw new Error('member_sign_in_required');
+ return identity;
+}
+async function getCurrentMember():Promise<ChatIdentity>{return chat.chatIdentity();}
+async function resolveExistingBusinessRoom(startEpoch:number,businessName:string):Promise<{id:string;participantId:string}|undefined>{
+ const page=await chat.listRooms(me());
+ if(startEpoch!==epoch)throw new Error('MemberAccessChanged');
+ const room=selectExistingBusinessRoom(page.items,businessName,true);
+ // An incomplete room list cannot prove there is no conversation.
+ if(page.more)throw new Error('business_room_list_incomplete');
+ return room;
+}
+function safeError(error:unknown,operation:'load'|'send'|'init'):string{
+ const text=String((error as Error)?.message||error);
+ if(/member_sign_in_required|MemberAccessChanged|\b401\b|\b403\b/i.test(text))return businessChatCopy('sessionChanged');
+ if(/approved first-party|webwix_owner_only|chat_setup_scope_unavailable/i.test(text))return businessChatCopy('hostUnavailable');
+ return operation==='send'?businessChatCopy('sendFailed'):
+  operation==='init'?businessChatCopy('openFailed'):businessChatCopy('loadFailed');
+}
+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{
+ attachmentUrls.clear();productImages.clear();productImageLookups.clear();serviceIds.clear();serviceIdLookups.clear();currentIdentity=null;businessParticipantId='';epoch++;void endSubscription();
+ return shape({...initial,phase,error:phase==='guest'?businessChatCopy('signInPrompt'):s.error});
+}
+let refreshTail:Promise<unknown>=Promise.resolve();
+/** One refresh runs at a time. A caller that needs the data (init, a send) waits for the one in flight and
+ *  then runs its own; a realtime event only asks the running one to go again, and gets nothing back. */
+async function loadHistory(s:State,wait=false):Promise<State|undefined>{
+ while(refreshFlight){
+  if(!wait){refreshQueued=true;return withLiveDraft(s);}
+  await refreshTail.catch(()=>{});
+ }
+ const run=refreshHistory(s);
+ refreshTail=run;
+ return run;
+}
+async function refreshHistory(s:State):Promise<State|undefined>{
+ refreshFlight=true;const startEpoch=epoch;const roomId=s.roomId;const principal=s.principal;const participantId=businessParticipantId||'smart-chat:visitor';const startDraftRevision=draftRevision;
+ // A refresh that outlived its member or session says nothing: returning a state would overwrite the new one.
+ const stale=()=>startEpoch!==epoch||(currentIdentity?.userId||currentIdentity?.email)!==principal;
+ try{
+  loadStage='history_request';
+  // The Members room and Smart Chat may be different conversations. Read Smart Chat's
+  // persisted transcript, not only its quick replies; retain Members history for sites without it.
+  const [memberRead,aiRead]=await Promise.all([
+   (roomId?chat.messagesPage(me(),roomId):Promise.resolve([])).then(page=>({page,error:null})).catch(error=>({page:[],error})),
+   loadSmartChatMessages().then(messages=>({messages,error:null})).catch(error=>({messages:[],error})),
+  ]);
+  if(stale())return undefined;
+  // Once this screen has followed Smart Chat, an unavailable read must not switch it back
+  // to the unrelated Members thread.
+  const liveSource=readServiceState();
+  const followedSmart=smartChatAcceptedEpoch===startEpoch||s.historySource==='smart-chat'||(liveSource.principal===principal&&liveSource.scope===s.scope&&liveSource.historySource==='smart-chat');
+  if(aiRead.error&&(!roomId||followedSmart||aiRead.error.code==='smart_chat_history_incomplete'))throw aiRead.error;
+  const smart=smartChatHistory(aiRead.messages,memberRead.page,participantId);
+  const useSmart=!!smart||followedSmart;
+  if(!useSmart&&memberRead.error)throw memberRead.error;
+  const page=useSmart?smart?.messages??[]:memberRead.page;
+  const historySource=useSmart?'smart-chat' as const:'members' as const;
+  const visitorOptions=businessVisitorOptionsFromAiMessages(aiRead.messages);
+  loadStage='history_normalization';
+  // Presented from the page alone: a row kept from an earlier page would be re-presented without the
+  // metadata that only the page carries (sender, avatar, AI badge, article buttons).
+  const messages=await presentMessages([],page,currentIdentity?.userId||undefined,participantId);
+  if(stale())return undefined;
+  // Read the live state last: what other actions changed while this one awaited is theirs to keep.
+  const latest=readServiceState();
+  // Resolving this member's first room is the same conversation, not a room switch.
+  const same=latest.principal===principal&&latest.scope===s.scope&&(latest.roomId===roomId||(!latest.roomId||!roomId));
+  // What was typed while this ran is kept even on the first load, when the live state is still empty.
+  const liveDraft=draftRevision!==startDraftRevision?latest.draft:s.draft;
+  const base:State=same?withLiveFields({...s,roomId:latest.roomId||roomId},latest,liveDraft):{...s,draft:liveDraft};
+  const intentObserved=intentObservedIn(messages,base.pendingIntent,historySource);
+  const draft=intentObserved&&base.pendingIntent&&base.draft.trim()===base.pendingIntent.text?'':base.draft;
+  // A send the server has not returned yet stays on screen until history does. Seeing it in history only replaces the
+  // placeholder: a send still in flight stays pending until its own request settles it, so its outcome is never lost.
+  // An unconfirmed one (its request is over) no longer holds Send once its words show up; its notice stays.
+  const shown=!intentObserved&&base.pendingIntent?[...messages,pendingRow(base.pendingIntent)]:messages;
+  const pendingIntent=intentObserved&&base.pendingIntent?.delivery==='unconfirmed'?null:base.pendingIntent;
+  const loaded:State={...base,historyRevision:++historyRevision,historySource,transcriptSource:historySource,smartChatEmpty:!aiRead.error&&aiRead.messages.length===0,messages:shown,pendingIntent,visitorOptions,quickReplies:businessVisitorOptionSuggestions(visitorOptions),draft,phase:'ready',error:'',loadFailure:''};
+  return shape(same?withAcceptedRows(loaded,latest):loaded);
+ }catch(error){
+  const wrapped=error instanceof Error?error:new Error('load_failed');
+  Object.assign(wrapped,{businessLoadFailure:safeLoadFailure(error)});
+  throw wrapped;
+ }finally{refreshFlight=false;}
+}
+/** What other actions own and may have changed while this one awaited, taken from the live state. A state
+ *  built from a snapshot taken before an await must carry these forward or it rolls them back. */
+function withLiveFields(st:State,latest:State,draft:string):State{
+ // The pending intent is always the live one: a send settled meanwhile (null now) must not come back from a snapshot.
+ return {...st,draft,pendingIntent:latest.pendingIntent,
+  usedSuggestionIds:[...new Set([...st.usedSuggestionIds,...latest.usedSuggestionIds])],
+  liveState:latest.liveState,liveReason:latest.liveReason,realtimeEventCount:Math.max(st.realtimeEventCount,latest.realtimeEventCount),lastRealtimeEventType:latest.lastRealtimeEventType,
+  scrollSend:Math.max(st.scrollSend,latest.scrollSend)};
+}
+/** A successful empty pre-send read anchors accepted Smart Chat rows, never an
+ * older Members payload retained after a failed read. Keep both contexts intact. */
+function intentObservedIn(messages:BusinessMessageRow[],intent:BusinessChatIntent|null,source:State['transcriptSource']):boolean{
+ return pendingIntentWasObserved(messages,source==='smart-chat'&&intent?.delivery==='sent'&&intent.smartChatFromStart
+  ?{...intent,afterId:undefined,fromStart:true}:intent);
+}
+/** Keep confirmed local deliveries independently of in-flight intent and history revision.
+ * Reconcile by the existing stored-id/anchor contract, never by ownership or text alone. */
+function withAcceptedRows(st:State,latest:State):State{
+ let messages=st.messages;
+ for(const row of [...st.messages,...latest.messages]){
+  const intent=row.acceptedIntent;
+  if(!intent)continue;
+  if(intentObservedIn(messages,intent,st.transcriptSource))messages=messages.filter(candidate=>!(candidate.id===intent.id&&candidate.pending));
+  else if(!messages.some(candidate=>candidate.id===intent.id))messages=[...messages,row];
+ }
+ return {...st,messages,historySource:smartChatAcceptedEpoch===epoch?'smart-chat':st.historySource};
+}
+function withLiveDraft(st:State):State{
+ const latest=readServiceState();
+ const same=latest.principal===st.principal&&latest.scope===st.scope&&(latest.roomId===st.roomId||!latest.roomId||!st.roomId);
+ // Failed reads also finish from old snapshots: keep a newer authoritative
+ // transcript and the member's first resolved room, just as successful reads do.
+ const newer=same&&latest.historyRevision>st.historyRevision;
+ const base=newer?{...st,historyRevision:latest.historyRevision,historySource:latest.historySource,transcriptSource:latest.transcriptSource,smartChatEmpty:latest.smartChatEmpty,messages:latest.messages,visitorOptions:latest.visitorOptions,quickReplies:latest.quickReplies}:st;
+ const live=withLiveFields({...base,roomId:st.roomId||(same?latest.roomId:'')},latest,latest.draft);
+ const merged=same?withAcceptedRows(live,latest):live;
+ // A later send owns both its intent and its visible row, even when this
+ // snapshot has a newer history revision that predates that send.
+ const intent=same?latest.pendingIntent:null;
+ return intent&&!intentObservedIn(merged.messages,intent,merged.transcriptSource)&&!merged.messages.some(row=>row.id===intent.id)
+  ?{...merged,messages:[...merged.messages,pendingRow(intent)]}:merged;
+}
+type SendResult={id:string;outcome:'sent'|'rejected'|'unconfirmed'|'signed_out';draft:string;storedId?:string;error?:unknown};
+/** Posts one message and reports how it ended; never throws. The caller already showed the message. The call lasts
+ *  until the AI has answered: history usually shows the stored copy first, which replaces the placeholder, while Send
+ *  stays held until this settles (the site's widget also waits for the answer). */
+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
+  result.storedId=await chat.sendMessage(me(),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'};
+ }
+ 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:{
+  // A host runs `load` when the screen shows again, also when a sign-in modal over it closes.
+  // Only a guest loads again: a member's chat is already live. No args: init keeps the site
+  // and name the screen gave first.
+  load:async (s):Promise<State|undefined>=>s.phase==='guest'?svc.init():undefined,
+  init:async(s,a)=>{
+   // Keep $t: keys as values: renderers translate bound worker copy in the active locale.
+   const copy=Object.fromEntries(Object.keys(BUSINESS_CHAT_COPY).map(key=>[`businessChat.${key}`,param(a,`businessChat.${key}`)]).filter(([,text])=>!!text));
+   if(Object.keys(copy).length)stashCopy({copy:JSON.stringify(copy)});
+   if(initFlight)return s;initFlight=true;eventDuringInit=false;statusDuringInit=null;
+   // A retry passes no site: the one the screen gave first stays. A site the screen passes, even an empty one (a
+   // business with no site), replaces it, so an earlier business's links are not routed to this one's screens.
+   if(hasParam(a,'siteUrl')){ownSiteUrl=param(a,'siteUrl');ownScreens.product=param(a,'productScreen');ownScreens.service=param(a,'serviceScreen');}
+   // A retry passes no name: the one the screen gave first stays. Under `displayName`, a copy key, so a template
+   // sweep that renames the business renames it here too and the initials follow.
+   const signedBy=s.hostedName||param(a,'displayName')||s.businessName;
+   const signed=(st:State):State=>({...st,businessName:signedBy,businessInitials:initialsOf(signedBy)});
+   s=signed(s);
+   const oldPrincipal=s.principal;
+   const initRevision=draftRevision;
+   // Text typed at any point of the load, subscribe step included, outlives the snapshot this started from. So does the
+   // live pending send, but only the same member's and only one still in flight: reopening is how a member checks an
+   // unconfirmed send (its notice says so), so it does not carry over and cannot hold Send for good.
+   // A reset for another member or scope (clearPrivate) ends the old send's settling, so nothing of it is kept.
+   let reset=false;
+   // Only an unconfirmed send the member reopened the chat to check is dropped. A send still in flight when this load
+   // began that settles during it (rejected, or turned unconfirmed) keeps what its settling told the member: its
+   // notice, its error and the draft it gave back.
+   const checkedId=s.pendingIntent?.delivery==='unconfirmed'?s.pendingIntent.id:'';
+   const inFlightId=s.pendingIntent&&s.pendingIntent.delivery!=='unconfirmed'?s.pendingIntent.id:'';
+   const keepTyped=(st:State):State=>{
+    const live=readServiceState();
+    const sameMember=!reset&&live.principal===st.principal&&live.scope===st.scope&&(live.roomId===st.roomId||!live.roomId||!st.roomId);
+    const own=sameMember?live.pendingIntent:null;
+    const intent=own&&!(own.delivery==='unconfirmed'&&own.id===checkedId)?own:null;
+    const settledMeanwhile=sameMember&&!!inFlightId&&!(live.pendingIntent?.id===inFlightId&&live.pendingIntent.delivery!=='unconfirmed');
+    // Accepted local rows can outlive pendingIntent while history is unavailable.
+    // Keep only rows the live session still owns; checked unconfirmed/rejected rows drop.
+    const retained=new Set(sameMember?live.messages.filter(row=>row.id!==checkedId).map(row=>row.id):[]);
+    // Equal history revisions share an authoritative read. Local send settling
+    // may still have advanced its rows/source while this reopen awaited rooms.
+    const history=sameMember&&live.historyRevision>=st.historyRevision
+     ?{...st,historyRevision:live.historyRevision,historySource:live.historySource,transcriptSource:live.transcriptSource,smartChatEmpty:live.smartChatEmpty,messages:live.messages,visitorOptions:live.visitorOptions,quickReplies:live.quickReplies}:st;
+    return {...history,pendingIntent:intent,historySource:sameMember&&live.historySource==='smart-chat'?'smart-chat':history.historySource,
+     messages:history.messages.filter(row=>!row.pending||row.id===intent?.id||retained.has(row.id)),
+     ...(settledMeanwhile?{notice:live.notice,error:live.error,draft:live.draft}:draftRevision!==initRevision?{draft:live.draft}:{})};
+   };
+   let myEpoch=epoch;
+   let openedStatus:{state:string;reason:string}|undefined;
+   const withOpenedStatus=(st:State):State=>{
+    const status=takeStatusDuringInit()??openedStatus;
+    return status?{...st,liveState:status.state,liveReason:status.reason}:st;
+   };
+   try{
+    loadStage='room_selection';
+    const identity=await getCurrentMember();
+    if(myEpoch!==epoch)return undefined;
+    if(!identity.authenticated)throw new Error('member_sign_in_required');
+    if(oldPrincipal&&(oldPrincipal!==(identity.userId||identity.email)||s.scope!==identity.scope)){s=signed(clearPrivate(s,'guest'));myEpoch=epoch;reset=true;}
+    currentIdentity=identity;
+    s=shape({...s,phase:'loading',member:true,principal:identity.userId||identity.email,scope:identity.scope,error:'',notice:''});
+    const existingRoom=await resolveExistingBusinessRoom(myEpoch,signedBy);
+    if(myEpoch!==epoch)return undefined;
+    const live=readServiceState();
+    const promoted=live.principal===s.principal&&live.scope===s.scope?live.roomId:'';
+    businessParticipantId=existingRoom?.participantId??(promoted?businessParticipantId:'');
+    s=shape({...s,roomId:existingRoom?.id??promoted});
+    // Subscribe before reading history, so anything that lands after the read arrives as a realtime event.
+    if(!subscriptionId){try{const result=await subscribeRealtime({onEvent:'businessChat.onEvent',onStatus:'businessChat.onStatus'});if(myEpoch!==epoch){if(result.subscriptionId)await unsubscribeRealtime({subscriptionId:result.subscriptionId});return undefined;}subscriptionId=result.subscriptionId;const status=subscriptionId?await getRealtimeStatus({subscriptionId}):result;s=shape({...s,liveState:status.state,liveReason:status.reason||''});}catch{s=shape({...s,liveState:'unavailable',liveReason:'runtime_unavailable'});}openedStatus={state:s.liveState,reason:s.liveReason};}
+    let loaded=await loadLatest(s,true);
+    if(!loaded||myEpoch!==epoch)return undefined;
+    // Until this returns the stored state has no room, so events are ignored; one that arrived meanwhile asks for another pass.
+    for(let pass=0;pass<3&&takeEventDuringInit();pass++){const again=await loadLatest(loaded,true);if(!again||myEpoch!==epoch)return undefined;loaded=again;}
+    return shape(keepTyped(withOpenedStatus(loaded)));
+   }catch(error){
+    if(myEpoch!==epoch)return undefined;
+    const sessionLost=/member_sign_in_required|MemberAccessChanged|\b401\b|\b403\b/i.test(String(error));
+    const loadFailure=typeof (error as {businessLoadFailure?:unknown})?.businessLoadFailure==='string'?(error as {businessLoadFailure:string}).businessLoadFailure:safeLoadFailure(error);
+    if(sessionLost)return clearPrivate(s,'guest');
+    const live=readServiceState();
+    // A failed reopen may finish after the first send promoted this member's
+    // room. Keep its accepted transcript, without importing another session.
+    const base=!reset&&live.principal===s.principal&&live.scope===s.scope?withLiveDraft(s):s;
+    return shape({...withOpenedStatus(keepTyped(base)),phase:'error',member:!!currentIdentity?.authenticated,error:safeError(error,'init'),loadFailure});
+   }finally{initFlight=false;}
+  },
+  // 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=canSend(s,draft);return {...s,draft,sendEnabled,sendDisabled:!sendEnabled};},
+  // 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();
+   // One send at a time: the pending intent, set right here, holds the next one until this one is settled or seen.
+   if(!text||!canSend(s,text))return s;
+   // 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??'';
+   const pending={...newBusinessChatIntent(text,s.roomId,s.principal),senderName:ownName,...sendAnchor(s.messages,text,s.phase==='ready'),smartChatFromStart:s.transcriptSource==='members'&&s.smartChatEmpty};
+   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:businessChatCopy('rejected')});
+   }
+   // History cannot tell this send from the same words written elsewhere (the website), so an indeterminate failure is
+   // never reported as sent. If matching words are already there it does not hold Send, and the notice still asks to check.
+   if(result.outcome==='unconfirmed'){
+    const unconfirmed={...pending,delivery:'unconfirmed' as const};
+    const seen=intentObservedIn(s.messages,pending,s.transcriptSource);
+    return shape({...s,pendingIntent:seen?null:unconfirmed,messages:replaceRow(unconfirmed),error:safeError(result.error,'send'),notice:businessChatCopy('checkDelivery')});
+   }
+   const sent={...pending,storedId:result.storedId,delivery:'sent' as const};
+   // Every typed send uses Smart Chat, even when a Members room already exists.
+   smartChatAcceptedEpoch=epoch;
+   const accepted=shape({...s,historySource:'smart-chat',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.
+   // History that already holds the message under the server's id needs no placeholder for it. Only this send's intent
+   // is cleared: a newer one the live state carried in is that send's to settle.
+   const ownIntent=(st:State)=>st.pendingIntent&&st.pendingIntent.id!==sent.id?st.pendingIntent:null;
+   const settled=(st:State):State=>intentObservedIn(st.messages,sent,st.transcriptSource)?shape({...st,pendingIntent:ownIntent(st),notice:'',messages:st.messages.filter(row=>!(row.id===sent.id&&row.pending))}):
+    shape({...st,pendingIntent:ownIntent(st),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)]});
+   // The stream finishes after the AI has persisted its answer. Reload even while connected:
+   // the Members-room subscription may never see the separate Smart Chat room's event.
+   // An existing-room refresh owns the next read. A first acceptance must wait for
+   // its own read/discovery pass so an overlapping refresh cannot skip room promotion.
+   if(refreshFlight&&accepted.roomId){refreshQueued=true;return settled(accepted);}
+   let resolved=accepted;
+   const latestResolved=():State=>{
+    const latest=readServiceState();
+    // Another refresh can finish while room discovery awaits. Its authoritative
+    // transcript/options win; draft/status-only updates cannot replace this read.
+    const same=latest.principal===resolved.principal&&latest.scope===resolved.scope;
+    const newer=same&&latest.historyRevision>resolved.historyRevision;
+    const transcript=newer?{...resolved,historyRevision:latest.historyRevision,historySource:latest.historySource,transcriptSource:latest.transcriptSource,smartChatEmpty:latest.smartChatEmpty,messages:latest.messages,visitorOptions:latest.visitorOptions,quickReplies:latest.quickReplies}:resolved;
+    return withLiveDraft({...transcript,roomId:resolved.roomId||(same?latest.roomId:'')});
+   };
+   try{
+    // Smart Chat's identity-scoped transcript is independent of Members-room
+    // discovery. Keep its persisted reply/options even when discovery fails.
+    const loaded=await loadLatest(resolved,true);
+    if(!loaded)return undefined;
+    resolved=loaded;
+    resolved=latestResolved();
+    // Creating a conversation is a consequence of the accepted send, never of opening chat.
+    if(!resolved.roomId){
+     const room=await resolveExistingBusinessRoom(sendEpoch,s.businessName);
+     if(sendEpoch!==epoch)return undefined;
+     const latest=latestResolved();
+     if(room&&!latest.roomId)businessParticipantId=room.participantId;
+     resolved={...latest,roomId:latest.roomId||room?.id||'',historySource:'smart-chat'};
+    }
+    return settled(resolved);
+   }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(accepted,'guest');
+    return settled(latestResolved());
+   }
+  },
+  sendSuggestion:async(s,a)=>{
+   if(suggestionFlight||!s.member||s.phase!=='ready'||!!s.pendingIntent)return s;
+   const id=param(a,'id');
+   if(!id||s.usedSuggestionIds.includes(id))return s;
+   const rows=[{suggestions:s.quickReplies} as {suggestions?:BusinessSuggestion[]},...s.messages];
+   if(!s.roomId&&findBusinessSuggestion(rows,id)?.kind!=='visitor_option')return s;
+   const options=s.visitorOptions;
+   const intent=newBusinessChatIntent('suggestion',s.roomId,s.principal);
+   const sendEpoch=epoch;
+   suggestionFlight=true;
+   s=shape({...s,usedSuggestionIds:[...s.usedSuggestionIds,id],error:'',notice:''});
+   let accepted:State|undefined;
+   const keptAccepted=():State=>{
+    const latest=withLiveDraft(accepted!);
+    return shape({...latest,historySource:accepted!.historySource==='smart-chat'?'smart-chat':latest.historySource,error:'',notice:businessChatCopy('suggestionSent')});
+   };
+   try{
+    const sent=await dispatchBusinessSuggestion(rows,id,{member:s.member,roomId:s.roomId,principal:s.principal,currentPrincipal:currentIdentity?.userId||currentIdentity?.email||'',scope:s.scope,currentScope:currentIdentity?.scope||''},suggestion=>suggestion.kind==='visitor_option'
+      ? sendBusinessVisitorOption(options,suggestion.label)
+      : chat.sendButton(me(),s.roomId,{id:intent.id,text:suggestion.label,appId:suggestion.appId!,interactionId:suggestion.interactionId!}));
+    if(sendEpoch!==epoch)return undefined;
+    if(!sent)return withLiveDraft(s);
+    const latest=readServiceState();
+    if(latest.principal!==s.principal||latest.scope!==s.scope||(latest.roomId!==s.roomId&&(!!s.roomId||findBusinessSuggestion(rows,id)?.kind!=='visitor_option')))return undefined;
+    if(findBusinessSuggestion(rows,id)?.kind==='visitor_option')smartChatAcceptedEpoch=epoch;
+    accepted=shape({...latest,historySource:smartChatAcceptedEpoch===epoch?'smart-chat':latest.historySource,usedSuggestionIds:[...new Set([...s.usedSuggestionIds,...latest.usedSuggestionIds])],scrollSend:latest.scrollSend+1,error:'',notice:businessChatCopy('suggestionSent')});
+    const loaded=await loadLatest(keptAccepted(),true);
+    if(!loaded||sendEpoch!==epoch)return undefined;
+    accepted=loaded;
+    if(!accepted.roomId){
+     const room=await resolveExistingBusinessRoom(sendEpoch,s.businessName);
+     if(sendEpoch!==epoch)return undefined;
+     const current=keptAccepted();
+     if(room&&!current.roomId)businessParticipantId=room.participantId;
+     accepted={...current,roomId:current.roomId||room?.id||'',historySource:'smart-chat'};
+    }
+    return keptAccepted();
+   }catch(error){
+    if(sendEpoch!==epoch)return undefined;
+    if(/member_sign_in_required|MemberAccessChanged|\b401\b|\b403\b/i.test(String(error)))return clearPrivate(s,'guest');
+    const latest=readServiceState();
+    if(latest.principal!==s.principal||latest.scope!==s.scope)return undefined;
+    if(accepted)return keptAccepted();
+    s=shape({...latest,usedSuggestionIds:[...new Set([...s.usedSuggestionIds,...latest.usedSuggestionIds])]});
+    const definitive=businessChatSendRejected(error);
+    return shape({...withLiveDraft(s),usedSuggestionIds:definitive?s.usedSuggestionIds.filter(value=>value!==id):s.usedSuggestionIds,error:safeError(error,'send'),notice:definitive?businessChatCopy('suggestionRejected'):businessChatCopy('suggestionUnconfirmed')});
+   }finally{suggestionFlight=false;}
+  },
+  onEvent:async(s,a)=>{
+   if(initFlight){eventDuringInit=true;return undefined;}
+   const startEpoch=epoch;
+   const envelope=a as RealtimeEventEnvelope|undefined;
+   const eventType=typeof envelope?.event?.type==='string'?envelope.event.type:'';
+   s=shape({...s,historySource:smartChatAcceptedEpoch===epoch?'smart-chat':s.historySource,realtimeEventCount:s.realtimeEventCount+1,lastRealtimeEventType:eventType});
+   if(!currentIdentity||!shouldRefreshBusinessHistory(envelope,s.roomId,{member:s.member,principal:s.principal,currentPrincipal:currentIdentity.userId||currentIdentity.email,scope:s.scope,currentScope:currentIdentity.scope},s.historySource==='smart-chat'))return s;
+   if(refreshFlight){refreshQueued=true;return withLiveDraft(s);}
+   try{return await loadLatest(s);}catch(error){
+    if(startEpoch!==epoch)return undefined;
+    return /member_sign_in_required|MemberAccessChanged|\b401\b|\b403\b/i.test(String(error))?clearPrivate(s,'guest'):shape({...withLiveDraft(s),error:safeError(error,'load'),loadFailure:typeof (error as {businessLoadFailure?:unknown})?.businessLoadFailure==='string'?(error as {businessLoadFailure:string}).businessLoadFailure:safeLoadFailure(error)});
+   }
+  },
+  onStatus:async(s,a)=>{
+   const startEpoch=epoch;const mySeq=++statusSeq;
+   const status=a as RealtimeStatus|undefined;
+   const liveState=status?.state||'unavailable';
+   // While init is opening, the stored state has no room yet: remember the status and let init apply it.
+   if(initFlight){statusDuringInit={state:liveState,reason:liveState==='connected'?'':status?.reason||''};return undefined;}
+   s={...s,historySource:smartChatAcceptedEpoch===epoch?'smart-chat':s.historySource};
+   let next=shape({...s,liveState,liveReason:liveState==='connected'?'':status?.reason||''});
+   if(liveState!=='connected'||s.liveState==='connected'||!s.member||(!s.roomId&&s.historySource!=='smart-chat')||!currentIdentity||s.principal!==(currentIdentity.userId||currentIdentity.email)||s.scope!==currentIdentity.scope)return next;
+   try{
+    const loaded=await loadLatest(next);
+    if(!loaded)return undefined;
+    // A newer status applied while the refresh ran wins over the one this handler started with.
+    const live=readServiceState();
+    const newer=statusSeq!==mySeq;
+    return shape({...loaded,liveState:newer?live.liveState:liveState,liveReason:newer?live.liveReason:(liveState==='connected'?'':status?.reason||''),error:''});
+   }
+   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++;attachmentUrls.clear();productImages.clear();productImageLookups.clear();serviceIds.clear();serviceIdLookups.clear();currentIdentity=null;businessParticipantId='';await endSubscription();return shape({...initial,phase:'guest'});},
+ }
+});
+readServiceState=()=>svc.getState();
+async function loadLatest(s:State,wait=false):Promise<State|undefined>{
+ // A caller that does not need the data asks the running refresh to go again and keeps its own change
+ // (a status, an event count): returning nothing would drop it.
+ if(!wait&&refreshFlight){refreshQueued=true;return withLiveDraft(s);}
+ let next=await loadHistory(s,wait);
+ // Events that arrived during a refresh ask for another pass, a few at most.
+ for(let pass=0;next&&refreshQueued&&pass<3;pass++){
+  refreshQueued=false;
+  next=await loadHistory(next,true);
+ }
+ if(!next)refreshQueued=false;
+ return next;
+}
+export { svc };