bunnyquery 1.8.13 → 1.8.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bunnyquery",
-  "version": "1.8.13",
+  "version": "1.8.15",
   "description": "Embeddable BunnyQuery AI chat widget + its framework-agnostic chat engine",
   "main": "bunnyquery.js",
   "exports": {
@@ -32,7 +32,8 @@
   "scripts": {
     "build": "tsup && node scripts/build-css.mjs",
     "build:css": "node scripts/build-css.mjs",
-    "dev": "npx bns port=3333"
+    "dev": "npx bns port=3333",
+    "test": "for f in ./tests/*.cjs; do echo \"--- $f\"; node \"$f\" || exit 1; done"
   },
   "dependencies": {
     "basic-node-server": "^1.1.1"

package/src/engine/history.ts

@@ -7,6 +7,7 @@
 import { extractClaudeText, extractOpenAIText, INDEXING_COMPLETE_MARKER, EMPTY_INDEXING_REPLY, getChatHistory, bgIndexingQueueName } from './requests';
 import { isErrorResponseBody, getErrorMessage } from './errors';
 import { sanitizeAttachmentLinksForHistory } from './links';
+import type { ChatMessage } from './host';
 
 export function filterListByClearHorizon(list: any[], clearedAt: number): any[] {
 	if (!clearedAt) return list;
@@ -732,3 +733,66 @@ export function mapHistoryListToMessages(list: any[], platform: 'claude' | 'open
 	}
 	return { messages: mapped, runningItemIds: runningItemIds };
 }
+
+/* ---- rescuing in-flight bubbles across a first-page refetch ---------------
+ *
+ * A first-page fetch REPLACES the message list, and the list may hold bubbles the
+ * server does not know about yet: a turn whose request is still in flight, a
+ * staged turn whose files are still uploading, a queued turn waiting for its ack.
+ * Those have to survive the replace, and nothing else may.
+ *
+ * The rule lived twice — agent.vue's own fetchHistoryPage and the engine's
+ * loadHistory — and the two had to be edited in lockstep to stay honest. It is one
+ * function now, because the failure mode when they drift is a turn rendered twice
+ * and then PERSISTED into the history cache, where it survives every later visit.
+ */
+
+export interface RescueDecisionContext {
+	/** Is this `_serverItemId` in the page that was just fetched? */
+	hasServerId: (id: string) => boolean;
+	/**
+	 * The fetched page already shows a non-background pending assistant.
+	 *
+	 * Only meaningful for a bubble with NO server id, where it is the sole
+	 * available answer to "is this turn already represented?". For a bubble that
+	 * HAS one, hasServerId answers exactly the same question exactly, and applying
+	 * this on top of it would drop an in-flight turn whose server copy simply is
+	 * not in the page that was fetched.
+	 */
+	pageHasPendingAssistant: boolean;
+	/** state.sending: an immediate send is in flight for this chat. */
+	sending: boolean;
+	/** The bubble directly after this one in the local list. */
+	next?: ChatMessage | null;
+	/** The chat this fetch is FOR. A bubble stamped for another must not cross. */
+	loadKey?: string;
+}
+
+export function shouldRescueInFlightMessage(m: ChatMessage, ctx: RescueDecisionContext): boolean {
+	if (!m) return false;
+	// Background indexing bubbles come back through their own merge.
+	if (m.isBackgroundTask) return false;
+	// Never carry another project's (or another platform's) bubbles onto this chat.
+	if (m._ownerKey !== undefined && ctx.loadKey !== undefined && m._ownerKey !== ctx.loadKey) return false;
+	// The page carries a fresher copy of this exact turn.
+	if (m._serverItemId && ctx.hasServerId(m._serverItemId)) return false;
+	// A staged turn has no server request yet, so nothing in the page can stand for
+	// it. Unconditional: applying the pending-assistant test here would delete the
+	// user's message mid-upload whenever some other turn happened to be in flight.
+	if (m._stageId) return true;
+	if (!m._serverItemId && ctx.pageHasPendingAssistant) return false;
+	// In flight by its own flags, id or no id. The immediate-send pair is stamped
+	// with its server id as soon as the dispatch reports one, and that id is there
+	// to let the check above recognise the server's copy — not to disqualify the
+	// bubble from being kept when there is no such copy.
+	if (m.isSendingToServer || m.isPendingQueued || m.isPendingInProcess || m.isPending) return true;
+	// An immediate-send user bubble carries no flags of its own (its in-flight-ness
+	// lives in state.sending); what identifies it is its own unanswered placeholder
+	// directly below it.
+	if (ctx.sending && m.role === 'user') {
+		var next = ctx.next;
+		if (!next || next.isBackgroundTask || !next.isPending) return false;
+		return next._serverItemId === undefined || next._serverItemId === m._serverItemId;
+	}
+	return false;
+}

package/src/engine/host.ts

@@ -194,6 +194,20 @@ export interface ChatHost {
 	 *  that cannot scroll has no way to reach page 2 (see viewport_fill). Only
 	 *  the view can measure that, which is why the engine merely announces it. */
 	onHistoryLoaded?(fetchMore: boolean, token: number): void;
+	/**
+	 * A list refresh just changed heights: put the reader back where they were.
+	 *
+	 * Called at BOTH moments a first-page refresh moves things — the surface page
+	 * landing, and the deferred background-indexing batch merging on top of it a
+	 * round trip later — because leaving a wrong position on screen between the two
+	 * is what reads as "the scroll jumped, then travelled somewhere else".
+	 *
+	 * The view owns the decision (it is the only side that can measure): pinned to
+	 * the bottom means the bottom AFTER the batch merged, anywhere else means the
+	 * exact line the reader was on. Falls back to scrollToBottomIfSticky when a host
+	 * does not implement it, which is the old behaviour.
+	 */
+	settleScroll?(): void;
 
 	// --- skapi surface beyond configureChatEngine() ---
 	cancelRequest(opts: {

package/src/engine/index.ts

@@ -68,6 +68,11 @@ export {
 	// read it the same way or the two will not group together.
 	isIndexingRequestText,
 	parseIndexingRequestText,
+	// One rule for which locally-pushed bubbles survive a first-page refetch.
+	// Shared because the failure mode when the two clients drift is a turn
+	// rendered twice and then persisted into the history cache.
+	shouldRescueInFlightMessage,
+	type RescueDecisionContext,
 	// One bounded look at the bg-indexing queue: which files still have a live
 	// pass. The dbfile browser's "indexed" badge uses this so a file only goes
 	// green once the run is confirmed over, not when its src:: record appears.
@@ -82,6 +87,18 @@ export {
 // a box too short to scroll strands the user on page 1 — the normal state once a
 // page of history collapses into one indexing row. Shared so both chatboxes page
 // their way out of it identically.
+// Holding the reader's place while the list mutates underneath them. Shared so
+// an older page, an indexing row, a re-parsed chip and a decoded image preview
+// are all absorbed the same way in both chatboxes.
+export {
+	createScrollAnchor,
+	type ScrollAnchor,
+	type ScrollAnchorOptions,
+	type RowAnchor,
+	type AnchorBoxEl,
+	type AnchorRowEl,
+} from './scroll_anchor';
+
 export {
 	fillHistoryViewport,
 	createHistoryFiller,

package/src/engine/link_markup.ts

@@ -113,7 +113,15 @@ export function renderInlineLinkHtml(link: RenderableInlineLink, opts?: InlineLi
 		'<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">' +
+		// decoding="async" but NOT loading="lazy". Lazy guarantees the bytes arrive
+		// exactly when the image is near the viewport, which is the one case the
+		// scroll anchor deliberately declines to compensate for (growth at or below
+		// the fold happened on screen, under a line the reader is looking at) — so it
+		// shoved up to 320px of text under their eyes on every scroll toward it. It
+		// saved no mint either: hydration mints for every preview in the DOM
+		// regardless of viewport. It was also what turned the widget's per-notify
+		// teardown into a 13x amplifier (6224px vs 450px measured).
+		' decoding="async">' +
 		// Minting the url is a network round trip before the image even starts
 		// downloading, so the wait is real and needs a state. Inline load, so the
 		// dot trail, never the jumping bunny. CSS hides it the moment the <img>

package/src/engine/links.ts

@@ -656,12 +656,37 @@ export function classifyInlineLink(
  * the placeholder href), so marking writes one key and the lookup tries all of
  * them.
  */
+/**
+ * Unicode form is not stable across the places a storage path travels through.
+ *
+ * macOS hands the browser a DECOMPOSED (NFD) filename, so a Korean name like
+ * 운전면허-김대현.jpg arrives as 24 codepoints where the composed (NFC) form is 12.
+ * Nothing in this engine normalized either way, so the SAME file could be keyed under
+ * two different strings depending on which path it travelled: a mark left by a failed
+ * mint under one form would never be cleared by a successful load under the other, and
+ * the chip stayed greyed out as "(unavailable)" forever.
+ *
+ * NFC is the canonical choice: it is what the Unicode standard recommends for
+ * interchange, and it is the shorter, more common form on the wire.
+ */
+export function canonicalizePathForm(value: string): string {
+	if (!value) return value;
+	try { return value.normalize('NFC'); } catch (e) { return value; }
+}
+
 export function linkUnavailableKeyForPath(remotePath: string): string {
-	return 'path:' + (remotePath || '');
+	// Canonicalized so the NFC and NFD spellings of one file share ONE key.
+	return 'path:' + canonicalizePathForm(remotePath || '');
 }
 
 export function linkUnavailableKeyForHref(href: string): string {
-	return 'href:' + (href || '');
+	// An `_expired_.url` placeholder carries the storage path percent-encoded, so NFC and
+	// NFD spellings of one file produce two different href strings and therefore two
+	// different keys. Route those through the path key instead, so a file has ONE key
+	// however it is spelled and whichever carrier it arrived on.
+	var carried = readExpiredAttachmentHref(href);
+	if (carried) return linkUnavailableKeyForPath(carried);
+	return 'href:' + canonicalizePathForm(href || '');
 }
 
 /**
@@ -676,10 +701,13 @@ export function linkUnavailableKeyForHref(href: string): string {
  */
 export function linkUnavailableKeysForPath(remotePath: string): string[] {
 	if (!remotePath) return [];
-	return [
+	var keys = [
 		linkUnavailableKeyForPath(remotePath),
 		linkUnavailableKeyForHref(buildDisplayExpiredAttachmentHref(remotePath)),
 	];
+	// Both now canonicalize to the same key for a placeholder href, so drop the duplicate
+	// rather than marking and clearing the same entry twice.
+	return keys.filter(function (k, i) { return keys.indexOf(k) === i; });
 }
 
 export function isLinkUnavailable(