@wix/himalaya-cli 0.987.0 → 0.989.0

package/dist/cli.mjs

@@ -15932,7 +15932,7 @@ function wixClientIdOf(appConfigJson) {
   if (typeof clientId !== "string" || !clientId) return { error: "no_client_id" };
   return { clientId };
 }
-var WIX_API, ONE_APP_SESSION, OWNER_SCOPED_WIX_HOST, VisitorTokenCache, OwnerInstanceCache, OWNER_SITES_QUERY_PATH, OWNER_SITES_COUNT_PATH, OwnerSitesCache;
+var WIX_API, ONE_APP_SESSION, OWNER_SCOPED_WIX_HOST, VisitorTokenCache, OWNER_REFRESH_MARGIN_MS, OwnerInstanceCache, OWNER_SITES_QUERY_PATH, OWNER_SITES_COUNT_PATH, OwnerSitesCache;
 var init_wix_bridge = __esm({
   "../../core/serve-runtime/src/wix-bridge.ts"() {
     init_sha256();
@@ -15969,20 +15969,29 @@ var init_wix_bridge = __esm({
         this.cache.delete(clientId);
       }
     };
+    OWNER_REFRESH_MARGIN_MS = 6e4;
     OwnerInstanceCache = class {
       constructor(fetchImpl = fetch, ttlMs = 5 * 6e4) {
         this.fetchImpl = fetchImpl;
         this.ttlMs = ttlMs;
       }
       cache = /* @__PURE__ */ new Map();
+      /** Keyed on the SESSION (`wixSession2`), not the whole cookie header: manage.wix.com's jar churns
+       *  (analytics, experiments), and keying on all of it re-minted on nearly every call (#3044). A
+       *  header with no session cookie falls back to itself — callers refuse that case before here. */
       key(msid, cookieHeader) {
+        const session = /(?:^|;\s*)wixSession2=([^;]*)/.exec(cookieHeader)?.[1] ?? cookieHeader;
         return sha256Hex2(`${msid}
-${cookieHeader}`);
+${session}`);
       }
       async instance(msid, cookieHeader, now = Date.now()) {
+        return (await this.entry(msid, cookieHeader, now)).instance;
+      }
+      /** The instance and the time this cache stops trusting it (#3044: the web host caches until then). */
+      async entry(msid, cookieHeader, now = Date.now()) {
         const key2 = this.key(msid, cookieHeader);
         const hit = this.cache.get(key2);
-        if (hit && hit.expiresAt > now) return hit.instance;
+        if (hit && hit.expiresAt - OWNER_REFRESH_MARGIN_MS > now) return { instance: hit.instance, expiresAt: hit.expiresAt };
         const res = await this.fetchImpl(`${ONE_APP_SESSION}/${msid}/signed-instance?signed_instance_type=User`, {
           method: "GET",
           headers: { Cookie: cookieHeader }
@@ -15995,8 +16004,9 @@ ${cookieHeader}`);
         }
         if (res.status < 200 || res.status >= 300 || !j.signedInstance)
           throw new Error(`owner mint failed (${res.status})`);
-        this.cache.set(key2, { instance: j.signedInstance, expiresAt: now + this.ttlMs });
-        return j.signedInstance;
+        const entry = { instance: j.signedInstance, expiresAt: now + this.ttlMs };
+        this.cache.set(key2, entry);
+        return { ...entry };
       }
       /** Drop a cached instance (e.g. after a 401 from wixapis) so the next call re-mints. */
       invalidate(msid, cookieHeader) {
@@ -18857,6 +18867,7 @@ function shouldRevealError(args) {
 var EMAIL_RE, URL_HOST_RE, INTEGER_RE, NUMBER_RE;
 var init_validation = __esm({
   "../../core/ts/src/validation.ts"() {
+    "use strict";
     EMAIL_RE = /^[A-Za-z0-9._%+-]+@[A-Za-z0-9-]+(\.[A-Za-z0-9-]+)*\.[A-Za-z]{2,}$/;
     URL_HOST_RE = /^[A-Za-z0-9-]+(\.[A-Za-z0-9-]+)*(:[0-9]+)?$/;
     INTEGER_RE = /^[+-]?[0-9]+$/;
@@ -22281,6 +22292,7 @@ function validateWorkerSubtree(raw, slotId, policy, actionCatalog) {
 var WORKER_SUBTREE_CEILINGS, ID_PART, ACTION_ID;
 var init_worker_subtree = __esm({
   "../../core/ts/src/worker-subtree.ts"() {
+    "use strict";
     init_worker_subtree_safe_types_generated();
     WORKER_SUBTREE_CEILINGS = Object.freeze({
       maxEncodedBytes: 65536,
@@ -43027,6 +43039,22 @@ ${releaseId}`;
           }
         });
       }
+      if (path === "/v1/owner/instance") {
+        if (opts.webwixBridge === false) return json3(503, { error: "webwix_bridge_disabled" });
+        if (!webwixOwnerRungOn()) return json3(503, { error: "webwix_owner_disabled" });
+        const msid = url.searchParams.get("msid") ?? "";
+        if (!isSafeMsid(msid)) return json3(400, { error: "webwix_owner_bad_msid" });
+        const cookie = request.headers.get("cookie") ?? "";
+        if (!/wixSession2=/.test(cookie)) return json3(401, { error: "webwix_owner_no_session" });
+        try {
+          const entry = await webwixOwnerInstances.entry(msid, cookie);
+          return json3(200, { ...entry, expiresInMs: Math.max(0, entry.expiresAt - Date.now()) }, { "cache-control": "no-store" });
+        } catch (e) {
+          const msg = String(e?.message ?? e);
+          if (/owner mint failed \(5\d\d\)/.test(msg) || !msg.includes("owner mint failed")) return json3(502, { error: "webwix_bridge_upstream_failed" });
+          return json3(403, { error: "webwix_owner_mint_failed" });
+        }
+      }
       if (path === "/v1/owner/sites") {
         if (!webwixOwnerRungOn()) return json3(503, { error: "webwix_owner_disabled" });
         const cookie = request.headers.get("cookie") ?? "";
@@ -43791,19 +43819,19 @@ var init_preview_assets_generated = __esm({
   "../../packages/serve/src/preview-assets.generated.ts"() {
     init_preview_assets_format();
     PREVIEW_ASSET_MANIFEST = [
-      { key: "assets/index-BHbI7Cmq.js", contentType: "application/javascript; charset=utf-8", offset: 8, length: 994462, sha256: "f4589e2d3922fada826a38cbf29c40cfbd124903a29c07c32b93f7019e417e05" },
-      { key: "fonts/WixMadeforDisplay-Bold.ttf", contentType: "font/ttf", offset: 994470, length: 90924, sha256: "ec4c7d63772d980d6e147b2df6215fd2737e4b04cebe0cf7e11dc695fb63cdcf" },
-      { key: "fonts/WixMadeforDisplay-ExtraBold.ttf", contentType: "font/ttf", offset: 1085394, length: 90984, sha256: "bf4c16a2774edd38a921edf3099469866cd74c094fd596f3fa4e81f54a04dfaa" },
-      { key: "fonts/WixMadeforDisplay-Medium.ttf", contentType: "font/ttf", offset: 1176378, length: 90980, sha256: "368faca44fb9f7207e4af784e94750b1ee59c1098b8689e0f4a918926f244fb5" },
-      { key: "fonts/WixMadeforDisplay-Regular.ttf", contentType: "font/ttf", offset: 1267358, length: 90872, sha256: "97ed8f1a6772abe26e3d8af5cecfc4b02faa94497d585b0398b5053b739a70c1" },
-      { key: "fonts/WixMadeforDisplay-SemiBold.ttf", contentType: "font/ttf", offset: 1358230, length: 90980, sha256: "642feab8a48ddf6c7a89d7c2a7c0edfa0e6e773f671287e460e222703563191e" },
-      { key: "fonts/WixMadeforText-Bold.ttf", contentType: "font/ttf", offset: 1449210, length: 108636, sha256: "37c179b4fefb63ea9637322b84583a2df53aa226c150294eea1675c14b1b8e29" },
-      { key: "fonts/WixMadeforText-ExtraBold.ttf", contentType: "font/ttf", offset: 1557846, length: 109084, sha256: "62e2fe4718129f36ecdb0ae4de385bd6b81ecc876146447167c6c140fad699a9" },
-      { key: "fonts/WixMadeforText-Medium.ttf", contentType: "font/ttf", offset: 1666930, length: 109048, sha256: "4ecf270136af928612c76fe4ebade91d8156975e5ea4c0cf9225501dd1788e02" },
-      { key: "fonts/WixMadeforText-Regular.ttf", contentType: "font/ttf", offset: 1775978, length: 107700, sha256: "dee56f09fd3efc127c1ea95557edc74110c1460a46287da36e0af25efd341ef5" },
-      { key: "fonts/WixMadeforText-SemiBold.ttf", contentType: "font/ttf", offset: 1883678, length: 88108, sha256: "dced97a77624bc5f8b1ae65850360908297f4588e09feb6f22792d29dc7e765b" },
-      { key: "index.html", contentType: "text/html; charset=utf-8", offset: 1971786, length: 4448, sha256: "246aa990caa5f3d2b93be16c284909d3cd339608304a0378eb838ea6eb21d21c" },
-      { key: "t5-frame.html", contentType: "text/html; charset=utf-8", offset: 1976234, length: 13784, sha256: "cfb9465254fab84f0e084bb4542c282758ea29774b5f172840cc0b9e4194ef89" }
+      { key: "assets/index-DKlP06hp.js", contentType: "application/javascript; charset=utf-8", offset: 8, length: 997374, sha256: "9dd7ca28e467c7715af80eb404682bcd75804fee6941c8ae30cacdb542385854" },
+      { key: "fonts/WixMadeforDisplay-Bold.ttf", contentType: "font/ttf", offset: 997382, length: 90924, sha256: "ec4c7d63772d980d6e147b2df6215fd2737e4b04cebe0cf7e11dc695fb63cdcf" },
+      { key: "fonts/WixMadeforDisplay-ExtraBold.ttf", contentType: "font/ttf", offset: 1088306, length: 90984, sha256: "bf4c16a2774edd38a921edf3099469866cd74c094fd596f3fa4e81f54a04dfaa" },
+      { key: "fonts/WixMadeforDisplay-Medium.ttf", contentType: "font/ttf", offset: 1179290, length: 90980, sha256: "368faca44fb9f7207e4af784e94750b1ee59c1098b8689e0f4a918926f244fb5" },
+      { key: "fonts/WixMadeforDisplay-Regular.ttf", contentType: "font/ttf", offset: 1270270, length: 90872, sha256: "97ed8f1a6772abe26e3d8af5cecfc4b02faa94497d585b0398b5053b739a70c1" },
+      { key: "fonts/WixMadeforDisplay-SemiBold.ttf", contentType: "font/ttf", offset: 1361142, length: 90980, sha256: "642feab8a48ddf6c7a89d7c2a7c0edfa0e6e773f671287e460e222703563191e" },
+      { key: "fonts/WixMadeforText-Bold.ttf", contentType: "font/ttf", offset: 1452122, length: 108636, sha256: "37c179b4fefb63ea9637322b84583a2df53aa226c150294eea1675c14b1b8e29" },
+      { key: "fonts/WixMadeforText-ExtraBold.ttf", contentType: "font/ttf", offset: 1560758, length: 109084, sha256: "62e2fe4718129f36ecdb0ae4de385bd6b81ecc876146447167c6c140fad699a9" },
+      { key: "fonts/WixMadeforText-Medium.ttf", contentType: "font/ttf", offset: 1669842, length: 109048, sha256: "4ecf270136af928612c76fe4ebade91d8156975e5ea4c0cf9225501dd1788e02" },
+      { key: "fonts/WixMadeforText-Regular.ttf", contentType: "font/ttf", offset: 1778890, length: 107700, sha256: "dee56f09fd3efc127c1ea95557edc74110c1460a46287da36e0af25efd341ef5" },
+      { key: "fonts/WixMadeforText-SemiBold.ttf", contentType: "font/ttf", offset: 1886590, length: 88108, sha256: "dced97a77624bc5f8b1ae65850360908297f4588e09feb6f22792d29dc7e765b" },
+      { key: "index.html", contentType: "text/html; charset=utf-8", offset: 1974698, length: 4448, sha256: "a21d7d8d7acdce79ccd442b4137814a17739998360e5b11fc74958c55b77ce30" },
+      { key: "t5-frame.html", contentType: "text/html; charset=utf-8", offset: 1979146, length: 13784, sha256: "cfb9465254fab84f0e084bb4542c282758ea29774b5f172840cc0b9e4194ef89" }
     ];
   }
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wix/himalaya-cli",
-  "version": "0.987.0",
+  "version": "0.989.0",
   "type": "module",
   "description": "himi — the Himalaya authoring CLI. Build a Tier-5 content package on your own machine, push it to the production serve as a draft, preview it on web + Himi Player, and read worker logs back — the remote dev loop. Wraps @himalaya/serve-cli for transport.",
   "keywords": [
@@ -65,5 +65,5 @@
       "artifactId": "himalaya-cli"
     }
   },
-  "falconPackageHash": "3f79c893fa88aecaae73386660fd819cce12d5a671bdf832dfbe7f39"
+  "falconPackageHash": "67a573e97c057c3bf277ed30655a7855e28d5c899c59b41eac1f3c85"
 }

package/templates/beauty-salon-owner/tier5-src/_shared/aria-chat.ts

@@ -46,6 +46,7 @@ import { isWebUrl } from "./aria-widget-model.js";
 import { NO_WIDGET, activeWidgetOf, asyncAdvanced, type SubtreeSlot, type WidgetOptionRow, type WidgetView }
   from "./aria-widget-view.js";
 import { substituteSelection } from "./aria-widget-model.js";
+import { LOCAL_ID_PREFIX, createRowMemo, mintLocalId, transcriptKeys, type RowMemo } from "./aria-hot-path.js";
 
 // ---------------------------------------------------------------------------
 // Shapes
@@ -119,6 +120,9 @@ export interface AriaChatState {
    *  question twice found the FIRST copy already in the transcript, dropped the
    *  second bubble off the screen, and declared the turn finished. */
   _pendingAfter: number;
+  /** The bubble id of `_pending` while the server has not echoed it — minted
+   *  once per send (`mintLocalId`) so every tick re-appends the SAME row. */
+  _pendingId: string;
   /** Server ASSISTANT-turn count at that same moment. The turn is over when the
    *  server holds more than this — read from the transcript ALONE. Gating it on
    *  the user's message having been echoed back instead meant a service that
@@ -573,33 +577,63 @@ export function plainBubble(id: string, role: string, who: string, content: stri
  *
  *  The widgets themselves are dropped here; rendering them is #2605 onward. A
  *  reply that was nothing but a widget therefore has empty prose and is filtered
- *  out below, which is deliberate: an empty bubble is a visible defect. */
-export function toBubbles(msgs: ConversationMessage[], assistantName: string, youName = "You"): AriaBubble[] {
-  return msgs
-    .map((m, i) => {
-      const raw = messageText(m);
-      const role = m.role || "ASSISTANT";
-      // Only assistant turns carry envelopes; a user's own text is literal, and
-      // scanning it would let an owner who typed `<<…>>` erase their own message.
-      // HIDDEN spans go first: the service marks text as transcript-only that
-      // way, and an aborted turn consists of nothing else. Then envelopes, then
-      // the markdown stripper — each stage handing on only what a reader should
-      // actually see.
-      // A row the service is still writing is scanned as STREAMING: an
-      // envelope whose `>>` has not arrived yet is held back rather than
-      // painted as raw JSON until the row finishes.
-      const prose = role === "USER" ? raw : proseOfParts(scanEnvelopes(stripHidden(raw), 0, !stillWriting(m)).parts);
-      return {
-        id: m.id || `m${i}`,
-        role,
-        who: role === "USER" ? youName : assistantName,
-        content: role === "USER" ? prose : stripMarkdown(prose),
-        notUser: role !== "USER",
-        notAria: role === "USER",
-        ...linkFieldsOf(prose, role),
-      };
-    })
-    .filter((b) => b.content && b.content.trim());
+ *  out below, which is deliberate: an empty bubble is a visible defect.
+ *
+ *  Pass a `memo` on a path that re-reads the transcript (every poll does): a
+ *  message whose id, text and writing state are unchanged since the last read
+ *  reuses the bubble built then instead of running the stages above again — see
+ *  `aria-hot-path.ts` rule 1. Without one, every bubble is built fresh; the two
+ *  are equivalent. */
+export function toBubbles(
+  msgs: ConversationMessage[], assistantName: string, youName = "You", memo?: BubbleMemo,
+): AriaBubble[] {
+  const ids = transcriptKeys(msgs);
+  const out: AriaBubble[] = [];
+  try {
+    for (let i = 0; i < msgs.length; i++) {
+      const m = msgs[i];
+      const role = m.role || "ASSISTANT", raw = messageText(m), id = ids[i];
+      const who = role === "USER" ? youName : assistantName;
+      // Part of the memo key, not just an input: a row that FINISHES writing
+      // can keep exactly the same text and still render differently (a held
+      // back envelope is released), so text alone would serve the stale bubble.
+      const writing = role !== "USER" && stillWriting(m);
+      const build = () => bubbleOf(id, role, who, raw, writing);
+      const b = memo ? memo.row(id, raw, `${role}\u0000${who}\u0000${writing ? "w" : ""}`, build) : build();
+      if (b) out.push(b);
+    }
+  } finally {
+    memo?.sweep();
+  }
+  return out;
+}
+
+/** Bubbles are built from one message's raw text; `null` is "paints nothing". */
+export type BubbleMemo = RowMemo<AriaBubble | null>;
+export const createBubbleMemo = (): BubbleMemo => createRowMemo<AriaBubble | null>();
+
+function bubbleOf(id: string, role: string, who: string, raw: string, writing: boolean): AriaBubble | null {
+  // Only assistant turns carry envelopes; a user's own text is literal, and
+  // scanning it would let an owner who typed `<<…>>` erase their own message.
+  // HIDDEN spans go first: the service marks text as transcript-only that
+  // way, and an aborted turn consists of nothing else. Then envelopes, then
+  // the markdown stripper — each stage handing on only what a reader should
+  // actually see.
+  // A row the service is still writing is scanned as STREAMING: an
+  // envelope whose `>>` has not arrived yet is held back rather than
+  // painted as raw JSON until the row finishes.
+  const prose = role === "USER" ? raw : proseOfParts(scanEnvelopes(stripHidden(raw), 0, !writing).parts);
+  const content = role === "USER" ? prose : stripMarkdown(prose);
+  if (!content || !content.trim()) return null;
+  return {
+    id,
+    role,
+    who,
+    content,
+    notUser: role !== "USER",
+    notAria: role === "USER",
+    ...linkFieldsOf(prose, role),
+  };
 }
 
 /** The reply the Copy / Regenerate row acts on: the LAST bubble, when it is an
@@ -648,11 +682,14 @@ export function argText(arg: AriaActionArg): string {
  *  when we sent. Until then it is appended so the owner's message does not
  *  vanish mid-turn. */
 export function reconcile(
-  server: AriaBubble[], pending: string, pendingAfter: number, youName = "You",
+  server: AriaBubble[], pending: string, pendingAfter: number, youName = "You", pendingId = "",
 ): { messages: AriaBubble[]; pending: string } {
   if (!pending) return { messages: server, pending: "" };
   if (countRole(server, "USER") > pendingAfter) return { messages: server, pending: "" };
-  return { messages: [...server, plainBubble(`pending-${server.length}`, "USER", youName, pending)], pending };
+  // `pendingId` is empty only for state persisted before ids were minted; a
+  // fixed fallback still keeps that one row stable across ticks.
+  const id = pendingId || `${LOCAL_ID_PREFIX}pending`;
+  return { messages: [...server, plainBubble(id, "USER", youName, pending)], pending };
 }
 
 /** How many turns of one role the transcript holds. Counted over BUBBLES rather
@@ -1029,7 +1066,7 @@ export function createAriaChat(o: AriaChatOptions): AriaChatCore {
   const initialState: AriaChatState = {
     status: "loading", statusText: "", error: "", input: "", copyNote: "", replyActionsHidden: true,
     messages: [], prompts: [], _convId: "", _siteId: "", _pending: "",
-    _pendingAfter: 0, _replyAfter: 0, _srvUsers: 0, _srvAssistants: 0,
+    _pendingAfter: 0, _pendingId: "", _replyAfter: 0, _srvUsers: 0, _srvAssistants: 0,
     _abortId: "", _turnId: "", stopHidden: true, ok: false,
     widget: NO_WIDGET,
   };
@@ -1047,6 +1084,17 @@ export function createAriaChat(o: AriaChatOptions): AriaChatCore {
    *  in-flight conversation. The latch is cleared once settled, so a failed
    *  create is retried rather than remembered. */
   let creating: { site: string; promise: Promise<string> } | null = null;
+
+  /** Bubbles built on the previous transcript read, reused while their message
+   *  is unchanged — every poll re-reads the WHOLE transcript, and re-deriving
+   *  every bubble on each one is the cost `aria-hot-path.ts` rule 1 removes.
+   *  Bounded by the latest read: rows it did not contain are forgotten. */
+  const bubbleMemo = createBubbleMemo();
+
+  /** Last number `mintLocalId` handed out. Not state: `mintLocalId` skips every
+   *  id already on screen, so a cold start resetting it cannot collide. */
+  let localSeq = 0;
+
   function createOnce(site: string): Promise<string> {
     if (creating && creating.site === site) return creating.promise;
     const promise = createConversation(assistantConfig, origin)
@@ -1270,7 +1318,7 @@ export function createAriaChat(o: AriaChatOptions): AriaChatCore {
     for (let n = 0; n < BUSY_LOOP_ROUNDS; n++) {
       const gm = await getConversationMessages(convId);
       const raw = messagesOf(gm);
-      const bubbles = toBubbles(raw, assistant(), you());
+      const bubbles = toBubbles(raw, assistant(), you(), bubbleMemo);
       if (bubbles.length) server = bubbles;
       seen = raw;
       // The turn is over when the SERVER holds an assistant answer — which a
@@ -1305,7 +1353,27 @@ export function createAriaChat(o: AriaChatOptions): AriaChatCore {
     turnSeq += 1;
     // Optimistic first: the owner's message and the typing line are part of the
     // state this action RETURNS, so on the `_poll` path they paint immediately.
-    const optimistic: AriaBubble[] = [...s.messages, plainBubble(`u${s.messages.length}`, "USER", you(), content)];
+    // Its id is the LOCAL SEND ID, minted here and carried as `_pendingId`, the
+    // one `reconcile` re-appends it under on every tick, so the row keeps one
+    // identity until the server's copy lands.
+    //
+    // A local bubble already on screen with these exact words is this message's
+    // FAILED attempt (an identical PENDING one is refused as a duplicate), so a
+    // retry takes over its id and replaces it rather than painting the same
+    // words twice. Matched on the words themselves — never on a hash of them.
+    const failedCopy = s.messages.find((b) =>
+      b.role === "USER" && b.id.startsWith(LOCAL_ID_PREFIX) && b.content === content);
+    let localId: string;
+    if (failedCopy) {
+      localId = failedCopy.id;
+    } else {
+      const minted = mintLocalId(localSeq, (id) => s.messages.some((b) => b.id === id));
+      localSeq = minted.seq;
+      localId = minted.id;
+    }
+    const optimistic: AriaBubble[] = [
+      ...s.messages.filter((b) => b.id !== localId), plainBubble(localId, "USER", you(), content),
+    ];
     const base: AriaChatState = {
       // `copyNote: ""` — a Copy confirmation belongs to the moment, and a new
       // turn ends it. Left in place it would sit under the next reply saying
@@ -1316,7 +1384,7 @@ export function createAriaChat(o: AriaChatOptions): AriaChatCore {
       // on a stale turn id would look for an answer that already exists. Both
       // are replaced the moment this send knows its own id.
       _abortId: "", _turnId: "",
-      statusText: typingText(), messages: optimistic, _pending: content,
+      statusText: typingText(), messages: optimistic, _pending: content, _pendingId: localId,
       // Mark the turn against the LAST COUNTS WE SAW, not against our own
       // message list — the greeting is a local bubble the server never had, so
       // counting `messages` would mark the turn one assistant reply ahead and
@@ -1508,15 +1576,33 @@ export function createAriaChat(o: AriaChatOptions): AriaChatCore {
         // this send was working on and is still the one we captured; otherwise it
         // belongs to another turn and must survive.
         : (supersedes && stalledTurn === latch ? null : stalledTurn);
+      // A FOLLOW-UP failing does not end the turn before it. Asking again while
+      // an answer is still being written is supported (`isDuplicateSend`), so
+      // the earlier turn can be in flight right now — and marking the screen
+      // `ready` here threw it away: its Stop went, and `tick` (which only slows
+      // the ladder on a turn it saw END) never slowed it, so the fast rate ran
+      // for as long as the screen stayed open (aria-hot-path.ts rule 4). Only in
+      // the same conversation: a turn in another one is not this screen's.
+      const keepsEarlier = turnInFlight(s) && convId === s._convId;
+      const earlier: Partial<AriaChatState> = keepsEarlier
+        ? { status: s.status, _pending: s._pending, _pendingId: s._pendingId, _pendingAfter: s._pendingAfter,
+            _replyAfter: s._replyAfter, _abortId: s._abortId, _turnId: s._turnId }
+        : { status: "ready", _pending: "" };
+      const slots = failureSlots(e, unavailableText);
       return {
-        ...base, status: "ready", _pending: "",
+        ...base, ...earlier,
         // `_siteId` moves with the id or neither does: a conversation remembered
         // without the site it belongs to reads as another business's on the next
         // send, and gets replaced instead of retried.
         _convId: convId, _siteId: convId === s._convId ? s._siteId : site,
         // Sets BOTH error and statusText, so it must come after the `statusText: ""`
         // this object used to carry — otherwise the literal would blank the sentence.
-        ...failureSlots(e, unavailableText),
+        ...slots,
+        // …except that a kept turn keeps its own status line. A real failure
+        // puts its sentence in `error` and blanks `statusText`, which here would
+        // leave Stop on screen beside no "Aria is typing…" until the answer
+        // landed. A boundary refusal's neutral sentence still wins.
+        ...(keepsEarlier ? { statusText: slots.statusText || s.statusText } : {}),
       };
     }
   }
@@ -1680,6 +1766,14 @@ export function createAriaChat(o: AriaChatOptions): AriaChatCore {
 
     load: async (s) => {
       const site = siteOf();
+      // Every branch below that puts a DIFFERENT conversation on screen abandons
+      // whatever turn was in flight — a business switch mid-turn does exactly
+      // that — so it re-arms the ladder slow, as `newChat` does. Otherwise the
+      // fast rate the send armed is never slowed: `tick` only slows on a turn it
+      // saw end (aria-hot-path.ts rule 4).
+      const wasMidTurn = !!s._pending || s.status === "sending";
+      const leaving = (next: AriaChatState): AriaChatState =>
+        wasMidTurn && o.poll ? cadence(next, o.poll.idleMs, null) : next;
       // Resume: the history screen routes here with a conversationId. Only
       // honour it for the site it belongs to — a stale id from another business
       // must not be re-opened.
@@ -1697,13 +1791,13 @@ export function createAriaChat(o: AriaChatOptions): AriaChatCore {
         try {
           const gm = await getConversationMessages(resumeId);
           const raw = messagesOf(gm);
-          const bubbles = toBubbles(raw, assistant(), you());
+          const bubbles = toBubbles(raw, assistant(), you(), bubbleMemo);
           const resumed = bubbles.length ? bubbles : greetingOnly();
           // `copyNote: ""` — a resumed transcript ends in a reply, so the row is
           // shown at once; a note carried over would say "Copied" beside an
           // answer from a different conversation that nobody copied.
-          return { ...s, status: "ready", _convId: resumeId, _siteId: site, _pending: "", statusText: "", error: "", copyNote: "",
-            messages: resumed, ...observed(raw, s.widget), prompts: promptsFor(resumed, promptList()) };
+          return leaving({ ...s, status: "ready", _convId: resumeId, _siteId: site, _pending: "", statusText: "", error: "", copyNote: "",
+            messages: resumed, ...observed(raw, s.widget), prompts: promptsFor(resumed, promptList()) });
         } catch { /* expired or unreachable — fall through to a fresh one */ }
       }
       // Opening a screen runs `load` more than once — the bundle self-kicks at
@@ -1735,12 +1829,12 @@ export function createAriaChat(o: AriaChatOptions): AriaChatCore {
         return { ...s, status: "ready", messages, prompts: promptsFor(messages, promptList()) };
       }
       try {
-        return { ...s, status: "ready", _convId: await createOnce(site), _siteId: site, _pending: "", statusText: "",
-          messages: greetingOnly(), ...observed([]), prompts: promptList() };
+        return leaving({ ...s, status: "ready", _convId: await createOnce(site), _siteId: site, _pending: "", statusText: "",
+          messages: greetingOnly(), ...observed([]), prompts: promptList() });
       } catch (e) {
         // Even if create fails, show the greeting; submit retries the create.
-        return { ...s, status: "ready", _convId: "", _siteId: site, _pending: "", ...failureSlots(e, unavailableText),
-          messages: greetingOnly(), ...observed([]), prompts: promptList() };
+        return leaving({ ...s, status: "ready", _convId: "", _siteId: site, _pending: "", ...failureSlots(e, unavailableText),
+          messages: greetingOnly(), ...observed([]), prompts: promptList() });
       }
     },
 
@@ -1842,14 +1936,14 @@ export function createAriaChat(o: AriaChatOptions): AriaChatCore {
         // `stop` holds a snapshot predating this read and will overwrite
         // whatever we write. A tick of a NEWER epoch is not stale, not fenced.
         if (turnSeq !== seq || abortingEpochs.has(seq)) return undefined;
-        const server = toBubbles(raw, assistant(), you());
+        const server = toBubbles(raw, assistant(), you(), bubbleMemo);
         // A transcript that renders to nothing is not necessarily an empty one:
         // a reply made entirely of widgets leaves no bubble behind. So the bail
         // is on the RAW transcript — bailing on the bubbles is what let such a
         // reply go unnoticed and pinned the ladder fast forever. Safe to return
         // `s` here: the guard above proved this tick is still current.
         if (!raw.length) return s;
-        const { messages, pending } = reconcile(server, s._pending, s._pendingAfter, you());
+        const { messages, pending } = reconcile(server, s._pending, s._pendingAfter, you(), s._pendingId);
         // …but still never PAINT nothing over something. `messages` is only
         // adopted when it has content: a transcript that renders empty leaves
         // the screen as it was (the greeting, or the last good turn) while the

package/templates/beauty-salon-owner/tier5-src/_shared/aria-hot-path.ts

@@ -0,0 +1,167 @@
+// The Aria transcript's hot path — the rules it is written to, and the two
+// primitives that make them hold.
+//
+// Adapted from `native-apps/PERFORMANCE.md` in wix-private/aria-native-apps, which
+// states eleven rules, each "a class of shipped regression". Most of them govern
+// 30 Hz streaming, which this app does not do yet (#2612), and adopting all eleven
+// for a POLLED chat would be cargo-culting. These four apply now (#2623):
+//
+//  1. NEVER RE-DERIVE THE WHOLE TRANSCRIPT PER TICK. Every poll re-reads the full
+//     transcript, and turning a message into a bubble is the expensive step —
+//     the envelope scan, the markdown stripper (a dozen regex passes) and the
+//     link scan. So a bubble is built once per (identity, content) and reused
+//     while its message is unchanged: a poll that brings nothing new builds
+//     nothing. `createRowMemo`.
+//     Measured per poll over an unchanged transcript of mixed-markdown replies
+//     (bubbles + both turn counts), median, QuickJS — the no-JIT floor a device
+//     worker realm runs at:
+//         messages     20      100     500
+//         before       3 ms    16 ms   79 ms
+//         after        0 ms     1 ms    6 ms   (≈5 ms of it is `countTurns`)
+//     Node's JIT shows the same ratio: 2.4 ms → 0.21 ms at 500.
+//
+//  2. A PER-TICK IDENTITY IS A CACHE FLUSH. The memo is keyed by the MESSAGE's
+//     identity, never by anything minted per read. A message that is still
+//     growing — the streaming case — keeps its id, so it overwrites its own slot
+//     in place and every settled row stays built. The memo's bound is the
+//     transcript itself (rows the latest read did not contain are dropped), so
+//     there is no LRU for a churning key to evict settled entries out of.
+//
+//  3. TRANSCRIPT IDENTITY IS THE SERVER MESSAGE ID — or the LOCAL SEND ID until
+//     the server acknowledges the message. Never an array index: an index names
+//     a POSITION, and the moment anything before it is dropped (an empty
+//     placeholder, a hidden-only row, a windowed read) the same index names a
+//     different message. The bubble id is also the row's stable test id
+//     (`<screen>.msg_<id>`, invariant 27). `transcriptKeys`, `mintLocalId`.
+//
+//  4. EVERY REPEATING CLOCK HAS AN OWNER AND STOPS ON EVERY EXIT PATH. The only
+//     clock here is the reply ladder, `_poll` id `aria-turn`, and its owner is
+//     the HOST's PollScheduler — a worker has no timers, and `PollDirective` has
+//     no stop verb. So, stated explicitly rather than implied:
+//       - one id, ever: no second `_poll` is armed (async-job progress rides the
+//         same ladder for exactly this reason — see `readJobState`);
+//       - every path that ENDS or ABANDONS a turn re-arms it at the IDLE rate
+//         (reply, Stop, ➕ mid-turn, a load that leaves the turn behind),
+//         because slowing is the only lever a worker holds;
+//       - a path that does NOT end the turn must not pretend to. A follow-up
+//         whose send failed used to discard the turn still in flight — marking
+//         the screen idle while the first answer was still being written — so
+//         `tick` never saw the turn end and the fast rate ran for as long as
+//         the screen stayed open (30 reads a minute instead of 4);
+//       - the host stops it on background, pooling and teardown (poll-parity).
+//     What it cannot do yet is stop while the screen is visible and idle: that
+//     needs a stop verb on the directive across every host arm.
+//
+// Rules for streaming (tail-only parsing, publish coalescing, frame-clock
+// drivers) and the native app's device budgets (cold start, frame time, hangs)
+// are deliberately NOT adopted here: nothing in this repo measures them for
+// Aria, and a budget nobody measures is decoration. Each rule above is pinned by
+// a test instead — `core/dev-server/tests/aria-hot-path.test.ts`.
+//
+// Dependency-free on purpose: the tests import this file directly.
+
+/** Prefix of every id minted for a bubble the server has not echoed yet. */
+export const LOCAL_ID_PREFIX = "local-";
+
+/** Mint the id for the bubble of a message the owner just sent.
+ *
+ *  MINTED once per send and then carried in state (`_pendingId`), so the
+ *  optimistic bubble `send` paints and the one `reconcile` re-appends on every
+ *  tick are the SAME row until the server's copy replaces it. It used to be
+ *  `u<list length>` in one and `pending-<server length>` in the other — two ids
+ *  for one message, both positions.
+ *
+ *  Deliberately NOT derived from the text. A 32-bit hash of it collides —
+ *  different words, one id — and then sending one message silently replaced
+ *  another's failed bubble and took over its identity. A retry of the SAME send
+ *  reuses its failed copy's id instead (see `send`).
+ *
+ *  `taken` is every id on screen, so a counter that a cold start reset can never
+ *  mint an id a persisted bubble still carries. */
+export function mintLocalId(seq: number, taken: (id: string) => boolean): { id: string; seq: number } {
+  let n = seq;
+  let id: string;
+  do { id = `${LOCAL_ID_PREFIX}${++n}`; } while (taken(id));
+  return { id, seq: n };
+}
+
+/** One transcript row, as far as identity is concerned. */
+export interface IdentityRow {
+  id?: unknown;
+}
+
+/** A usable server id: a non-empty string, or a number (kept as its string). */
+function serverIdOf(id: unknown): string {
+  if (typeof id === "string") return id;
+  if (typeof id === "number" && Number.isFinite(id)) return String(id);
+  return "";
+}
+
+/** A stable key per row: the server id when there is one.
+ *
+ *  A row with no id is keyed RELATIVE TO THE NEAREST SERVER ID BEFORE IT —
+ *  `after-<id>-<k>` for the k-th id-less row since that anchor, `head-<k>` before
+ *  any. Never by its content, and never by its absolute position:
+ *   - content would re-key a row that is still being written on every read, the
+ *     exact case where identity matters most;
+ *   - an absolute index re-keys every later row the moment anything before it
+ *     is dropped (a placeholder, a hidden-only row, a windowed read).
+ *  What remains unstable is narrow and stated: dropping an id-less row between
+ *  the same anchor and this one shifts `k`, and the `head-` rows have no anchor
+ *  to hold them. The service names its rows; this is the fallback. */
+export function transcriptKeys(rows: ReadonlyArray<IdentityRow>): string[] {
+  let anchor = "";
+  let k = 0;
+  return rows.map((r) => {
+    const id = serverIdOf(r.id);
+    if (id) { anchor = id; k = 0; return id; }
+    return anchor ? `after-${anchor}-${k++}` : `head-${k++}`;
+  });
+}
+
+/** Per-row derivation memo for a transcript that is re-read wholesale.
+ *
+ *  Use: call `row` once per message of one read, then `sweep`. A row is rebuilt
+ *  only when its key is new or its `input` / `variant` changed.
+ *
+ *  BOUND: the rows of the latest completed read — `sweep` forgets every key that
+ *  read did not touch. So the memo never outgrows the transcript on screen, and
+ *  a conversation switch drops the previous one's rows at the first read.
+ *
+ *  Values are SHARED between reads. Callers must treat them as immutable, which
+ *  the transcript already is: every reducer here replaces `messages`, none
+ *  mutates a bubble in place. */
+export interface RowMemo<V> {
+  row(key: string, input: string, variant: string, build: () => V): V;
+  sweep(): void;
+  /** How many times `build` ran since creation — what a count test pins. */
+  readonly builds: number;
+  /** Rows currently held. */
+  readonly size: number;
+}
+
+export function createRowMemo<V>(): RowMemo<V> {
+  interface Entry { input: string; variant: string; value: V }
+  let live = new Map<string, Entry>();
+  let next = new Map<string, Entry>();
+  let builds = 0;
+  return {
+    row(key, input, variant, build) {
+      const e = next.get(key) ?? live.get(key);
+      if (e && e.input === input && e.variant === variant) {
+        next.set(key, e);
+        return e.value;
+      }
+      builds++;
+      const value = build();
+      next.set(key, { input, variant, value });
+      return value;
+    },
+    sweep() {
+      live = next;
+      next = new Map();
+    },
+    get builds() { return builds; },
+    get size() { return live.size; },
+  };
+}