bunnyquery 1.8.13 → 1.8.15

package/bunnyquery.js

@@ -857,18 +857,31 @@ Index the REMAINING windows - one record per row/item, looking at any page image
       part: { type: "link", label: truncateLabelForDisplay(urlLabel), fullLabel: urlLabel, href: originalHref, expired: false }
     });
   }
+  function canonicalizePathForm(value) {
+    if (!value) return value;
+    try {
+      return value.normalize("NFC");
+    } catch (e) {
+      return value;
+    }
+  }
   function linkUnavailableKeyForPath(remotePath) {
-    return "path:" + (remotePath || "");
+    return "path:" + canonicalizePathForm(remotePath || "");
   }
   function linkUnavailableKeyForHref(href) {
-    return "href:" + (href || "");
+    var carried = readExpiredAttachmentHref(href);
+    if (carried) return linkUnavailableKeyForPath(carried);
+    return "href:" + canonicalizePathForm(href || "");
   }
   function linkUnavailableKeysForPath(remotePath) {
     if (!remotePath) return [];
-    return [
+    var keys = [
       linkUnavailableKeyForPath(remotePath),
       linkUnavailableKeyForHref(buildDisplayExpiredAttachmentHref(remotePath))
     ];
+    return keys.filter(function(k, i) {
+      return keys.indexOf(k) === i;
+    });
   }
   function isLinkUnavailable(link, map) {
     if (!link || !map) return false;
@@ -1247,7 +1260,7 @@ Index the REMAINING windows - one record per row/item, looking at any page image
     if (link.remotePath) attrs.push('data-bq-remote-path="' + escapeInlineHtml(link.remotePath) + '"');
     if (link.fullLabel) attrs.push('data-bq-full-label="' + escapeInlineHtml(link.fullLabel) + '"');
     if (!preview) return "<a " + attrs.join(" ") + ">" + escapeInlineHtml(labelText) + "</a>";
-    return "<a " + attrs.join(" ") + '><img class="bq-img-preview" alt="' + escapeInlineHtml(full) + '" data-bq-img-path="' + escapeInlineHtml(link.remotePath || "") + '" data-bq-img-type="' + escapeInlineHtml(link.image ? link.image.contentType : "") + '" loading="lazy" decoding="async"><span class="bq-loader" data-bq-img-loader="1"></span><span class="bq-img-preview-caption" translate="no">' + escapeInlineHtml(labelText) + "</span></a>";
+    return "<a " + attrs.join(" ") + '><img class="bq-img-preview" alt="' + escapeInlineHtml(full) + '" data-bq-img-path="' + escapeInlineHtml(link.remotePath || "") + '" data-bq-img-type="' + escapeInlineHtml(link.image ? link.image.contentType : "") + '" decoding="async"><span class="bq-loader" data-bq-img-loader="1"></span><span class="bq-img-preview-caption" translate="no">' + escapeInlineHtml(labelText) + "</span></a>";
   }
 
   // src/engine/image_preview.ts
@@ -1327,31 +1340,48 @@ Index the REMAINING windows - one record per row/item, looking at any page image
     var warm = peekImagePreviewUrl(ctx, path);
     if (warm) {
       img.setAttribute("src", warm);
+      notifyLayoutChange(img, ctx, path);
       return;
     }
     resolveImagePreviewUrl(ctx, path, type).then(function(url) {
       if (img.getAttribute("data-bq-img-state") !== "loading") return;
       img.setAttribute("src", url);
+      notifyLayoutChange(img, ctx, path);
     }, function(e) {
       img.setAttribute("data-bq-img-state", "error");
+      notifyLayoutChange(img, ctx, path);
       if (ctx.onError) ctx.onError(path, e);
     });
   }
   function onImageError(img, ctx, path, type) {
     if (img.getAttribute("data-bq-img-retry") === "1") {
       img.setAttribute("data-bq-img-state", "error");
+      notifyLayoutChange(img, ctx, path);
       if (ctx.onError) ctx.onError(path, new Error("image preview failed to load"));
       return;
     }
     img.setAttribute("data-bq-img-retry", "1");
     img.removeAttribute("src");
+    notifyLayoutChange(img, ctx, path);
     resolveImagePreviewUrl(ctx, path, type, true).then(function(url) {
       img.setAttribute("src", url);
+      notifyLayoutChange(img, ctx, path);
     }, function(e) {
       img.setAttribute("data-bq-img-state", "error");
+      notifyLayoutChange(img, ctx, path);
       if (ctx.onError) ctx.onError(path, e);
     });
   }
+  function notifyLayoutChange(img, ctx, path) {
+    if (!ctx.onLayoutChange) return;
+    ctx.onLayoutChange(previewLayoutBox(img), path);
+  }
+  var PREVIEW_LAYOUT_BOX_SELECTOR = "a.bq-link-button.is-image-preview";
+  function previewLayoutBox(img) {
+    var closest = img.closest;
+    if (typeof closest !== "function") return img;
+    return closest.call(img, PREVIEW_LAYOUT_BOX_SELECTOR) || img;
+  }
 
   // src/engine/time.ts
   function wallClockNow() {
@@ -2389,6 +2419,327 @@ Index the REMAINING windows - one record per row/item, looking at any page image
     }
     return { messages: mapped, runningItemIds };
   }
