@wix/himalaya-cli 0.1495.0 → 0.1497.0

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/iap-attendance-form.ts

@@ -0,0 +1,106 @@
+import { copyParam } from "./himi-copy.js";
+
+export interface AttendanceField {
+  id: string;
+  label: string;
+  kind: string;
+  required: boolean;
+  value: string;
+  selectedIds: string[];
+  options: { id: string; label: string }[];
+  error: string;
+  maxLength?: number;
+  maxSize?: number;
+}
+
+const object = (v: unknown): Record<string, unknown> => v !== null && typeof v === "object" && !Array.isArray(v) ? v as Record<string, unknown> : {};
+const text = (v: unknown): string => typeof v === "string" ? v : "";
+const EMAIL = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+
+export function createAttendanceForm(prefix: string) {
+  let fields: AttendanceField[] = [];
+  let supported = false;
+  const label = (name: string) => copyParam(`${prefix}.${name}Label`, name === "firstName" ? "First name" : name === "lastName" ? "Last name" : "Email");
+  const field = (scope: string, name: string, input: Record<string, unknown> = {}): AttendanceField => ({
+    id: `${scope}:${name}`, label: text(input.label) || label(name), required: input.mandatory === true,
+    kind: name === "email" ? "email" : input.type === "NUMBER" ? "number" : input.type === "TEXT_ARRAY" ? "multiple" : Array.isArray(input.options) && input.options.length ? "choice" : "text",
+    value: "", selectedIds: [], error: "",
+    options: Array.isArray(input.options) ? input.options.filter((o): o is string => typeof o === "string").map((o) => ({ id: o, label: o })) : [],
+    ...(typeof input.maxLength === "number" ? { maxLength: input.maxLength } : {}),
+    ...(typeof input.maxSize === "number" ? { maxSize: input.maxSize } : {}),
+  });
+  const contact = (scope: string) => ["firstName", "lastName", "email"].map((name) => field(scope, name, { mandatory: true }));
+
+  function event(raw: unknown): void {
+    fields = contact("buyer");
+    const controls = object(raw).controls;
+    supported = Array.isArray(controls) && controls.length > 0;
+    const names = new Set<string>();
+    for (const control of Array.isArray(controls) ? controls : []) {
+      const c = object(control);
+      if (c.deleted === true) continue;
+      if (!Array.isArray(c.inputs) || !c.inputs.length) { supported = false; continue; }
+      for (const rawInput of c.inputs) {
+        const input = object(rawInput);
+        const name = text(input.name);
+        if (!name || names.has(name) || !["TEXT", "NUMBER", "TEXT_ARRAY"].includes(text(input.type)) || (input.type === "TEXT_ARRAY" && (!Array.isArray(input.options) || !input.options.length))) { supported = false; continue; }
+        names.add(name);
+        fields.push(field("guest", name, { ...input, mandatory: input.mandatory === true || ["firstName", "lastName", "email"].includes(name) }));
+      }
+    }
+    if (!["firstName", "lastName", "email"].every((name) => names.has(name))) supported = false;
+  }
+
+  function booking(service: unknown): void {
+    fields = contact("buyer");
+    const id = text(object(object(service).form).id);
+    // Custom intake schemas need their own reader; never silently omit their required fields.
+    supported = id === "00000000-0000-0000-0000-000000000000";
+  }
+
+  function change(arg: unknown): void {
+    const a = object(arg);
+    const f = fields.find((candidate) => candidate.id === a.id);
+    if (!f) return;
+    if (typeof a.option === "string") {
+      if (f.kind === "multiple") f.selectedIds = f.selectedIds.includes(a.option) ? f.selectedIds.filter((v) => v !== a.option) : [...f.selectedIds, a.option];
+      else f.value = a.option;
+      f.error = "";
+      return;
+    }
+    f.value = text(a.value ?? a.text ?? a.selectedId);
+    f.selectedIds = Array.isArray(a.selectedIds) ? a.selectedIds.filter((v): v is string => typeof v === "string") : [];
+    f.error = "";
+  }
+
+  function valid(f: AttendanceField): boolean {
+    const value = f.value.trim();
+    const values = f.kind === "multiple" ? f.selectedIds : value ? [value] : [];
+    if (!values.length) return !f.required;
+    if (f.options.length && values.some((v) => !f.options.some((o) => o.id === v))) return false;
+    if (f.maxSize !== undefined && values.length > f.maxSize) return false;
+    if (f.maxLength !== undefined && values.some((v) => v.length > f.maxLength!)) return false;
+    return f.kind === "email" ? EMAIL.test(value) : f.kind !== "number" || /^-?\d+(?:\.\d+)?$/.test(value);
+  }
+
+  function validate(): boolean {
+    for (const f of fields) f.error = valid(f) ? "" : copyParam(`${prefix}.formInvalidText`, "Check this field.");
+    return supported && fields.every((f) => !f.error);
+  }
+
+  function buyer(): Record<string, string> {
+    return Object.fromEntries(fields.filter((f) => f.id.startsWith("buyer:")).map((f) => [f.id.slice(6), f.value.trim()]));
+  }
+
+  function ticket(definitionId: string) {
+    const inputValues = fields.filter((f) => f.id.startsWith("guest:") && (f.value.trim() || f.selectedIds.length)).map((f) => ({ inputName: f.id.slice(6), ...(f.kind === "multiple" ? { values: f.selectedIds.slice() } : { value: f.value.trim() }) }));
+    return { buyer: buyer(), guests: [{ ticketDefinitionId: definitionId, form: { inputValues } }] };
+  }
+
+  return {
+    event, booking, change, validate, buyer, ticket,
+    supported: () => supported,
+    rows: () => fields.map((f) => ({ ...f, selectedIds: f.selectedIds.slice(), kind: f.kind === "text" && f.required ? "requiredText" : f.kind })),
+    clear: () => { for (const f of fields) { f.value = ""; f.selectedIds = []; f.error = ""; } },
+  };
+}

