@wix/himalaya-cli 0.1494.0 → 0.1496.0

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

@@ -206,7 +206,7 @@
       "displayName": "Portfolio Project"
     },
     "himi_product": {
-      "displayName": "Product"
+      "displayName": "Product Details"
     },
     "himi_program": {
       "displayName": "Program"

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

@@ -2,8 +2,11 @@ import { formatClock } from './engine-intl.js';
 import { mergeMessages, normalizeMessages, type MessageRow } from './business-chat-message-model.js';
 
 /** `delivery` is what the composer's own row shows while the server catches up: sending, accepted (shown with its
- *  time) or unconfirmed (the request failed without a definite answer). */
-export interface BusinessChatIntent { id:string; text:string; roomId:string; principal:string; createdDate:string; delivery:'sending'|'sent'|'unconfirmed'; senderName?:string }
+ *  time) or unconfirmed (the request failed without a definite answer). The server names the stored message, so the
+ *  new one is recognised by its text, among the messages after `afterId` (the newest stored message on screen when it
+ *  was sent), or among all of them when the room was loaded and empty (`fromStart`); `priorCount` is how many earlier
+ *  sends with the same text were still waiting for their stored copy. */
+export interface BusinessChatIntent { id:string; text:string; roomId:string; principal:string; createdDate:string; delivery:'sending'|'sent'|'unconfirmed'; senderName?:string; afterId?:string; fromStart?:boolean; priorCount?:number }
 
 export function newBusinessChatIntent(text:string,roomId:string,principal:string,random=Math.random):BusinessChatIntent{
  return {id:'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g,c=>{const r=Math.floor(random()*16);return(c==='x'?r:(r&3)|8).toString(16);}),text,roomId,principal,createdDate:new Date().toISOString(),delivery:'sending'};
@@ -12,8 +15,36 @@ export function businessChatSendRejected(error:unknown):boolean{
  return /\b(400|401|403|404|409|413|422|429)\b|approved first-party|webwix_owner_only|sign_in_required|owner_preview_read_only/i.test(String((error as Error)?.message||error));
 }
 export function draftAfterAcceptedSend(currentDraft:string,sentDraft:string):string{return currentDraft===sentDraft?'':currentDraft;}
-export function pendingIntentWasObserved(messages:{id:string}[],intent:BusinessChatIntent|null):boolean{
- return !!intent&&messages.some(message=>message.id===intent.id);
+type Row={id:string;mine?:boolean;bodyText?:string;pending?:boolean};
+const sameOwnText=(message:Row,text:string)=>!!message.mine&&(message.bodyText??'').trim()===text.trim();
+/** What a send records about the screen it was sent from: the newest stored message (history is one page in time
+ *  order, so counting only after it ignores old messages, even one that drops off the page), and how many sends with
+ *  the same words are still waiting for their stored copies. No clock is involved: the phone's and the server's differ. */
+export function sendAnchor(messages:Row[],text:string,roomLoaded:boolean):{afterId?:string;fromStart?:boolean;priorCount:number}{
+ const stored=messages.filter(message=>!message.pending);
+ const priorCount=messages.filter(message=>message.pending&&sameOwnText(message,text)).length;
+ // A room that loaded with nothing in it: every stored message that appears later is newer than this send's screen.
+ // One that failed to load has no anchor at all, as it may hold older messages with the same words.
+ if(!stored.length)return roomLoaded?{fromStart:true,priorCount}:{priorCount};
+ return {afterId:stored[stored.length-1]!.id,priorCount};
+}
+/** Whether history already holds the member's sent message: by its own id, or as one more message of theirs with the
+ *  same text than there were when it was sent (the Smart Chat send does not let the app choose the stored id). This
+ *  only places the message on screen: the send itself is settled by its own request, never by what history shows, so
+ *  a coincidence (the same words sent from the website meanwhile) cannot hide a failure. */
+export function pendingIntentWasObserved(messages:Row[],intent:BusinessChatIntent|null):boolean{
+ if(!intent)return false;
+ const stored=messages.filter(message=>!message.pending);
+ if(stored.some(message=>message.id===intent.id))return true;
+ let newer:Row[];
+ if(intent.fromStart)newer=stored;
+ else{
+  // With no anchor (the room had not loaded) or the anchor gone, an older message with these words cannot be told apart.
+  const after=intent.afterId?stored.findIndex(message=>message.id===intent.afterId):-1;
+  if(after<0)return false;
+  newer=stored.slice(after+1);
+ }
+ return newer.filter(message=>sameOwnText(message,intent.text)).length>(intent.priorCount??0);
 }
 export function messageTimeLabel(value:string):string{
  const date=new Date(value);

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

@@ -1,6 +1,6 @@
-// The business chat's Wix calls: the member-role chat-web SDK for rooms, history and sends, plus the two
-// calls the SDK has no helper for (a tapped button, a private attachment's download URL).
-import { getChatToken, getMessagesPage, listChatroomsPage, sendChatMessage } from "@himalaya/wix-chat-web";
+// The business chat's Wix calls: the member-role chat-web SDK for rooms and history, plus the calls the SDKs have
+// no helper for (a typed message sent through Smart Chat, a tapped button, a private attachment's download URL).
+import { getChatToken, getMessagesPage, listChatroomsPage } from "@himalaya/wix-chat-web";
 import { assertMemberAccess, memberAccess } from "./member-access.js";
 
 const MANAGE = "https://manage.wix.com";
@@ -70,14 +70,21 @@ export const listRooms = (identity: ChatIdentity): Promise<{ items: Raw[]; more:
 });
 export const messagesPage = (identity: ChatIdentity, roomId: string): Promise<Raw[]> => fenced(identity, async () =>
   (await withToken(identity, (chatToken) => getMessagesPage(roomId, { ...MEMBER, chatToken, pageSize: 50, ordering: "Desc" }))).items as unknown as Raw[]);
-export const sendMessage = (identity: ChatIdentity, roomId: string, intent: { id: string; text: string }): Promise<void> =>
-  fenced(identity, () => withToken(identity, (chatToken) => sendChatMessage(roomId, intent.text, { ...MEMBER, chatToken, messageId: intent.id })));
 
 function bridge(): Bridge {
   const api = (globalThis as unknown as { himalaya?: { wixApi?: Bridge } }).himalaya?.wixApi;
   if (!api) throw new Error("wix_api_bridge_unavailable");
   return api;
 }
+/** A typed message goes through Smart Chat, exactly as the site's chat widget sends it. The Inbox then files it under
+ *  Wix Smart Chat and the AI can answer it; a message posted straight into the room has no channel, so the AI never
+ *  saw it and the owner's reply went out by email. It lands in the same room, under an id the server chooses.
+ *  The bridge resolves once the AI has finished answering, not when the message is stored. */
+export const sendMessage = (identity: ChatIdentity, text: string): Promise<void> => fenced(identity, async () => {
+  await bridge().call("POST", "/wix-assistant-widget/v1/messages/stream", {
+    message: { sender: "SITE_VISITOR", messageType: "QUESTION", body: { mainText: text } },
+  });
+});
 /** A tapped button is a silent, ephemeral message carrying the button's chat action. */
 export const sendButton = (identity: ChatIdentity, roomId: string, input: { id: string; text: string; appId: string; interactionId: string }): Promise<void> => fenced(identity, async () => {
   await withToken(identity, (chatToken) => bridge().call("POST", `${MANAGE}/_api/chat-web/v2/chatrooms/${encodeURIComponent(roomId)}/messages`, {

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

@@ -7,9 +7,12 @@ export const storeCollectionSaving: CollectionSaving = {
     const products = new Map(readSavedProducts().map(row => [row.id, row]));
     for (const row of rows) {
       if (typeof row.id !== 'string' || typeof row.name !== 'string') continue;
-      products.set(row.id, { id: row.id, name: row.name,
-        price: typeof row.commercePrice === 'string' ? row.commercePrice : typeof row.subtitle === 'string' ? row.subtitle : '',
-        image: typeof row.image === 'string' ? row.image : '' });
+      const previous = products.get(row.id);
+      const freshPrice = typeof row.commercePrice === 'string' ? row.commercePrice : typeof row.subtitle === 'string' ? row.subtitle : '';
+      const wasPrice = typeof row.wasPrice === 'string' ? row.wasPrice || undefined : previous?.price === freshPrice ? previous?.wasPrice : undefined;
+      products.set(row.id, { ...previous, wasPrice, id: row.id, name: row.name,
+        price: freshPrice || previous?.price || '',
+        image: typeof row.image === 'string' && row.image ? row.image : previous?.image ?? '' });
     }
     const selected = ids.map(id => products.get(id));
     if (selected.some(row => !row)) throw new Error('Saved product metadata is unavailable');

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

@@ -5,6 +5,8 @@ export interface SavedProduct {
   name: string;
   price: string;
   image: string;
+  wasPrice?: string;
+  swatches?: string[];
 }
 type StorageLike = { getItem(key: string): string | null; setItem(key: string, value: string): void };
 const KEY = "himi-store:saved-products:v1";
@@ -24,7 +26,11 @@ export function readSavedProducts(): SavedProduct[] {
     if (!value || typeof value !== "object") continue;
     const row = value as Record<string, unknown>;
     if (typeof row.id !== "string" || !row.id.trim() || typeof row.name !== "string") continue;
-    rows.set(row.id, { id: row.id, name: row.name, price: typeof row.price === "string" ? row.price : "", image: typeof row.image === "string" ? row.image : "" });
+    const swatches = Array.isArray(row.swatches)
+      ? row.swatches.filter((color): color is string => typeof color === "string" && /^#(?:[0-9a-f]{3}|[0-9a-f]{6})$/i.test(color)).slice(0, 5)
+      : [];
+    rows.set(row.id, { id: row.id, name: row.name, price: typeof row.price === "string" ? row.price : "", image: typeof row.image === "string" ? row.image : "",
+      ...(typeof row.wasPrice === "string" && row.wasPrice ? { wasPrice: row.wasPrice } : {}), ...(swatches.length ? { swatches } : {}) });
   }
   return [...rows.values()];
 }

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

@@ -2,7 +2,7 @@ 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, pendingIntentWasObserved, chronologicalMessages, newBusinessChatIntent, type BusinessChatIntent } from '../_shared/business-chat-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 { dispatchBusinessSuggestion, businessRealtimeStatusLabel, businessVisitorOptionSuggestions, presentBusinessMessages, selectExistingBusinessRoom, shouldRefreshBusinessHistory, type BusinessSuggestion, type BusinessVisitorOptions, businessVisitorOptionRequest, businessVisitorOptionsFromAiMessages, newBusinessSelectionId} from '../_shared/business-chat-presenter.js';
 import { listMessages, streamMessages } from '@himalaya/wix-ai-site-chat';
@@ -33,7 +33,6 @@ const initial:State={hostedName,hasHostedName:!!hostedName,noHostedName:!hostedN
 let currentIdentity:ChatIdentity|null=null;
 let subscriptionId='';
 let initFlight=false;
-let sendFlight=false;
 let suggestionFlight=false;
 let refreshFlight=false;
 let refreshQueued=false;
@@ -71,7 +70,10 @@ function pendingRow(intent:BusinessChatIntent):BusinessMessageRow{
   suggestions:[],articleActions:[],couponCode:'',noCoupon:true,notMine:false,dayLabel:'',dayHidden:true,startsDay:false,scrollAnchor:`himi_business_chat.message_${intent.id}`,pending:true};
 }
 function shape(s:State):State{const used=new Set(s.usedSuggestionIds);const messages=s.messages.map(row=>({...row,suggestions:(row.suggestions||[]).map(button=>used.has(button.id)?{...button,enabled:false,disabled:true}:button)}));const quickReplies=(s.quickReplies||[]).map(button=>used.has(button.id)?{...button,enabled:false,disabled:true}:button);const quickEnabled=quickReplies.some(button=>button.enabled);return {...s,messages,quickReplies,hasQuickReplies:quickEnabled,noQuickReplies:!quickEnabled,scrollAnchor:messages[messages.length-1]?.scrollAnchor||'',liveLabel:liveDescription(s.liveState,s.liveReason),hasActiveRoom:!!s.roomId,noActiveRoom:!s.roomId,hasHostedName:!!s.hostedName,noHostedName:!s.hostedName,isGuest:s.phase==='guest',notGuest:s.phase!=='guest',realtimeDiagnostic:`state=${s.liveState}; reason=${s.liveReason||'none'}; events=${s.realtimeEventCount}; lastType=${/^(message|messagesent)$/i.test(s.lastRealtimeEventType)?s.lastRealtimeEventType:'none'}`,errorText:s.error,loadingHidden:s.phase!=='loading'||!!s.error,noError:!s.error,noNotice:!s.notice,noMessages:!messages.length,hasMessages:!!messages.length,noEmpty:s.phase!=='ready'||!!messages.length,
-  notLoading:s.phase!=='loading',sendDisabled:!s.member||!s.roomId||s.busy||!s.draft.trim()||!!s.pendingIntent,sendEnabled:!!s.member&&!!s.roomId&&!s.busy&&!!s.draft.trim()&&!s.pendingIntent,noLive:!s.roomId||s.liveState==='connected'};}
+  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;}
 function safeLoadFailure(error:unknown):string{
  const name=error instanceof Error?error.name:'UnknownError';
  const code=(error as {code?:unknown}|null)?.code;
@@ -215,9 +217,12 @@ async function refreshHistory(s:State):Promise<State|undefined>{
   const base:State=same?withLiveFields(s,latest,liveDraft):{...s,draft:liveDraft};
   const intentObserved=pendingIntentWasObserved(messages,base.pendingIntent);
   const draft=intentObserved&&base.pendingIntent&&base.draft.trim()===base.pendingIntent.text?'':base.draft;
-  // A send the server has not returned yet stays on screen until history does.
+  // 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;
-  return shape({...base,messages:shown,visitorOptions,quickReplies:businessVisitorOptionSuggestions(visitorOptions),draft,pendingIntent:intentObserved?null:base.pendingIntent,phase:'ready',error:'',loadFailure:''});
+  const pendingIntent=intentObserved&&base.pendingIntent?.delivery==='unconfirmed'?null:base.pendingIntent;
+  return shape({...base,messages:shown,pendingIntent,visitorOptions,quickReplies:businessVisitorOptionSuggestions(visitorOptions),draft,phase:'ready',error:'',loadFailure:''});
  }catch(error){
   const wrapped=error instanceof Error?error:new Error('load_failed');
   Object.assign(wrapped,{businessLoadFailure:safeLoadFailure(error)});
@@ -227,24 +232,27 @@ async function refreshHistory(s:State):Promise<State|undefined>{
 /** 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{
- return {...st,draft,pendingIntent:latest.pendingIntent||st.pendingIntent,
+ // 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)};
 }
 function withLiveDraft(st:State):State{const latest=readServiceState();return withLiveFields(st,latest,latest.draft);}
 type SendResult={id:string;outcome:'sent'|'rejected'|'unconfirmed'|'signed_out';draft:string;error?:unknown};
-/** Posts one message and reports how it ended; never throws. The caller already showed the message. */
+/** 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
-  await chat.sendMessage(me(),pending.roomId,{id:pending.id,text:pending.text});
+  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'};
- }finally{sendFlight=false;}
+ }
  if(sendEpoch===epoch)void svc.settleSend(result);
 }
 const svc=defineService<State,Record<string,(s:State,a?:unknown)=>State|undefined|Promise<State|undefined>>>('businessChat',{
@@ -254,15 +262,32 @@ const svc=defineService<State,Record<string,(s:State,a?:unknown)=>State|undefine
    if(initFlight)return s;initFlight=true;eventDuringInit=false;statusDuringInit=null;
    const oldPrincipal=s.principal;
    const initRevision=draftRevision;
-   // Text typed at any point of the load, subscribe step included, outlives the snapshot this started from.
-   const keepTyped=(st:State):State=>draftRevision!==initRevision?{...st,draft:readServiceState().draft}:st;
+   // 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;
+    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),
+     ...(settledMeanwhile?{notice:live.notice,error:live.error,draft:live.draft}:draftRevision!==initRevision?{draft:live.draft}:{})};
+   };
    let myEpoch=epoch;
    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=clearPrivate(s,'guest');myEpoch=epoch;}
+    if(oldPrincipal&&(oldPrincipal!==(identity.userId||identity.email)||s.scope!==identity.scope)){s=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);
@@ -284,15 +309,16 @@ const svc=defineService<State,Record<string,(s:State,a?:unknown)=>State|undefine
    }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=!!s.member&&!!s.roomId&&!s.busy&&!!draft.trim()&&!s.pendingIntent;return {...s,draft,sendEnabled,sendDisabled:!sendEnabled};},
+  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();
-   if(!text||sendFlight||!s.roomId||!s.member||s.pendingIntent)return s;
+   // 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??'';
-   sendFlight=true;const pending={...newBusinessChatIntent(text,s.roomId,s.principal),senderName:ownName};
+   const pending={...newBusinessChatIntent(text,s.roomId,s.principal),senderName:ownName,...sendAnchor(s.messages,text,s.phase==='ready')};
    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});
@@ -306,16 +332,23 @@ const svc=defineService<State,Record<string,(s:State,a?:unknown)=>State|undefine
     // 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.'});
    }
+   // 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};
-    return shape({...s,pendingIntent:unconfirmed,messages:replaceRow(unconfirmed),error:safeError(result.error,'send'),notice:'No automatic retry was made. Reopen the conversation to check whether it arrived.'});
+    const 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 sent={...pending,delivery:'sent' as const};
    const accepted=shape({...s,pendingIntent:sent,messages:replaceRow(sent),error:'',notice:''});
    const sendEpoch=epoch;
    // The server accepted it, so Send is free again whatever history says; the row stays until history returns it.
    // A refresh that ran while the committed intent still said sending leaves a 'Sending…' row: swap it for the accepted one.
-   const settled=(st:State):State=>shape({...st,pendingIntent:null,notice:'',messages:st.messages.some(row=>row.id===sent.id)?st.messages.map(row=>row.id===sent.id&&row.pending?pendingRow(sent):row):[...st.messages,pendingRow(sent)]});
+   // 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)&&!st.messages.some(row=>row.id===sent.id)?shape({...st,pendingIntent:ownIntent(st),notice:''}):
+    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)]});
    // While live updates are connected the server's own event brings the message back through one refresh; a second
    // one here would only queue behind it on the worker, delaying the member's next keystroke or send.
    if(s.liveState==='connected')return settled(accepted);