+  function shouldRescueInFlightMessage(m, ctx) {
+    if (!m) return false;
+    if (m.isBackgroundTask) return false;
+    if (m._ownerKey !== void 0 && ctx.loadKey !== void 0 && m._ownerKey !== ctx.loadKey) return false;
+    if (m._serverItemId && ctx.hasServerId(m._serverItemId)) return false;
+    if (m._stageId) return true;
+    if (!m._serverItemId && ctx.pageHasPendingAssistant) return false;
+    if (m.isSendingToServer || m.isPendingQueued || m.isPendingInProcess || m.isPending) return true;
+    if (ctx.sending && m.role === "user") {
+      var next = ctx.next;
+      if (!next || next.isBackgroundTask || !next.isPending) return false;
+      return next._serverItemId === void 0 || next._serverItemId === m._serverItemId;
+    }
+    return false;
+  }
+
+  // src/engine/scroll_anchor.ts
+  var ROW_KEY_ATTR = "data-row-key";
+  var ROW_POS_ATTR = "data-row-pos";
+  var MAX_ALTS = 2;
+  var ALT_SCAN_LIMIT = 64;
+  var UNKNOWN_ROW_POS = "\0?";
+  function createScrollAnchor(options) {
+    var held = null;
+    var seen = typeof WeakMap === "function" ? /* @__PURE__ */ new WeakMap() : null;
+    function capture() {
+      var box = options.getBox();
+      if (!box || options.isStuck()) return null;
+      var boxTop = box.getBoundingClientRect().top;
+      var kids = box.children;
+      var fallback = null;
+      var fallbackAt = -1;
+      for (var i = 0; i < kids.length; i++) {
+        var el = kids[i];
+        if (!el || typeof el.getAttribute !== "function") continue;
+        var key = el.getAttribute(ROW_KEY_ATTR);
+        if (!key) continue;
+        var top = el.getBoundingClientRect().top - boxTop;
+        if (top + el.offsetHeight <= 0) continue;
+        if (top >= box.clientHeight) break;
+        var rawPos = el.getAttribute(ROW_POS_ATTR);
+        var pos = rawPos === null ? null : rawPos || UNKNOWN_ROW_POS;
+        var cand = {
+          key,
+          top,
+          pos,
+          scrollTop: box.scrollTop,
+          scrollHeight: box.scrollHeight,
+          el
+        };
+        if (rawPos === null) {
+          cand.alts = collectAlts(box, boxTop, i + 1);
+          return cand;
+        }
+        if (!fallback) {
+          fallback = cand;
+          fallbackAt = i;
+        }
+      }
+      if (fallback) {
+        fallback.alts = collectAlts(box, boxTop, fallbackAt + 1, true);
+        return fallback;
+      }
+      return {
+        key: null,
+        top: 0,
+        pos: null,
+        scrollTop: box.scrollTop,
+        scrollHeight: box.scrollHeight,
+        el: null
+      };
+    }
+    function collectAlts(box, boxTop, from, ordinaryOnly) {
+      var out = [];
+      var kids = box.children;
+      var stop = Math.min(kids.length, from + ALT_SCAN_LIMIT);
+      for (var i = from; i < stop && out.length < MAX_ALTS; i++) {
+        var el = kids[i];
+        if (!el || typeof el.getAttribute !== "function") continue;
+        var key = el.getAttribute(ROW_KEY_ATTR);
+        if (!key) continue;
+        var rawPos = el.getAttribute(ROW_POS_ATTR);
+        if (ordinaryOnly && rawPos !== null) continue;
+        out.push({
+          key,
+          top: el.getBoundingClientRect().top - boxTop,
+          pos: rawPos === null ? null : rawPos || UNKNOWN_ROW_POS,
+          el
+        });
+      }
+      return out.length ? out : void 0;
+    }
+    function findRow(box, anchor) {
+      var el = anchor.el;
+      if (el && el.parentNode === box) return el;
+      if (!anchor.key) return null;
+      var kids = box.children;
+      for (var i = 0; i < kids.length; i++) {
+        var kid = kids[i];
+        if (!kid || typeof kid.getAttribute !== "function") continue;
+        if (kid.getAttribute(ROW_KEY_ATTR) === anchor.key) return kid;
+      }
+      return null;
+    }
+    var sawFrozen = false;
+    var parked = null;
+    var parkedStuck = false;
+    var returning = false;
+    var wroteTop = -1;
+    var restoreExact = true;
+    var restorePinned = false;
+    function frozen() {
+      var f = !!options.isFrozen && options.isFrozen();
+      if (f) sawFrozen = true;
+      return f;
+    }
+    function restore(anchor, unbounded) {
+      if (frozen()) return;
+      var box = options.getBox();
+      if (!box || !anchor || options.isStuck()) return;
+      var el = findRow(box, anchor);
+      if (el) {
+        var livePos = el.getAttribute(ROW_POS_ATTR) || UNKNOWN_ROW_POS;
+        if (anchor.pos !== null && anchor.pos !== UNKNOWN_ROW_POS && livePos !== UNKNOWN_ROW_POS && livePos !== anchor.pos) el = null;
+      }
+      if (el) {
+        var boxTop = box.getBoundingClientRect().top;
+        var delta = el.getBoundingClientRect().top - boxTop - anchor.top;
+        var slack = Math.abs(box.scrollHeight - anchor.scrollHeight) + box.clientHeight;
+        if (!unbounded && (delta > slack || delta < -slack)) {
+          lost(box, anchor);
+          return;
+        }
+        var want = box.scrollTop + delta;
+        if (delta >= 1 || delta <= -1) box.scrollTop += delta;
+        wroteTop = box.scrollTop;
+        restorePinned = true;
+        restoreExact = box.scrollTop >= want - 1 && box.scrollTop <= want + 1;
+        held = {
+          key: anchor.key,
+          top: anchor.top,
+          pos: anchor.pos,
+          scrollTop: box.scrollTop,
+          scrollHeight: box.scrollHeight,
+          el,
+          // Carried, not dropped: one successful restore used to disarm the
+          // standbys for every later hold.
+          alts: anchor.alts
+        };
+        return;
+      }
+      var alts = anchor.alts;
+      for (var ai = 0; alts && ai < alts.length; ai++) {
+        var alt = alts[ai];
+        var ael = findRow(box, { key: alt.key, top: alt.top, pos: alt.pos, scrollTop: anchor.scrollTop, scrollHeight: anchor.scrollHeight, el: alt.el });
+        if (!ael) continue;
+        if (alt.pos !== null && alt.pos !== UNKNOWN_ROW_POS) {
+          var altLive = ael.getAttribute(ROW_POS_ATTR) || UNKNOWN_ROW_POS;
+          if (altLive !== UNKNOWN_ROW_POS && altLive !== alt.pos) continue;
+        }
+        var aboxTop = box.getBoundingClientRect().top;
+        var adelta = ael.getBoundingClientRect().top - aboxTop - alt.top;
+        var aslack = Math.abs(box.scrollHeight - anchor.scrollHeight) + box.clientHeight;
+        if (!unbounded && (adelta > aslack || adelta < -aslack)) continue;
+        var awant = box.scrollTop + adelta;
+        if (adelta >= 1 || adelta <= -1) box.scrollTop += adelta;
+        wroteTop = box.scrollTop;
+        restorePinned = true;
+        restoreExact = box.scrollTop >= awant - 1 && box.scrollTop <= awant + 1;
+        held = {
+          key: alt.key,
+          top: alt.top,
+          pos: alt.pos,
+          scrollTop: box.scrollTop,
+          scrollHeight: box.scrollHeight,
+          el: ael,
+          alts: alts.slice(ai + 1)
+        };
+        return;
+      }
+      lost(box, anchor);
+    }
+    function lost(box, anchor) {
+      held = null;
+      var grew = box.scrollHeight - anchor.scrollHeight;
+      if (grew > 0) {
+        box.scrollTop = anchor.scrollTop + grew;
+        wroteTop = box.scrollTop;
+        return;
+      }
+      if (options.rawFallback) {
+        box.scrollTop = anchor.scrollTop;
+        wroteTop = box.scrollTop;
+      }
+    }
+    function preserve(mutate) {
+      var anchor = capture();
+      var result = mutate();
+      restore(anchor);
+      return result;
+    }
+    function remember() {
+      var b0 = options.getBox();
+      if (returning && b0 && b0.scrollTop !== wroteTop) {
+        parked = null;
+        parkedStuck = false;
+        returning = false;
+      }
+      if (frozen()) return;
+      held = capture();
+    }
+    function hold() {
+      if (frozen()) return;
+      if (sawFrozen || returning) {
+        settleReturn();
+        return;
+      }
+      var box = options.getBox();
+      if (!box || options.isStuck()) {
+        held = null;
+        return;
+      }
+      if (!held) {
+        held = capture();
+        return;
+      }
+      if (box.scrollTop !== held.scrollTop) {
+        held = capture();
+        return;
+      }
+      restore(held);
+    }
+    function absorb(el) {
+      if (!el) return;
+      var box = options.getBox();
+      if (!box) return;
+      var h = el.offsetHeight;
+      var prev = seen ? seen.get(el) : void 0;
+      if (seen) seen.set(el, h);
+      if (options.isStuck()) return;
+      if (prev === void 0) prev = 0;
+      var delta = h - prev;
+      if (delta === 0) return;
+      if (frozen()) {
+        foldFrozenGrowth(box, el, delta);
+        return;
+      }
+      if (el.getBoundingClientRect().top >= box.getBoundingClientRect().top) return;
+      box.scrollTop += delta;
+      wroteTop = box.scrollTop;
+      if (held) held = capture();
+    }
+    function park() {
+      parked = capture();
+      parkedStuck = !!options.isStuck();
+      returning = true;
+    }
+    function pinBottom() {
+      var box = options.getBox();
+      if (!box) return;
+      box.scrollTop = box.scrollHeight;
+      wroteTop = box.scrollTop;
+    }
+    function settleReturn() {
+      if (frozen()) return false;
+      sawFrozen = false;
+      if (parkedStuck) {
+        pinBottom();
+        return true;
+      }
+      var target = parked || held;
+      restoreExact = true;
+      restorePinned = false;
+      restore(target, true);
+      parked = !restorePinned || !restoreExact ? target : null;
+      returning = !!parked;
+      return false;
+    }
+    function isReturning() {
+      return returning;
+    }
+    function thaw() {
+      settleReturn();
+    }
+    function foldFrozenGrowth(box, el, delta) {
+      var elTop = el.getBoundingClientRect().top;
+      foldInto(box, held, elTop, delta);
+      foldInto(box, parked, elTop, delta);
+    }
+    function foldInto(box, a, elTop, delta) {
+      if (!a || a.top >= 0) return;
+      var rowEl = findRow(box, a);
+      if (!rowEl) return;
+      var within = elTop - rowEl.getBoundingClientRect().top;
+      if (within < 0 || within >= rowEl.offsetHeight) return;
+      if (within >= -a.top) return;
+      a.top -= delta;
+      a.scrollHeight += delta;
+    }
+    function forget() {
+      held = null;
+      parked = null;
+      parkedStuck = false;
+      returning = false;
+    }
+    return {
+      capture,
+      restore,
+      preserve,
+      remember,
+      hold,
+      park,
+      settleReturn,
+      isReturning,
+      pinBottom,
+      isFrozen: frozen,
+      thaw,
+      absorb,
+      forget
+    };
+  }
 
   // src/engine/viewport_fill.ts
   var HISTORY_FILL_SLACK_PX = 64;
