@wix/himalaya-cli 0.1574.0 → 0.1575.0

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

@@ -1,10 +1,12 @@
+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, businessRealtimeStatusLabel, businessVisitorOptionSuggestions, presentBusinessMessages, selectExistingBusinessRoom, shouldRefreshBusinessHistory, type BusinessSuggestion, type BusinessVisitorOptions, businessVisitorOptionRequest, businessVisitorOptionsFromAiMessages, newBusinessSelectionId} from '../_shared/business-chat-presenter.js';
+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';
@@ -20,11 +22,15 @@ type BusinessMessageRow = Pick<MessageRow,'id'|'sender'|'when'|'createdDate'|'mi
  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';
+  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;
@@ -47,7 +53,7 @@ function initialsOf(name:string):string{
  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',
+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='';
@@ -56,6 +62,9 @@ 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;
@@ -63,6 +72,7 @@ let statusDuringInit:{state:string;reason:string}|null=null;
 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);
@@ -106,16 +116,16 @@ function liveDescription(state:string,reason:string):string{return businessRealt
 /** 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);
+ 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};
+  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,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,
+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'};}
-/** Send is offered only once the room's history has loaded: a send needs it as its anchor, the Smart Chat send does
- *  not let the app name the stored message, and history is how the app finds it. */
-function canSend(s:State,draft:string):boolean{return !!s.member&&!!s.roomId&&s.phase==='ready'&&!s.busy&&!!draft.trim()&&!s.pendingIntent;}
+/** 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;
@@ -128,11 +138,13 @@ function param(arg:unknown,key:string):string{const a=arg as Record<string,unkno
 // 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??''}`;
+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(me(),part);
+ 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;
 }
@@ -216,25 +228,26 @@ 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):Promise<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)};}catch{return {...part,url:''};}
+    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,businessParticipantId) as unknown as Record<string,unknown>[];
+ 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||'Product image'});
+   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)));
  }));
@@ -246,31 +259,30 @@ function me():ChatIdentity{
  return identity;
 }
 async function getCurrentMember():Promise<ChatIdentity>{return chat.chatIdentity();}
-async function resolveExistingBusinessRoom(startEpoch:number,businessName:string):Promise<{id:string;participantId:string}>{
- businessParticipantId='';
+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);
- if(!room)throw new Error('existing_business_conversation_unavailable');
+ 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 'Your member session changed. Sign in again to continue.';
- if(/approved first-party|webwix_owner_only|chat_setup_scope_unavailable/i.test(text))return 'This app host cannot reach the inbox yet.';
- return operation==='send'?'Message delivery could not be confirmed. Check the conversation before trying again.':
-  operation==='init'?'Couldn’t open the conversation. Try again.':'Couldn’t load the conversation. Try again.';
+ 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'?'Sign in to send a message.':s.error});
+ 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>{
- if(!s.roomId)return s;
  while(refreshFlight){
   if(!wait){refreshQueued=true;return withLiveDraft(s);}
   await refreshTail.catch(()=>{});
@@ -280,7 +292,7 @@ async function loadHistory(s:State,wait=false):Promise<State|undefined>{
  return run;
 }
 async function refreshHistory(s:State):Promise<State|undefined>{
- refreshFlight=true;const startEpoch=epoch;const roomId=s.roomId;const principal=s.principal;const startDraftRevision=draftRevision;
+ 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{
@@ -288,15 +300,17 @@ async function refreshHistory(s:State):Promise<State|undefined>{
   // 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([
-   chat.messagesPage(me(),roomId).then(page=>({page,error:null})).catch(error=>({page:[],error})),
+   (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.
-  if(aiRead.error&&(s.historySource==='smart-chat'||aiRead.error.code==='smart_chat_history_incomplete'))throw aiRead.error;
-  const smart=smartChatHistory(aiRead.messages,memberRead.page,businessParticipantId);
-  const useSmart=!!smart||s.historySource==='smart-chat';
+  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;
@@ -304,22 +318,24 @@ async function refreshHistory(s:State):Promise<State|undefined>{
   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);
+  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();
-  const same=latest.roomId===roomId&&latest.principal===principal;
+  // 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,latest,liveDraft):{...s,draft:liveDraft};
-  const intentObserved=pendingIntentWasObserved(messages,base.pendingIntent);
+  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;
-  return shape({...base,historySource,messages:shown,pendingIntent,visitorOptions,quickReplies:businessVisitorOptionSuggestions(visitorOptions),draft,phase:'ready',error:'',loadFailure:''});
+  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)});
@@ -335,7 +351,39 @@ function withLiveFields(st:State,latest:State,draft:string):State{
   liveState:latest.liveState,liveReason:latest.liveReason,realtimeEventCount:Math.max(st.realtimeEventCount,latest.realtimeEventCount),lastRealtimeEventType:latest.lastRealtimeEventType,
   scrollSend:Math.max(st.scrollSend,latest.scrollSend)};
 }
-function withLiveDraft(st:State):State{const latest=readServiceState();return withLiveFields(st,latest,latest.draft);}
+/** 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
@@ -360,6 +408,9 @@ const svc=defineService<State,Record<string,(s:State,a?:unknown)=>State|undefine
   // 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.
@@ -383,14 +434,27 @@ const svc=defineService<State,Record<string,(s:State,a?:unknown)=>State|undefine
    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;
+    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');
-    return {...st,pendingIntent:intent,messages:st.messages.filter(row=>!row.pending||row.id===intent?.id),
+    // 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();
@@ -401,20 +465,27 @@ const svc=defineService<State,Record<string,(s:State,a?:unknown)=>State|undefine
     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;
-    businessParticipantId=existingRoom.participantId;
-    s=shape({...s,roomId:existingRoom.id});
+    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'});}}
+    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;}
-    const opened=takeStatusDuringInit();
-    return shape(keepTyped(opened?{...loaded,liveState:opened.state,liveReason:opened.reason}:loaded));
+    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);
-    return sessionLost?clearPrivate(s,'guest'):shape(keepTyped({...s,phase:'error',member:!!currentIdentity?.authenticated,error:safeError(error,'init'),loadFailure}));
+    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.
@@ -427,7 +498,7 @@ const svc=defineService<State,Record<string,(s:State,a?:unknown)=>State|undefine
    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')};
+   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});
@@ -439,47 +510,81 @@ const svc=defineService<State,Record<string,(s:State,a?:unknown)=>State|undefine
    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.'});
+    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=pendingIntentWasObserved(s.messages,pending);
-    return shape({...s,pendingIntent:seen?null:unconfirmed,messages:replaceRow(unconfirmed),error:safeError(result.error,'send'),notice:'No automatic retry was made. Reopen the conversation to check whether it arrived.'});
+    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};
-   const accepted=shape({...s,pendingIntent:sent,messages:replaceRow(sent),error:'',notice:''});
+   // 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=>pendingIntentWasObserved(st.messages,sent)?shape({...st,pendingIntent:ownIntent(st),notice:'',messages:st.messages.filter(row=>!(row.id===sent.id&&row.pending))}):
+   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.
-   // A refresh already running owns the next read. Queue one more pass without keeping Send
-   // locked behind that request (or allowing its old snapshot to restore this intent).
-   if(refreshFlight){refreshQueued=true;return settled(accepted);}
-   try{const loaded=await loadLatest(accepted,true);return loaded?settled(loaded):undefined;}catch(error){
+   // 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(withLiveDraft(accepted));
+    return settled(latestResolved());
    }
   },
   sendSuggestion:async(s,a)=>{
-   if(suggestionFlight||!s.member||!s.roomId||!!s.pendingIntent)return s;
+   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)
@@ -487,14 +592,29 @@ const svc=defineService<State,Record<string,(s:State,a?:unknown)=>State|undefine
     if(sendEpoch!==epoch)return undefined;
     if(!sent)return withLiveDraft(s);
     const latest=readServiceState();
-    if(latest.roomId!==s.roomId||latest.principal!==s.principal)return undefined;
-    try{const loaded=await loadLatest(withLiveDraft(shape({...s,scrollSend:s.scrollSend+1,error:'',notice:'Suggestion sent.'})),true);return loaded?shape({...loaded,notice:'Suggestion sent.'}):undefined;}
-    catch{return withLiveDraft(shape({...s,scrollSend:s.scrollSend+1,error:'',notice:'Suggestion sent.'}));}
+    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?'The suggestion was rejected.':'Suggestion delivery is unconfirmed; it will not be sent again automatically.'});
+    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)=>{
@@ -502,7 +622,7 @@ const svc=defineService<State,Record<string,(s:State,a?:unknown)=>State|undefine
    const startEpoch=epoch;
    const envelope=a as RealtimeEventEnvelope|undefined;
    const eventType=typeof envelope?.event?.type==='string'?envelope.event.type:'';
-   s=shape({...s,realtimeEventCount:s.realtimeEventCount+1,lastRealtimeEventType:eventType});
+   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){
@@ -516,8 +636,9 @@ const svc=defineService<State,Record<string,(s:State,a?:unknown)=>State|undefine
    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||!currentIdentity||s.principal!==(currentIdentity.userId||currentIdentity.email)||s.scope!==currentIdentity.scope)return next;
+   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;

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

@@ -115,6 +115,7 @@ interface State {
   checkoutHint: string;
   itemCount: number;
   promoCode: string;
+  promoEditRevision: number;
   appliedCode: string;
   appliedLabel: string;
   couponId: string;
@@ -380,11 +381,24 @@ function couponDetails(result: unknown): { id: string; code: string } {
   return { id: coupon?.coupon?.id ?? coupon?.id ?? "", code: coupon?.coupon?.code ?? coupon?.code ?? "" };
 }
 
+import { withExclusiveWrites } from "../_shared/exclusive-writes.js";
+
 let cartPricing: IapCommerce;
 const defineService = withIapPresentation<State>({
-  register: withOnlineWrites(registerState, ["remove", "increment", "decrement", "checkout", "beginPromo", "applyPromo", "removePromo"], { derive, messageFields: action => action.includes("Promo") ? ["promoError"] : ["checkoutHint"] }),
+  register: withExclusiveWrites<State>(withOnlineWrites(registerState, ["remove", "increment", "decrement", "checkout", "beginPromo", "applyPromo", "removePromo"], { derive, messageFields: action => action.includes("Promo") ? ["promoError"] : ["checkoutHint"] }), ["load", "remove", "increment", "decrement", "checkout", "applyPromo", "removePromo", "save"], {
+    prepare: (action, args) => { if (action === "load") stashCopy(args[0]); },
+    coalesce: ["load"],
+    // Full cart reloads share the transaction, since they also replace rows and
+    // reset promo fields. Only setPromo increments the edit revision: beginPromo's internal error reset
+    // must not masquerade as a user edit when a rejected code is retried.
+    settle: (before, next, live) => {
+      if ((before.promoEditRevision ?? 0) === (live.promoEditRevision ?? 0)) return next;
+      return derive({ ...next, promoEditRevision: live.promoEditRevision,
+        ...(next.items.length ? { promoCode: live.promoCode, promoError: live.promoError } : {}) });
+    },
+  }),
   onCreate: commerce => { cartPricing = commerce; },
-  prefix: "cart", transientKeys: ["items", "subtotal", "promoBusy"], contentActions: ["load", "remove", "increment", "decrement"],
+  prefix: "cart", transientKeys: ["items", "subtotal", "promoBusy", "promoEditRevision"], contentActions: ["load", "remove", "increment", "decrement"],
   items: state => state.items.flatMap(row => row.catalogReference?.catalogItemId ? [{ reference: { kind: "storesProduct", id: row.catalogReference.catalogItemId }, commerceDisplayPrice: row.commerceTotal ?? row.total }] : []),
   present: (state, price, allowed) => ({ ...state,
     items: state.items.map(row => ({ ...row, total: row.catalogReference?.catalogItemId ? price(row.catalogReference.catalogItemId, row.commerceTotal ?? row.total) : row.total })),
@@ -404,10 +418,9 @@ const svc = defineService<State, {
   decrement: (state: State, arg?: unknown) => Promise<State>;
   checkout: (state: State) => Promise<State>;
 }>("himiStoreCart", {
-  state: derive({ status: "loading", errorKind: "", items: [], subtotal: "", subtotalLabel: "", emptyText: "", checkoutHint: "", showPaidToast: false, noPaidToast: true, itemCount: 0, promoCode: "", appliedCode: "", appliedLabel: "", couponId: "", promoError: "", promoBusy: false, noPromoError: true, hasCoupon: false, discount: "", noDiscount: true, noCheckoutHint: true, noCoupon: true, isLoading: true, notLoading: false, isErrored: false, notErrored: true, noOfflineError: true, noServerError: true, hideContent: true, noEmpty: true, noItems: true }),
+  state: derive({ status: "loading", errorKind: "", items: [], subtotal: "", subtotalLabel: "", emptyText: "", checkoutHint: "", showPaidToast: false, noPaidToast: true, itemCount: 0, promoCode: "", promoEditRevision: 0, appliedCode: "", appliedLabel: "", couponId: "", promoError: "", promoBusy: false, noPromoError: true, hasCoupon: false, discount: "", noDiscount: true, noCheckoutHint: true, noCoupon: true, isLoading: true, notLoading: false, isErrored: false, notErrored: true, noOfflineError: true, noServerError: true, hideContent: true, noEmpty: true, noItems: true }),
   actions: {
     load: async (state, arg) => {
-      stashCopy(arg);
       // 1) Instant paint from the on-device cache (offline-safe; empty on first-ever run).
       const cached = await readCachedItems();
       const base = cached.length
@@ -423,7 +436,7 @@ const svc = defineService<State, {
           : derive({ ...state, status: "error", errorKind: isOfflineFailure(error) ? "offline" : "server", items: [], subtotal: "", emptyText: copyParam("cart.loadErrorText", "Cart could not load."), checkoutHint: "" });
       }
     },
-    setPromo: (state, arg) => derive({ ...state, promoCode: (typeof arg === "string" ? arg : String((arg as { value?: unknown } | undefined)?.value ?? "")).slice(0, 100), promoError: "" }),
+    setPromo: (state, arg) => derive({ ...state, promoEditRevision: (state.promoEditRevision ?? 0) + 1, promoCode: (typeof arg === "string" ? arg : String((arg as { value?: unknown } | undefined)?.value ?? "")).slice(0, 100), promoError: "" }),
     beginPromo: state => derive({ ...state, promoBusy: true, promoError: "" }),
     applyPromo: async (state): Promise<State> => {
       const code = state.promoCode.trim();