package/templates/branded-lite/tier5-src/_shared/iap-attendance-purchase.ts

@@ -0,0 +1,211 @@
+import { attendanceCheckoutRoute, availableTicketAttendanceOf, bookingAttendanceOf, classifyForApple, hostSessionFromGlobal, iapPriceFields, type BookingAttendance, type CatalogReference, type IapPollDirective, type TicketAttendance } from "@himalaya/iap";
+import { bookingOrders, createIapCommerce, eventTicketOrders, type IapOrderItem } from "@himalaya/iap-checkout";
+import { copyParam, copyTemplate } from "./himi-copy.js";
+import { createAttendanceForm, type AttendanceField } from "./iap-attendance-form.js";
+import { attendancePlatform } from "./iap-attendance.js";
+import { iapPriceCopy, iapPurchaseCopy } from "./iap-worker.js";
+
+export interface AttendancePurchaseFields {
+  iapBuyHidden: boolean;
+  iapBuyDisabled: boolean;
+  iapBuyLabel: string;
+  iapBusy: boolean;
+  iapPrice: string;
+  iapNote: string;
+  iapRetryHidden: boolean;
+  iapFormHidden: boolean;
+  iapFormError: string;
+  iapSignInHidden: boolean;
+  iapFields: AttendanceField[];
+  _poll?: IapPollDirective;
+}
+
+export const ATTENDANCE_INITIAL: AttendancePurchaseFields = {
+  iapBuyHidden: true, iapBuyDisabled: true, iapBuyLabel: "", iapBusy: false,
+  iapPrice: "", iapNote: "", iapRetryHidden: true, iapFormHidden: true, iapFormError: "", iapSignInHidden: true, iapFields: [],
+};
+export const ATTENDANCE_NOT_HYDRATED = [...Object.keys(ATTENDANCE_INITIAL), "_poll"] as (keyof AttendancePurchaseFields & string)[];
+
+export function createAttendancePurchase(options: { kind: "bookingsService" | "eventsTicket"; prefix: string; pollAction: string; onChange(): void }) {
+  const { prefix } = options;
+  let form = createAttendanceForm(prefix);
+  const submittedForms = new Map<string, ReturnType<typeof createAttendanceForm>>();
+  const session = hostSessionFromGlobal();
+  const commerce = createIapCommerce({ adapters: [options.kind === "bookingsService" ? bookingOrders : eventTicketOrders], onChange: options.onChange });
+  let generation = session.current().generation;
+  let reference: CatalogReference | undefined;
+  let metadata: BookingAttendance | TicketAttendance | undefined;
+  let platform = "unknown";
+  let started = false;
+  let inFlight = false;
+  let formError = "";
+  let sequence = 0;
+  let formRevision = 0;
+  const attempts = new Map<string, string>();
+  session.subscribe(() => { syncSession(); if (reference) options.onChange(); });
+
+  function syncSession(): void {
+    const next = session.current().generation;
+    if (next === generation) return;
+    generation = next;
+    form.clear();
+    submittedForms.clear();
+    formError = "";
+    attempts.clear();
+  }
+
+  async function refresh(): Promise<void> {
+    const next = await attendancePlatform(publishPlatform);
+    if (next !== "unknown" || platform === "unknown") platform = next;
+    await resume();
+  }
+
+  async function resume(): Promise<void> {
+    if (reference) await commerce.loadPrices([{ reference }]);
+    const first = !started;
+    started = true;
+    await (first ? commerce.start() : commerce.reconcile());
+  }
+
+  function publishPlatform(next: string): void {
+    if (next === "unknown" && platform !== "unknown") return;
+    platform = next;
+    void resume().then(options.onChange, options.onChange);
+  }
+
+  function show(): void {
+    void attendancePlatform(publishPlatform).then(publishPlatform, options.onChange);
+  }
+
+  async function booking(id: string, service: unknown): Promise<void> {
+    syncSession();
+    reference = { kind: options.kind, id };
+    metadata = bookingAttendanceOf(service);
+    selectForm(id, (next) => next.booking(service));
+    formRevision++;
+    formError = "";
+    await show();
+  }
+
+  async function ticket(id: string, event: unknown, available: unknown): Promise<void> {
+    syncSession();
+    reference = id ? { kind: options.kind, id } : undefined;
+    metadata = availableTicketAttendanceOf(event, available);
+    selectForm(id, (next) => next.event((event as { form?: unknown } | undefined)?.form));
+    formRevision++;
+    formError = "";
+    await show();
+  }
+
+  function selectForm(id: string, initialize: (next: ReturnType<typeof createAttendanceForm>) => void): void {
+    const key = `${options.kind}:${id}`;
+    const retained = submittedForms.get(key);
+    form = retained ?? createAttendanceForm(prefix);
+    if (!retained) initialize(form);
+  }
+
+  function fields(selected = true, publishPoll = true): AttendancePurchaseFields {
+    syncSession();
+    if (!reference || !metadata) return ATTENDANCE_INITIAL;
+    const currency = metadata.currency ?? "";
+    const classified = classifyForApple(metadata, currency);
+    const candidate = platform === "ios" && classified === "appleIap";
+    const price = iapPriceFields(commerce.pricing.view(reference), iapPriceCopy(prefix));
+    const copy = { ...iapPurchaseCopy(prefix), buy: copyParam(`${prefix}.appleBuyCta`, options.kind === "bookingsService" ? "Book with Apple" : "Buy ticket with Apple"), buyAnother: copyParam(`${prefix}.buyAnotherCta`, options.kind === "bookingsService" ? "Book again" : "Buy another ticket") };
+    const purchase = commerce.purchaseFields(reference, copy);
+    const apple = candidate || (platform === "ios" && classified !== "wixPayments" && purchase.appleRoute);
+    const enabled = attendanceCheckoutRoute(metadata, currency, platform) === "appleIap";
+    const poll = publishPoll ? commerce.pollDirective(options.pollAction) : undefined;
+    const state = commerce.state();
+    for (const [target, attempt] of attempts) {
+      const key = `${reference.kind}:${reference.id}#${encodeURIComponent(attempt)}`;
+      if ((state.phase === "accessReady" && state.item === key) || state.payments.some((p) => p.item === key && p.access === "granted")) attempts.delete(target);
+    }
+    const formKey = `${reference.kind}:${reference.id}`;
+    if (![...attempts.keys()].some((target) => target.startsWith(`${formKey}:`))) submittedForms.delete(formKey);
+    const own = state.item?.startsWith(`${reference.kind}:${reference.id}#`);
+    const completed = state.phase === "accessReady" && own;
+    const member = session.current().kind === "member";
+    let note = "";
+    if (apple && !enabled) note = copy.unavailable;
+    else if (apple && !member) note = copy.signInRequired;
+    else if (apple && purchase.buyNote) note = purchase.buyNote;
+    else if (apple && !form.supported()) note = copyParam(`${prefix}.formUnavailableText`, "This registration form is not supported yet.");
+    else if (apple && completed) note = copyParam(`${prefix}.purchaseCompleteText`, options.kind === "bookingsService" ? "Your booking is confirmed." : "Your ticket is confirmed.");
+    else if (apple && own && state.phase === "cancelled") note = copyParam(`${prefix}.purchaseCancelledText`, "Purchase cancelled. Your place is not confirmed.");
+    return {
+      iapBuyHidden: !apple, iapBuyDisabled: !enabled || !selected || !member || !form.supported() || purchase.buyDisabled || inFlight,
+      iapBuyLabel: purchase.buyLabel || copy.buy, iapBusy: purchase.buyBusy || inFlight,
+      iapPrice: apple ? price.priceText : "", iapRetryHidden: !apple || (price.hidePriceRetry && commerce.scopeComplete()),
+      iapNote: note,
+      iapFormHidden: !apple || !selected || !form.supported(), iapFormError: formError,
+      iapSignInHidden: !apple || member || options.kind === "bookingsService",
+      iapFields: form.rows().map((f, index, rows) => ({ ...f,
+        id: `${generation}:${formRevision}:${f.id}`, fieldId: f.id,
+        errorHidden: !f.error,
+        options: f.options.map((o) => ({ ...o, fieldId: f.id, displayLabel: (f.kind === "multiple" ? f.selectedIds.includes(o.id) : f.value === o.id) ? `${o.label} ✓` : o.label })),
+        label: f.required ? `${f.label} *` : f.label,
+        inputLabel: copyTemplate(`${prefix}.fieldAccessibilityLabel`, "{section}: {field}", { section: f.id.startsWith("buyer:") ? copyParam(`${prefix}.buyerDetailsLabel`, "Buyer details") : copyParam(`${prefix}.guestDetailsLabel`, "Ticket holder details"), field: f.label }),
+        sectionLabel: index === 0 ? copyParam(`${prefix}.buyerDetailsLabel`, "Buyer details") : f.id.startsWith("guest:") && rows[index - 1].id.startsWith("buyer:") ? copyParam(`${prefix}.guestDetailsLabel`, "Ticket holder details") : "",
+      })), ...(poll ? { _poll: poll } : {}),
+    };
+  }
+
+  async function buy(selection: { key: string; slot?: Record<string, unknown>; eventId?: string }): Promise<void> {
+    syncSession();
+    if (!reference || !metadata || fields(true, false).iapBuyDisabled || inFlight) return;
+    if (options.kind === "eventsTicket" && reference.id !== selection.key) return;
+    if (!form.validate()) { formError = copyParam(`${prefix}.formRequiredText`, "Complete the required details before purchasing."); return; }
+    if (session.current().kind !== "member") { formError = iapPurchaseCopy(prefix).signInRequired; return; }
+    const currentGeneration = generation;
+    const ref = reference;
+    submittedForms.set(`${ref.kind}:${ref.id}`, form);
+    const target = `${ref.kind}:${ref.id}:${selection.key}`;
+    let attemptId = attempts.get(target);
+    const state = commerce.state();
+    const attemptKey = attemptId ? `${ref.kind}:${ref.id}#${encodeURIComponent(attemptId)}` : "";
+    const completed = attemptId && ((state.phase === "accessReady" && state.item === attemptKey) || state.payments.some((p) => p.item === attemptKey && p.access === "granted"));
+    if (!attemptId || completed) { attemptId = `${Date.now().toString(36)}-${++sequence}-${Math.random().toString(36).slice(2)}`; attempts.set(target, attemptId); }
+    const item: IapOrderItem = { reference: ref, attemptId, quantity: 1, attendance: {
+      amount: metadata.amount!, currency: metadata.currency!,
+      ...(options.kind === "bookingsService" ? { booking: { slot: selection.slot ?? {}, contactDetails: form.buyer() } } : { ticket: { eventId: selection.eventId ?? "", ...form.ticket(ref.id) } }),
+    } };
+    inFlight = true;
+    formError = "";
+    options.onChange();
+    try {
+      await commerce.buy(item);
+      const after = commerce.state();
+      if (after.phase === "accessReady" && after.item === `${ref.kind}:${ref.id}#${encodeURIComponent(attemptId)}`) attempts.delete(target);
+    }
+    finally { inFlight = false; syncSession(); if (generation !== currentGeneration) form.clear(); options.onChange(); }
+  }
+
+  function change(arg: unknown): void {
+    syncSession();
+    const state = commerce.state();
+    if (reference) {
+      for (const [target, attempt] of attempts) {
+        const item = `${reference.kind}:${reference.id}#${encodeURIComponent(attempt)}`;
+        const canCorrect = state.phase === "cancelled" || (state.phase === "refused" && (state.failure === "orderRefused" || state.failure === "productChanged"));
+        if (canCorrect && state.item === item) { attempts.delete(target); submittedForms.delete(`${reference.kind}:${reference.id}`); }
+      }
+      const referencePrefix = `${reference.kind}:${reference.id}:`;
+      if (inFlight || [...attempts.keys()].some((target) => target.startsWith(referencePrefix))) {
+        formError = copyParam(`${prefix}.detailsLockedText`, "Finish the current purchase before changing registration details.");
+        return;
+      }
+    }
+    form.change(arg);
+    formError = "";
+  }
+
+  return {
+    booking, ticket, fields, buy,
+    usesRegularPlatform: () => platform === "android" || platform === "web",
+    invalidate: () => { reference = undefined; metadata = undefined; options.onChange(); },
+    change,
+    refresh,
+    poll: async () => { syncSession(); await commerce.poll(); },
+  };
+}