@@ -2500,6 +2851,7 @@ Index the REMAINING windows - one record per row/item, looking at any page image
   var LIVE_INDEX_SNAPSHOT_MAX_AGE_MS = 5e3;
   var INDEX_DISPATCH_CLAIM_MS = 2 * 60 * 1e3;
   var WORKER_PASS_ADOPT_ATTEMPTS = [0, 2e3, 6e3];
+  var EARLY_PROBE_SCHEDULE_MS = [400, 900, 1700];
   var INDEXING_DRAIN_BUSY_POLL_MS = 8e3;
   var INDEXING_DRAIN_CONFIRM_POLL_MS = 3e3;
   var INDEXING_DRAIN_IDLE_LOOKS = 2;
@@ -2895,7 +3247,93 @@ Index the REMAINING windows - one record per row/item, looking at any page image
      *
      * `stop` comes from the SDK and may be absent on an older skapi-js, in which case the
      * poll simply cannot be stopped and is left running — see pausePolling.
+     *
+     * (This block documents _trackPoll, further down. The two methods below sit between it
+     * and its subject.)
+     */
+    /**
+     * Foreground poll with an early-probe race.
+     *
+     * skapi's poll() is a bare setInterval(fn, latency) with NO check at t=0, so the earliest a
+     * reply can be observed is one full POLL_INTERVAL (3s) after dispatch. For a long generation
+     * that granularity is free. For a SHORT one it is nearly pure dead time: a greeting that the
+     * provider finishes in 1s still waits until the 3s tick, which measured as a large share of a
+     * 5s "yo" round trip.
+     *
+     * So keep the 3s interval as the steady state, and additionally point-look-up the item a few
+     * times early, on a widening schedule. Whichever answers first wins and the other is stopped.
+     * The probe uses the csrHistoryItemLookup hook both clients already implement; without it this
+     * degrades to exactly the old behaviour.
+     *
+     * FOREGROUND ONLY. Background indexing polls keep the flat cadence: nobody is watching them,
+     * and they are the ones bounded by MAX_CONCURRENT_BG_POLLS, so adding probes there would spend
+     * the request budget the cap exists to protect.
      */
+    attachForegroundPoll(source, itemId, opts) {
+      return this._fgPollWithEarlyProbe(source, itemId, opts);
+    }
+    _fgPollWithEarlyProbe(source, itemId, opts) {
+      var base = source.poll(Object.assign({ latency: POLL_INTERVAL }, opts || {}));
+      var lookup = chatEngineConfig().csrHistoryItemLookup;
+      var ident = this.host.getIdentity();
+      var platform = ident && ident.platform;
+      if (!lookup || !itemId || !ident || !ident.projectId || platform !== "claude" && platform !== "openai") {
+        return base;
+      }
+      var settled = false;
+      var timers = [];
+      var clearProbes = function() {
+        for (var i = 0; i < timers.length; i++) clearTimeout(timers[i]);
+        timers = [];
+      };
+      var stopBase = base && typeof base.stop === "function" ? base.stop.bind(base) : null;
+      var raced = new Promise(function(resolve, reject) {
+        base.then(function(res) {
+          if (settled) return;
+          settled = true;
+          clearProbes();
+          resolve(res);
+        }, function(err) {
+          if (settled) return;
+          settled = true;
+          clearProbes();
+          reject(err);
+        });
+        var fullId = buildHistoryItemFullId(platform, ident.projectId, itemId);
+        EARLY_PROBE_SCHEDULE_MS.forEach(function(delay) {
+          timers.push(setTimeout(function() {
+            if (settled) return;
+            Promise.resolve(lookup(fullId, ident.projectId, ident.owner)).then(function(body) {
+              if (settled || !body || typeof body !== "object") return;
+              if (body.status === "pending" || body.status === "running") return;
+              if (isPollStopped(body)) return;
+              settled = true;
+              clearProbes();
+              if (stopBase) {
+                try {
+                  stopBase();
+                } catch (e) {
+                }
+              }
+              if (opts && typeof opts.onResponse === "function") {
+                try {
+                  opts.onResponse(body);
+                } catch (e) {
+                }
+              }
+              resolve(body);
+            }, function() {
+            });
+          }, delay));
+        });
+      });
+      raced.stop = function() {
+        settled = true;
+        clearProbes();
+        if (stopBase) stopBase();
+      };
+      return raced;
+    }
     _trackPoll(id, kind, p) {
       var stop = p && typeof p.stop === "function" ? p.stop.bind(p) : void 0;
       if (!stop) {
@@ -3071,6 +3509,68 @@ Index the REMAINING windows - one record per row/item, looking at any page image
         startKeyHistory: this.state.historyStartKeyHistory.slice()
       };
     }