package/templates/branded-lite/tier5-src/_shared/iap-attendance.ts

@@ -0,0 +1,38 @@
+import { get as appInfo } from "@himalaya/app-info";
+import { attendanceCheckoutRoute, bookingAttendanceOf, ticketAttendanceOf } from "@himalaya/iap";
+
+let knownPlatform: string | undefined;
+
+export function attendancePlatform(onResolved?: (platform: string) => void): Promise<string> {
+  if (knownPlatform) return Promise.resolve(knownPlatform);
+  const info = appInfo().then((value) => value.platform, () => "unknown").then((platform) => {
+    if (platform !== "unknown") knownPlatform = platform;
+    return platform;
+  });
+  const host = globalThis as { setTimeout?: (fn: () => void, ms: number) => unknown; clearTimeout?: (timer: unknown) => void };
+  if (!host.setTimeout) {
+    void info.then((platform) => onResolved?.(platform));
+    return Promise.resolve("unknown");
+  }
+  return new Promise((resolve) => {
+    let timedOut = false;
+    const timer = host.setTimeout!(() => { timedOut = true; resolve("unknown"); }, 1500);
+    void info.then((platform) => { host.clearTimeout?.(timer); resolve(platform); if (timedOut) onResolved?.(platform); });
+  });
+}
+
+export async function mayUseRegularBookingCheckout(service: unknown): Promise<boolean> {
+  const metadata = bookingAttendanceOf(service);
+  if (metadata.priceType === "NO_FEE" || isZero(metadata.amount)) return true;
+  return attendanceCheckoutRoute(metadata, metadata.currency ?? "", await attendancePlatform()) === "regular";
+}
+
+export async function mayUseRegularTicketCheckout(event: unknown, ticket: { free?: boolean; price?: { amount?: string; currency?: string }; saleStatus?: string } | undefined): Promise<boolean> {
+  if (ticket?.free === true || isZero(ticket?.price?.amount)) return true;
+  const metadata = ticketAttendanceOf(event, { hidden: false, saleStatus: ticket?.saleStatus });
+  return attendanceCheckoutRoute(metadata, ticket?.price?.currency ?? "", await attendancePlatform()) === "regular";
+}
+
+function isZero(value: unknown): boolean {
+  return typeof value === "string" && /^0+(?:\.0+)?$/.test(value);
+}

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);