+    /**
+     * Give the immediate-send pair the server's id for their turn, the moment the
+     * dispatch learns it.
+     *
+     * WHY THIS EXISTS. An immediate send pushes its user bubble and its
+     * "Thinking..." placeholder locally, and until now neither ever carried a
+     * _serverItemId — only the QUEUED path stamped one, off its ack. So for the
+     * whole life of the turn there was no way to tell the local copy and the
+     * server's copy of the SAME turn apart, and the history merge fell back to a
+     * heuristic: rescue the local pair unless the freshly-fetched page happens to
+     * contain a pending assistant.
+     *
+     * That heuristic has a hole exactly one poll interval wide. The server settles
+     * the request; for up to POLL_INTERVAL the client has not noticed, so
+     * `state.sending` is still true and the local pair is still on screen — while a
+     * history fetch issued in that window returns the turn ALREADY SETTLED, with no
+     * pending assistant in it. The rescue then re-appends the local pair below the
+     * server's copy (the question, twice), and when the poll finally resolves,
+     * typewriteLatestReply writes the answer into the rescued placeholder because it
+     * is the only pending assistant left (the answer, twice). updateHistoryCache
+     * persists the result, so it survives every later visit.
+     *
+     * Navigating away while waiting and coming back is what lands a fetch in that
+     * window: a remount runs refreshGate -> a fresh first page, at an arbitrary
+     * moment relative to the 3s poll.
+     *
+     * With the id on the bubbles, both clients' rescue loops skip them through the
+     * dedup they already have (`_serverItemId is in this page`), the reply the
+     * dispatch caches inherits the id too, and nothing needs a new special case.
+     *
+     * Matched by _localId, never by index: a file's indexing rows are spliced in
+     * above these bubbles while the request is in flight.
+     */
+    _stampTurnWithItemId(key, userLid, placeholderLid, itemId) {
+      if (!itemId) return;
+      var changed = false;
+      var stamp = function(list) {
+        var hit = false;
+        for (var i = 0; i < list.length; i++) {
+          var m = list[i];
+          if (!m || !m._localId) continue;
+          if (m._localId !== userLid && m._localId !== placeholderLid) continue;
+          if (m._serverItemId === itemId) continue;
+          list[i] = Object.assign({}, m, { _serverItemId: itemId });
+          hit = true;
+        }
+        return hit;
+      };
+      changed = stamp(this.state.messages);
+      var cached = key ? this.aiChatHistoryCache[key] : void 0;
+      if (cached) {
+        var msgs = cached.messages.slice();
+        if (stamp(msgs)) {
+          this.aiChatHistoryCache[key] = {
+            messages: msgs,
+            endOfList: cached.endOfList,
+            startKeyHistory: cached.startKeyHistory
+          };
+        }
+      }
+      if (changed) this.host.notify();
+    }
     /**
      * Land a resolved reply in the history cache of a chat that is NOT currently
      * visible, without touching state.messages. Mirrors the cache-only path in
@@ -3152,8 +3652,9 @@ Index the REMAINING windows - one record per row/item, looking at any page image
             if (initial.id) {
               if (dispatchItemId && dispatchItemId !== initial.id) self.historyItemPolls.delete(dispatchItemId);
               dispatchItemId = initial.id;
+              if (typeof params.onItemId === "function") params.onItemId(initial.id);
             }
-            var dp = initial.poll({ latency: POLL_INTERVAL });
+            var dp = self._fgPollWithEarlyProbe(initial, initial.id);
             if (initial.id) self._trackPoll(initial.id, "fg", dp);
             return dp;
           }
@@ -3178,28 +3679,9 @@ Index the REMAINING windows - one record per row/item, looking at any page image
       }).then(function(result) {
         delete self.pendingAgentRequests[params.key];
         if (dispatchItemId) self.historyItemPolls.delete(dispatchItemId);
-        var existing = self.aiChatHistoryCache[params.key] || { messages: [], endOfList: false, startKeyHistory: [] };
         var reply = { role: "assistant", content: result.content, isError: result.isError };
-        var msgs = existing.messages.slice();
-        var idx = -1;
-        for (var i = msgs.length - 1; i >= 0; i--) {
-          var m = msgs[i];
-          if (m && m.isPending && m.role === "assistant" && !m.isBackgroundTask) {
-            idx = i;
-            break;
-          }
-        }
-        if (idx !== -1) {
-          reply._serverItemId = msgs[idx]._serverItemId;
-          msgs[idx] = reply;
-        } else {
-          msgs.push(reply);
-        }
-        self.aiChatHistoryCache[params.key] = {
-          messages: msgs,
-          endOfList: existing.endOfList,
-          startKeyHistory: existing.startKeyHistory
-        };
+        if (dispatchItemId) reply._serverItemId = dispatchItemId;
+        self._applyReplyToCache(params.key, reply, dispatchItemId);
         return result;
       });
       this.pendingAgentRequests[params.key] = run;
@@ -3588,8 +4070,9 @@ Index the REMAINING windows - one record per row/item, looking at any page image
         }
         this.host.notify();
         this.updateHistoryCache();
-        this.host.scrollToBottom(true);
+        this.scrollForDispatch(stageId);
         var capturedComposed = composed, capturedPlatform = aiPlatform, capturedKey = key;
+        var capturedQueuedLid = queuedBubble._localId;
         Promise.resolve(this._callProviderFor(aiPlatform, composed, boundedQ.messages, systemPrompt, aiModel, chatQueue, extractContent, fileUrls, id.projectId, id.owner)).then(function(result) {
           var sendingIdx = self.getHistoryCacheKey() !== capturedKey ? -1 : self.state.messages.findIndex(function(m) {
             return m.isSendingToServer && (m.isPendingQueued || m.isPendingInProcess) && m.role === "user" && !m._stageId && (m._ownerKey === void 0 || m._ownerKey === capturedKey);
@@ -3601,8 +4084,9 @@ Index the REMAINING windows - one record per row/item, looking at any page image
             self.state.messages[sendingIdx] = upd;
             self.host.notify();
           }
+          if (serverId) self._stampTurnWithItemId(capturedKey, capturedQueuedLid, void 0, serverId);
           if (result && result.poll && (result.status === "pending" || result.status === "running")) {
-            var qp = result.poll({ latency: POLL_INTERVAL });
+            var qp = self._fgPollWithEarlyProbe(result, serverId);
             if (serverId) self._trackPoll(serverId, "fg", qp);
             return qp.then(function(res) {
               if (isPollStopped(res)) return;
@@ -3618,7 +4102,7 @@ Index the REMAINING windows - one record per row/item, looking at any page image
         return;
       }
       var immediateUser = { role: "user", content: composed, _localId: this._newLocalId(), _ts: wallClockNow(), ...key ? { _ownerKey: key } : {} };
-      var immediatePlaceholder = { role: "assistant", content: "", isPending: true, isPendingInProcess: true, ...key ? { _ownerKey: key } : {} };
+      var immediatePlaceholder = { role: "assistant", content: "", isPending: true, isPendingInProcess: true, _localId: this._newLocalId(), ...key ? { _ownerKey: key } : {} };
       var iStage = this._stageIndex(this.state.messages, stageId);
       if (iStage !== -1) {
         var iEx = this.state.messages[iStage];
@@ -3632,7 +4116,7 @@ Index the REMAINING windows - one record per row/item, looking at any page image
       this.host.notify();
       this.updateHistoryCache();
       this.state.sending = true;
-      this.host.scrollToBottom(true);
+      this.scrollForDispatch(stageId);
       var historyForLlm = this.state.messages.filter(function(m) {
         if (m === immediateUser) return false;
         return !m.isPending && !m.isPendingQueued && !m.isPendingInProcess && !m.isPendingOlder && !m.isCancelled && !m.isBackgroundTask && !m.isError;
@@ -3645,6 +4129,7 @@ Index the REMAINING windows - one record per row/item, looking at any page image
         projectId: id.projectId,
         history: historyForLlm
       });
+      var immediateUserLid = immediateUser._localId, immediatePlaceholderLid = immediatePlaceholder._localId;
       var run = this.dispatchAgentRequest({
         key,
         projectId: id.projectId,
@@ -3656,7 +4141,15 @@ Index the REMAINING windows - one record per row/item, looking at any page image
         boundedMessages: bounded.messages,
         userId: chatQueue,
         extractContent,
-        fileUrls
+        fileUrls,
+        // THE fix for a turn rendering twice after navigate-away-and-back. Until
+        // this existed the immediate-send pair carried no server id for its whole
+        // life (only the QUEUED path stamped one, off its ack), so nothing could
+        // tell the local copy and the server's copy of the same turn apart. See
+        // _stampTurnWithItemId.
+        onItemId: function(itemId) {
+          self._stampTurnWithItemId(key, immediateUserLid, immediatePlaceholderLid, itemId);
+        }
       });
       Promise.resolve(run).catch(function() {
       }).then(function() {
@@ -3667,6 +4160,28 @@ Index the REMAINING windows - one record per row/item, looking at any page image
         });
       });
     }
+    /**
+     * Scroll for a dispatch that is going out NOW, but never for one arriving late.
+     *
+     * A turn with attachments does not dispatch when the user hits Send: it waits out
+     * its uploads and then its whole indexing chain, which is minutes
+     * (awaitIndexingDrained). By then the reader has very often scrolled up into
+     * history to pass the time, and the forcing scrollToBottom yanked them out of it
+     * — and worse, force-pinned stickToBottom, which no-ops every method on the
+     * scroll anchor and re-arms the queue-detect poll whose only bail is
+     * !stickToBottom.
+     *
+     * `stageId` is the exact marker for that case: only the attachment path ever
+     * produces one. The gesture itself was already paid for at stage time, where
+     * stageOutgoingMessage forces the scroll while the user is still looking at the
+     * composer. Deliberately NOT gated on "did we find the staged bubble" — a remount
+     * rebuilds from the cache and the turn is appended rather than replaced, which is
+     * just as late and just as unrequested.
+     */
+    scrollForDispatch(stageId) {
+      if (stageId) this.host.scrollToBottomIfSticky(true);
+      else this.host.scrollToBottom(true);
+    }
     promoteNextBgQueuedToRunning() {
       if (this.state.messages.some(function(m) {
         return m.isPending && m.role === "assistant" && m.isBackgroundTask;
@@ -3792,6 +4307,29 @@ Index the REMAINING windows - one record per row/item, looking at any page image
       else if (targetIdx >= 0) this.state.messages.splice(targetIdx, 0, msg);
       else this.state.messages.push(msg);
     }
+    /**
+     * The server's OWN copy of this turn is already on screen.
+     *
+     * A first-page fetch can land between the server settling the item and this
+     * poll's tick, and now that the local bubbles carry the item id
+     * (_stampTurnWithItemId) the rescue correctly drops them and renders the
+     * server's settled pair instead. There is then nothing left to resolve: the
+     * -1 fallback would push the answer in a SECOND time at the bottom of the list,
+     * and the positional fallbacks would hijack some other turn's bubble.
+     *
+     * The USER bubble counts, not just a settled assistant: an item whose answer is
+     * empty produces no assistant bubble at all in the mapper, and that variant
+     * would otherwise still bottom-push "No text response received...". While a turn
+     * is genuinely live its user bubble is always pending (the queued branch sets
+     * isPendingQueued, promoteNextQueuedToRunning sets isPendingInProcess), so this
+     * cannot fire early.
+     */
+    _turnAlreadyRendered(serverId) {
+      if (!serverId) return false;
+      return this.state.messages.some(function(m) {
+        return m._serverItemId === serverId && !m.isPending && !m.isPendingQueued && !m.isPendingInProcess;
+      });
+    }
     onQueuedSendResponse(_composed, response, platform, serverId, ownerKey) {
       if (serverId) this.historyItemPolls.delete(serverId);
       if (ownerKey && this.getHistoryCacheKey() !== ownerKey) {
@@ -3800,6 +4338,12 @@ Index the REMAINING windows - one record per row/item, looking at any page image
         if (serverId) this.cancelledServerIds.delete(serverId);
         return;
       }
+      if (this._turnAlreadyRendered(serverId)) {
+        if (serverId) this.cancelledServerIds.delete(serverId);
+        this.host.notify();
+        this.updateHistoryCache();
+        return;
+      }
       var targetIdx = this.resolveQueuedUserBubble(serverId);
       if (targetIdx === void 0) {
         this.host.notify();
@@ -3841,6 +4385,12 @@ Index the REMAINING windows - one record per row/item, looking at any page image
         if (serverId) this.cancelledServerIds.delete(serverId);
         return;
       }
+      if (this._turnAlreadyRendered(serverId)) {
+        if (serverId) this.cancelledServerIds.delete(serverId);
+        this.host.notify();
+        this.updateHistoryCache();
+        return;
+      }
       var isNotExists = err && (err.code === "NOT_EXISTS" || err.body && err.body.code === "NOT_EXISTS");
       if (isNotExists) {
         var userIdx = serverId ? this.state.messages.findIndex(function(m) {
@@ -5102,21 +5652,15 @@ Index the REMAINING windows - one record per row/item, looking at any page image
           var rescued = [];
           for (var ri = 0; ri < self.state.messages.length; ri++) {
             var mm = self.state.messages[ri];
-            if (mm.isBackgroundTask) continue;
-            if (mm._ownerKey !== void 0 && mm._ownerKey !== loadKey) continue;
-            if (mm._serverItemId && serverIds[mm._serverItemId]) continue;
-            if (!mm._serverItemId) {
-              if (mm._stageId) {
-                rescued.push(mm);
-                continue;
-              }
-              if (mappedHasPendingAssistant) continue;
-              if (mm.isSendingToServer || mm.isPendingQueued || mm.isPendingInProcess || mm.isPending) rescued.push(mm);
-              else if (self.state.sending && mm.role === "user") {
-                var next = self.state.messages[ri + 1];
-                if (next && !next.isBackgroundTask && next.isPending && !next._serverItemId) rescued.push(mm);
-              }
-            }
+            if (shouldRescueInFlightMessage(mm, {
+              hasServerId: function(sid) {
+                return !!serverIds[sid];
+              },
+              pageHasPendingAssistant: mappedHasPendingAssistant,
+              sending: !!self.state.sending,
+              next: self.state.messages[ri + 1],
+              loadKey
+            })) rescued.push(mm);
           }
           var oldestInPage1 = void 0;
           mapped.forEach(function(m) {
@@ -5167,6 +5711,9 @@ Index the REMAINING windows - one record per row/item, looking at any page image
           keptOlderPages = prependOlder.length > 0 || interleave.length > 0;
           self.state.messages = prependOlder.length ? prependOlder.concat(page1) : page1;
           rescued.forEach(function(m) {
+            if (m._serverItemId && self.state.messages.some(function(x) {
+              return x._serverItemId === m._serverItemId && x.role === m.role;
+            })) return;
             self.state.messages.push(m);
           });
           if (Object.keys(locallyCancelled).length) {
@@ -5291,6 +5838,7 @@ Index the REMAINING windows - one record per row/item, looking at any page image
             releaseBgFlag();
             self.updateHistoryCache();
             self.host.notify();
+            if (self.host.settleScroll) self.host.settleScroll();
           }, function() {
             releaseBgFlag();
             self.host.notify();
@@ -5318,8 +5866,8 @@ Index the REMAINING windows - one record per row/item, looking at any page image
             if ((item._isBgTask || item._isOnBgQueue) && self.isPollingPaused()) return;
             if ((item._isBgTask || item._isOnBgQueue) && !bgAllow[item.id]) return;
             var capturedId = item.id;
-            var pp = item.poll({
-              latency: POLL_INTERVAL,
+            var isBg = !!(item._isBgTask || item._isOnBgQueue);
+            var pollOpts = {
               onResponse: function(response) {
                 if (isPollStopped(response)) return;
                 self.handleHistoryItemResolution(capturedId, response, platform);
@@ -5334,9 +5882,9 @@ Index the REMAINING windows - one record per row/item, looking at any page image
                   var uIdx = self.state.messages.findIndex(function(m) {
                     return m.role === "user" && m._serverItemId === capturedId && !m.isCancelled;
                   });
-                  var isBg = aIdx !== -1 && !!self.state.messages[aIdx].isBackgroundTask || uIdx !== -1 && !!self.state.messages[uIdx].isBackgroundTask;
+                  var isBg2 = aIdx !== -1 && !!self.state.messages[aIdx].isBackgroundTask || uIdx !== -1 && !!self.state.messages[uIdx].isBackgroundTask;
                   if (aIdx !== -1) self.state.messages.splice(aIdx, 1);
-                  if (!isBg) {
+                  if (!isBg2) {
                     if (uIdx !== -1) {
                       var ex = self.state.messages[uIdx];
                       self.state.messages[uIdx] = { role: "user", content: ex.content, isCancelled: true, _serverItemId: ex._serverItemId };
@@ -5363,7 +5911,8 @@ Index the REMAINING windows - one record per row/item, looking at any page image
                   self.updateHistoryCache();
                 }
               }
-            });
+            };
+            var pp = isBg ? item.poll(Object.assign({ latency: POLL_INTERVAL }, pollOpts)) : self._fgPollWithEarlyProbe(item, capturedId, pollOpts);
             self._trackPoll(capturedId, item._isBgTask || item._isOnBgQueue ? "bg" : "fg", pp);
             if (pp && pp.catch) pp.catch(function() {
             });
@@ -5371,7 +5920,7 @@ Index the REMAINING windows - one record per row/item, looking at any page image
           self.drainBgTaskQueue();
         }
         if (!fetchMore) self.refreshLiveIndexState();
-        if (!fetchMore) return self.host.scrollToBottomIfSticky();
+        if (!fetchMore) return self.host.settleScroll ? self.host.settleScroll() : self.host.scrollToBottomIfSticky();
       }).catch(function(err) {
         console.warn("[chat-engine] getChatHistory failed", err);
       }).then(function() {
@@ -5998,7 +6547,7 @@ Index the REMAINING windows - one record per row/item, looking at any page image
   (function() {
     var MCP_PROD = "https://mcp.broadwayinc.computer";
     var MCP_DEV = "https://mcp-dev.broadwayinc.computer";
-    var BQ_VERSION = "1.8.12" ;
+    var BQ_VERSION = "1.8.14" ;
     var ATTACHMENT_URL_EXPIRES_SECONDS = 600;
     var GOOGLE_AUTH_URL = "https://accounts.google.com/o/oauth2/v2/auth";
     var GOOGLE_TOKEN_URL = "https://oauth2.googleapis.com/token";
@@ -7678,10 +8227,10 @@ Index the REMAINING windows - one record per row/item, looking at any page image
         refreshMessageBubble(i);
       },
       scrollToBottom: function(smooth) {
-        return scrollToBottom(smooth);
+        return scrollToBottom();
       },
       scrollToBottomIfSticky: function(smooth) {
-        return scrollToBottomIfSticky(smooth);
+        return scrollToBottomIfSticky();
       },
       // A first page can render shorter than the box (a file's every indexing
       // pass folds into ONE row), and a box that cannot scroll never fires the
@@ -7690,6 +8239,9 @@ Index the REMAINING windows - one record per row/item, looking at any page image
       onHistoryLoaded: function(fetchMore, token) {
         if (!fetchMore) ensureHistoryFillsViewport(token);
       },
+      settleScroll: function() {
+        settleScrollAfterRefresh();
+      },
       cancelRequest: function(opts) {
         return S.skapi.cancelClientSecretRequest(opts);
       },
@@ -7881,7 +8433,7 @@ Index the REMAINING windows - one record per row/item, looking at any page image
         if (job.stageId) session.settleStagedMessage(job.stageId);
         CS.messages.push({ role: "assistant", content: "Something went wrong while uploading attachments. " + (err && err.message || ""), isError: true });
         renderMessages();
-        scrollToBottom(true);
+        scrollToBottomIfSticky();
         return null;
       });
     }
@@ -7934,28 +8486,60 @@ Index the REMAINING windows - one record per row/item, looking at any page image
       };
       enqueueAttachmentSend({ text, batchId, stageId, pinned });
     }
-    function scrollToBottom(smooth) {
+    function scrollToBottom() {
+      if (chatScrollAnchor.isFrozen()) {
+        CS.stickToBottom = true;
+        chatScrollAnchor.pinBottom();
+        return Promise.resolve();
+      }
       return raf2().then(function() {
         if (!CS.messagesBox) return;
         CS.stickToBottom = true;
-        if (smooth) CS.messagesBox.scrollTo({ top: CS.messagesBox.scrollHeight, behavior: "smooth" });
-        else CS.messagesBox.scrollTop = CS.messagesBox.scrollHeight;
+        chatScrollAnchor.pinBottom();
       });
     }
-    function scrollToBottomIfSticky(smooth) {
+    function scrollToBottomIfSticky() {
       if (!CS.stickToBottom) return Promise.resolve();
+      if (chatScrollAnchor.isFrozen()) {
+        chatScrollAnchor.pinBottom();
+        return Promise.resolve();
+      }
       return raf2().then(function() {
         if (!CS.stickToBottom || !CS.messagesBox) return;
-        if (smooth) CS.messagesBox.scrollTo({ top: CS.messagesBox.scrollHeight, behavior: "smooth" });
-        else CS.messagesBox.scrollTop = CS.messagesBox.scrollHeight;
+        chatScrollAnchor.pinBottom();
       });
     }
+    function settleScrollAfterRefresh(afterAbsence) {
+      if (afterAbsence || chatScrollAnchor.isReturning()) {
+        if (chatScrollAnchor.settleReturn()) CS.stickToBottom = true;
+        return;
+      }
+      if (CS.stickToBottom) scrollToBottomIfSticky();
+      else chatScrollAnchor.hold();
+    }
+    var lastHistoryScrollTop = 0;
     function onHistoryScroll() {
       if (!CS.messagesBox || CS.chatSettingsOpen) return;
       var el = CS.messagesBox;
-      CS.stickToBottom = el.scrollHeight - el.scrollTop - el.clientHeight <= 16;
+      if (chatScrollAnchor.isFrozen()) {
+        lastHistoryScrollTop = el.scrollTop;
+        return;
+      }
+      var atBottom = el.scrollHeight - el.scrollTop - el.clientHeight <= 16;
+      if (!atBottom) CS.stickToBottom = false;
+      else if (el.scrollTop >= lastHistoryScrollTop) CS.stickToBottom = true;
+      lastHistoryScrollTop = el.scrollTop;
+      chatScrollAnchor.remember();
       if (el.scrollTop <= 60) pageOlderHistoryUntilTaller();
     }
+    function onMessagesFontsSettled() {
+      chatScrollAnchor.hold();
+    }
+    function onMessagesImageSettled(e) {
+      var t = e && e.target;
+      if (!t || t.tagName !== "IMG") return;
+      chatScrollAnchor.absorb(previewLayoutBox(t));
+    }
     var _touchStartY = 0;
     function onMessagesWheel(e) {
       if (e.deltaY < 0) CS.stickToBottom = false;
@@ -8288,12 +8872,13 @@ Index the REMAINING windows - one record per row/item, looking at any page image
         var uid = S.user && S.user.user_id;
         if (uid) body.uid = uid;
       }
-      return S.skapi.util.request("get-signed-url", body, reqOpts).then(function(res) {
+      function unwrap(res) {
         var u = typeof res === "string" ? res : res && res.url;
         if (!u) throw new Error("No temporary URL returned.");
         if (/^https?:\/\//i.test(u)) return u;
         return "https://db." + hostDomain() + "/" + u;
-      });
+      }
+      return S.skapi.util.request("get-signed-url", body, reqOpts).then(unwrap);
     }
     var ATTACH_ICON_SVG = '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" width="18" height="18"><path d="M21.44 11.05l-9.19 9.19a6 6 0 0 1-8.49-8.49l9.19-9.19a4 4 0 0 1 5.66 5.66l-9.2 9.19a2 2 0 0 1-2.83-2.83l8.49-8.48"/></svg>';
     var FILE_ICON_SVG = '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z"/><polyline points="14 2 14 8 20 8"/></svg>';
@@ -8841,7 +9426,15 @@ Index the REMAINING windows - one record per row/item, looking at any page image
         // earlier failure left on this file's chips.
         onLoad: function(path) {
           clearLinkUnavailable(linkUnavailableKeysForPath(path));
-          scrollToBottomIfSticky(false);
+          scrollToBottomIfSticky();
+        },
+        // The resizes an <img> makes with no event of its own to announce
+        // them: the src landing, and the src being dropped for a retry (which
+        // collapses an already-painted picture to nothing). load and error are
+        // covered by the listener on the message box, which also catches the
+        // markdown images this module never sees.
+        onLayoutChange: function(img) {
+          chatScrollAnchor.absorb(img);
         },
         // The mint was refused, or the url it minted would not load. Either
         // way there is no url for this file, so the caption chip left behind
@@ -8863,16 +9456,23 @@ Index the REMAINING windows - one record per row/item, looking at any page image
     }
     var refreshedLinkExpiryTimer = null;
     function expireAllRefreshedLinks() {
-      for (var k in refreshedExpiredLinkMap) delete refreshedExpiredLinkMap[k];
-      for (var u in unavailableLinkMap) delete unavailableLinkMap[u];
+      var changed = false;
+      for (var k in refreshedExpiredLinkMap) {
+        delete refreshedExpiredLinkMap[k];
+        changed = true;
+      }
+      for (var u in unavailableLinkMap) {
+        delete unavailableLinkMap[u];
+        changed = true;
+      }
+      return changed;
     }
     function scheduleNextLinkExpiryBoundary() {
       if (refreshedLinkExpiryTimer) clearTimeout(refreshedLinkExpiryTimer);
       var now = Date.now();
       var next = Math.ceil(now / LINK_REFRESH_WINDOW_MS) * LINK_REFRESH_WINDOW_MS;
       refreshedLinkExpiryTimer = setTimeout(function() {
-        expireAllRefreshedLinks();
-        renderMessages();
+        if (expireAllRefreshedLinks()) renderMessages();
         scheduleNextLinkExpiryBoundary();
       }, Math.max(1, next - now));
     }
@@ -9608,40 +10208,33 @@ Index the REMAINING windows - one record per row/item, looking at any page image
     function indexGroupAnchorId(group) {
       return group.anchorId || "";
     }
+    var chatScrollAnchor = createScrollAnchor({
+      getBox: function() {
+        return CS.messagesBox;
+      },
+      isStuck: function() {
+        return !!CS.stickToBottom;
+      },
+      // A hidden tab keeps mutating this list - a resumed poll, the head refresh
+      // and its deferred background batch, a settling request - and every one of
+      // those would otherwise move a scroll position nobody is looking at. Freeze
+      // instead, and put the reader back once they can see it (settleScroll).
+      isFrozen: function() {
+        return typeof document !== "undefined" && !!document.hidden;
+      },
+      rawFallback: true
+    });
     function captureScrollAnchor() {
-      var box = CS.messagesBox;
-      if (!box || CS.stickToBottom) return null;
-      var boxTop = box.getBoundingClientRect().top;
-      var kids = box.children;
-      var fallback = null;
-      for (var i = 0; i < kids.length; i++) {
-        if (!kids[i].getAttribute) continue;
-        var key = kids[i].getAttribute("data-row-key");
-        if (!key) continue;
-        var top = kids[i].getBoundingClientRect().top - boxTop;
-        if (top + kids[i].offsetHeight <= 0) continue;
-        var cand = { key, top, scrollTop: box.scrollTop, pos: kids[i].getAttribute("data-row-pos") };
-        if (cand.pos === null) return cand;
-        if (!fallback) fallback = cand;
-      }
-      return fallback || { key: null, top: 0, scrollTop: box.scrollTop };
+      return chatScrollAnchor.capture();
     }
     function restoreScrollAnchor(anchor) {
       var box = CS.messagesBox;
       if (!box) return;
-      if (!anchor || CS.stickToBottom) {
-        box.scrollTop = box.scrollHeight;
+      if (CS.stickToBottom) {
+        chatScrollAnchor.pinBottom();
         return;
       }
-      var boxTop = box.getBoundingClientRect().top;
-      var kids = box.children;
-      for (var i = 0; anchor.key && i < kids.length; i++) {
-        if (!kids[i].getAttribute || kids[i].getAttribute("data-row-key") !== anchor.key) continue;
-        if (anchor.pos && kids[i].getAttribute("data-row-pos") !== anchor.pos) break;
-        box.scrollTop += kids[i].getBoundingClientRect().top - boxTop - anchor.top;
-        return;
-      }
-      box.scrollTop = anchor.scrollTop;
+      chatScrollAnchor.restore(anchor);
     }
     function syncDraftingIndicator() {
       if (!CS.messagesBox) return;
@@ -9684,6 +10277,7 @@ Index the REMAINING windows - one record per row/item, looking at any page image
         if (CS.loadingHistory && !CS.loadingOlderHistory) {
           CS.messagesBox.appendChild(historyLoadingEl(true));
           syncDraftingIndicator();
+          restoreScrollAnchor(anchor);
           return;
         }
         var emptyStubEls = [];
@@ -9692,12 +10286,16 @@ Index the REMAINING windows - one record per row/item, looking at any page image
           for (var ge = 0; ge < emptyEntries.length; ge++) {
             if (emptyEntries[ge].kind !== "indexing") continue;
             var sg = emptyEntries[ge].group;
-            emptyStubEls.push(buildIndexGroupEl(sg, !!CS.indexGroupsOpen[sg.key]));
+            var stubEl = buildIndexGroupEl(sg, !!CS.indexGroupsOpen[sg.key]);
+            stubEl.setAttribute("data-row-key", "g" + sg.runKey);
+            stubEl.setAttribute("data-row-pos", indexGroupAnchorId(sg));
+            emptyStubEls.push(stubEl);
           }
         } catch (e) {
         }
         for (var gse = 0; gse < emptyStubEls.length; gse++) CS.messagesBox.appendChild(emptyStubEls[gse]);
         syncDraftingIndicator();
+        restoreScrollAnchor(anchor);
         return;
       }
       var rows = buildChatDisplayList(CS.messages, displayListOptions());
@@ -9762,14 +10360,17 @@ Index the REMAINING windows - one record per row/item, looking at any page image
       if (idx < 0 || idx >= CS.messages.length) return;
       var oldEl = CS.messageEls[idx];
       if (!oldEl || !oldEl.parentNode) return;
-      var newEl = buildMessageEl(CS.messages[idx], idx);
-      if (oldEl.classList.contains("bq-index-pass")) newEl.classList.add("bq-index-pass");
-      oldEl.parentNode.replaceChild(newEl, oldEl);
-      CS.messageEls[idx] = newEl;
+      chatScrollAnchor.preserve(function() {
+        var newEl = buildMessageEl(CS.messages[idx], idx);
+        if (oldEl.classList.contains("bq-index-pass")) newEl.classList.add("bq-index-pass");
+        oldEl.parentNode.replaceChild(newEl, oldEl);
+        CS.messageEls[idx] = newEl;
+      });
       hydrateMessageImagePreviews();
     }
     function renderChat() {
       clearImagePreviewCache(S.projectId || "default");
+      chatScrollAnchor.forget();
       for (var uk in unavailableLinkMap) delete unavailableLinkMap[uk];
       CS.messages = [];
       CS.messageEls = [];
@@ -9844,6 +10445,11 @@ Index the REMAINING windows - one record per row/item, looking at any page image
         box.addEventListener("wheel", onMessagesWheel, { passive: true });
         box.addEventListener("touchstart", onMessagesTouchStart, { passive: true });
         box.addEventListener("touchmove", onMessagesTouchMove, { passive: true });
+        box.addEventListener("load", onMessagesImageSettled, true);
+        box.addEventListener("error", onMessagesImageSettled, true);
+        if (document.fonts && document.fonts.addEventListener) {
+          document.fonts.addEventListener("loadingdone", onMessagesFontsSettled);
+        }
         CS.messagesBox = box;
         var input = h("textarea", { class: "bq-input", rows: "1", placeholder: "Ask anything about: " + (S.serviceName || "your project") });
         CS.inputEl = input;
@@ -9867,7 +10473,7 @@ Index the REMAINING windows - one record per row/item, looking at any page image
           if (drafting !== CS.drafting) {
             CS.drafting = drafting;
             syncDraftingIndicator();
-            scrollToBottomIfSticky(false);
+            scrollToBottomIfSticky();
           }
         });
         input.addEventListener("keydown", function(e) {
@@ -10221,18 +10827,26 @@ Index the REMAINING windows - one record per row/item, looking at any page image
         S._resizeBound = true;
         window.addEventListener("resize", function() {
           scheduleAttachmentOverflowRecompute();
-          scrollToBottomIfSticky(false);
+          scrollToBottomIfSticky();
           ensureHistoryFillsViewport();
         });
       }
       if (!S._visBound && typeof document !== "undefined" && document.addEventListener) {
         S._visBound = true;
+        window.addEventListener("blur", function() {
+          chatScrollAnchor.park();
+        });
+        window.addEventListener("focus", function() {
+          settleScrollAfterRefresh(true);
+        });
         document.addEventListener("visibilitychange", function() {
           if (document.visibilityState === "hidden") {
+            chatScrollAnchor.park();
             if (session && session.pausePolling) session.pausePolling("hidden");
             return;
           }
           if (document.visibilityState === "visible") {
+            settleScrollAfterRefresh(true);
             var refreshed = S.user ? ensureMcpGrantFresh() : null;
             Promise.resolve(refreshed).catch(function() {
             }).then(function() {