@ryuu-64/dsh-find-all 0.1.4 → 0.1.6

package/lib/client.js

@@ -21,19 +21,19 @@
 //   * In whole-conversation mode a search pages the older history in through
 //     the session service (ctx.sessions.binding(id).session.loadOlder()),
 //     re-running the match pass after every page — so the count and the
-//     highlight set end up covering the entire session.
+//     highlight set cover the history the host currently makes available.
 //   * Progress is visible ("正在加载更早的历史… 已 3 页"), clickable to stop,
 //     capped at MAX_PAGES, and it stops by itself when the history stops
-//     growing (which also covers hosts that expose no `hasMore`).
+//     growing. Host termination does not establish historical completeness.
 //
 // How it works without fighting React (unchanged from the fork):
 //   * Matches are collected as DOM Range objects (start/end offsets inside
-//     text nodes) via a TreeWalker that also descends into shadow roots.
+//     text nodes) from block-local text snapshots, including shadow roots.
 //   * Highlights use the CSS Custom Highlight API (CSS.highlights + Highlight)
 //     which paints ranges WITHOUT mutating the DOM — React keeps full
 //     ownership of the tree. Chromium/Electron support this since 105.
-//   * When the API is unavailable, the bar degrades to the legacy
-//     window.find() calls (no count, still functional).
+//   * Without CSS Highlights, navigation still scrolls only scoped ranges.
+//     Browser-wide window.find() is deliberately never used.
 //
 // Keyboard:
 //   Cmd/Ctrl+F  open (prefilled with the current selection)
@@ -43,7 +43,7 @@
 
 window.__ModuleLoader__.load({
 	id: "@ryuu-64/dsh-find-all",
-	factory: () => {
+	factory: (require) => {
 		var module = { exports: {} };
 		var exports = module.exports;
 
@@ -59,6 +59,16 @@ window.__ModuleLoader__.load({
 		/** How often the open bar notices that the user switched session. */
 		var SESSION_POLL_MS = 600;
 		var SKIP_TAGS = { SCRIPT: 1, STYLE: 1, NOSCRIPT: 1 };
+		// Structural boundaries, not a computed-style visibility policy. In
+		// particular, host message divs and code-content/toolbars stay separate.
+		var BLOCK_TAGS = {
+			ADDRESS: 1, ARTICLE: 1, ASIDE: 1, BLOCKQUOTE: 1, DD: 1, DETAILS: 1,
+			DIALOG: 1, DIV: 1, DL: 1, DT: 1, FIELDSET: 1, FIGCAPTION: 1, FIGURE: 1,
+			FOOTER: 1, FORM: 1, H1: 1, H2: 1, H3: 1, H4: 1, H5: 1, H6: 1,
+			HEADER: 1, HR: 1, LI: 1, MAIN: 1, NAV: 1, OL: 1, P: 1, PRE: 1,
+			SECTION: 1, SUMMARY: 1, TABLE: 1, TBODY: 1, TD: 1, TFOOT: 1,
+			TH: 1, THEAD: 1, TR: 1, UL: 1
+		};
 
 		var ZH = typeof navigator !== "undefined" && /^zh/i.test(navigator.language || "");
 		var L = ZH ? {
@@ -72,11 +82,14 @@ window.__ModuleLoader__.load({
 			scopeToPage: "搜索范围：整段会话。点击改为只搜当前页面",
 			scopeToWhole: "搜索范围：仅当前页面。点击改为搜索整段会话",
 			loading: "正在加载更早的历史… 已 {n} 页",
-			allLoaded: "整段会话已就绪",
-			capped: "已到加载上限（{n} 页），停止加载",
-			stalled: "没有更早的历史了",
+			available: "已搜索当前可用历史；宿主未提供更早页，无法确认历史完整性",
+			capped: "历史尚未搜完：已到加载上限（{n} 页）",
 			stopTip: "点击停止加载",
-			noService: "取不到会话接口，只能搜当前页面"
+			noService: "会话接口不可用，仅保留已显示的部分结果",
+			noTarget: "请先选择可见的会话，再打开查找",
+			noRoot: "当前会话的搜索范围不可用",
+			incomplete: "历史尚未搜完，保留部分结果",
+			find: "查找会话"
 		} : {
 			placeholder: "Find in conversation…",
 			prev: "Previous match",
@@ -88,31 +101,42 @@ window.__ModuleLoader__.load({
 			scopeToPage: "Scope: the whole conversation. Click to search only the rendered page",
 			scopeToWhole: "Scope: the rendered page only. Click to search the whole conversation",
 			loading: "Loading earlier history… {n} pages",
-			allLoaded: "Whole conversation loaded",
-			capped: "Page cap reached ({n}), stopped loading",
-			stalled: "No earlier history",
+			available: "Searched currently available history; the host offers no earlier pages, so completeness cannot be confirmed",
+			capped: "History search incomplete: page cap reached ({n})",
 			stopTip: "Click to stop loading",
-			noService: "Session service unavailable — rendered page only"
+			noService: "Session service unavailable; rendered results only",
+			noTarget: "Select a visible conversation before opening find",
+			noRoot: "Search scope unavailable for this conversation",
+			incomplete: "History search incomplete; partial results retained",
+			find: "Find in conversation"
 		};
 
 		//#region pure helpers (exported for tests)
 
-		// All non-overlapping case-insensitive start indices of `query` in
-		// `text`; empty array for an empty query or no hits.
-		function findIndices(text, query) {
+		// Literal, locale-independent Unicode simple folding on the ORIGINAL
+		// text. RegExp returns UTF-16 offsets, exactly as DOM Range requires.
+		// No normalization, full case folding, or transformed-string offsets.
+		function findMatches(text, query) {
 			if (!query) return [];
-			var haystack = String(text).toLowerCase();
-			var needle = String(query).toLowerCase();
+			// This is the entire pattern (not interpolated into another regex).
+			// Escape regex syntax only; '-' and '/' are literal in this context.
+			// Do not require the newer RegExp.escape() API in supported hosts.
+			var literal = String(query).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+			if (!literal) return [];
+			var haystack = String(text);
+			var matcher = new RegExp(literal, "giu");
 			var out = [];
-			var i = haystack.indexOf(needle);
-			while (i !== -1) {
-				out.push(i);
-				if (out.length >= MAX_MATCHES) break;
-				i = haystack.indexOf(needle, i + needle.length);
+			var match;
+			while (out.length < MAX_MATCHES && (match = matcher.exec(haystack)) !== null) {
+				out.push({ start: match.index, end: match.index + match[0].length });
 			}
 			return out;
 		}
 
+		function findIndices(text, query) {
+			return findMatches(text, query).map(function (match) { return match.start; });
+		}
+
 		// Keyboard routing, isolated so tests can drive it with spies.
 		function createHandlers(ops) {
 			return function onKeydown(event) {
@@ -121,7 +145,7 @@ window.__ModuleLoader__.load({
 				if (meta && (key === "f" || key === "F")) {
 					event.preventDefault();
 					event.stopPropagation();
-					ops.open();
+					ops.open(event.target);
 					return;
 				}
 				if (!ops.isOpen()) return;
@@ -143,41 +167,44 @@ window.__ModuleLoader__.load({
 			};
 		}
 
-		/**
-		 * Page older history in until the conversation stops growing.
-		 *
-		 * Every dependency is injected, so the loop is testable without a DOM or
-		 * a host: the caller supplies how to read `hasMore`, how to load a page,
-		 * how to measure the rendered history, and how to wait for that measure
-		 * to change.
-		 *
-		 * @param opts - { maxPages, isCancelled, hasMore, loadOlder, signature,
-		 *   waitChange, onProgress }.
-		 *   `hasMore` returns true/false/null (null = the host cannot say, so the
-		 *   pager keeps going until a page changes nothing).
-		 * @returns { pages, reason } where reason is one of done | cancelled |
-		 *   capped | stalled | error.
+		/** Page only while the public host state is ready; false is not completeness.
+		 * Dependencies supply cancellable, bounded readiness/load/DOM waits.
+		 * @returns { pages, reason } with done, cancelled, capped, stalled, unknown or error.
 		 */
 		async function runPageIn(opts) {
 			var pages = 0;
-			var reason = "done";
+			function result(reason) { return { pages: pages, reason: reason }; }
 			for (;;) {
-				if (opts.isCancelled()) { reason = "cancelled"; break; }
-				if (opts.hasMore() === false) { reason = "done"; break; }
-				if (pages >= opts.maxPages) { reason = "capped"; break; }
+				if (opts.isCancelled()) return result("cancelled");
+				var ready = await opts.waitReady();
+				if (opts.isCancelled()) return result("cancelled");
+				if (ready.reason) return result(ready.reason);
+				if (ready.hasMore === false) return result("done");
+				if (pages >= opts.maxPages) return result("capped");
 				var before = opts.signature();
-				try {
-					await opts.loadOlder();
-				} catch (error) {
-					reason = "error";
-					break;
+				var loaded;
+				try { loaded = await opts.loadOlder(); }
+				catch (error) { loaded = { reason: "error" }; }
+				if (opts.isCancelled()) return result("cancelled");
+				ready = await opts.waitReady(!!(loaded && loaded.reason));
+				if (opts.isCancelled()) return result("cancelled");
+				if (loaded && loaded.reason) return result(loaded.reason);
+				if (ready.reason) return result(ready.reason);
+				if (loaded && loaded.deferred) continue;
+				if (ready.hasMore !== false) await opts.waitChange(before);
+				if (opts.isCancelled()) return result("cancelled");
+				ready = await opts.waitReady();
+				if (opts.isCancelled()) return result("cancelled");
+				if (ready.reason) return result(ready.reason);
+				var changed = opts.signature() !== before;
+				if (changed) {
+					pages += 1;
+					if (opts.onProgress) opts.onProgress(pages);
 				}
-				if (opts.isCancelled()) { reason = "cancelled"; break; }
-				if (!(await opts.waitChange(before))) { reason = "stalled"; break; }
-				pages += 1;
-				if (opts.onProgress) opts.onProgress(pages);
+				if (opts.isCancelled()) return result("cancelled");
+				if (ready.hasMore === false) return result("done");
+				if (!changed) return result("stalled");
 			}
-			return { pages: pages, reason: reason };
 		}
 		//#endregion
 
@@ -213,8 +240,8 @@ window.__ModuleLoader__.load({
 			return typeof CSS !== "undefined" && CSS.highlights && typeof Highlight === "function";
 		}
 
-		// Collect text nodes under `root`, descending into shadow roots and
-		// skipping the find bar itself plus invisible metadata tags.
+		// Keep the existing pager signature collector unchanged. Matching below
+		// uses separate block snapshots; page-settlement semantics are out of scope.
 		function collectTextNodes(root, into) {
 			if (!root) return into;
 			var walker = document.createTreeWalker(root, NodeFilter.SHOW_TEXT, {
@@ -239,17 +266,62 @@ window.__ModuleLoader__.load({
 			return into;
 		}
 
-		function collectRanges(query) {
+		// Join inline Text nodes only within one structural block and DOM root.
+		// These snapshots live for one scan. Preserve every original code unit,
+		// including whitespace-only nodes and code newlines; never trim or pad.
+		function collectTextBlocks(root) {
+			var blocks = [];
+			var text = "";
+			var segments = [];
+			function flush() {
+				if (segments.length) blocks.push({ text: text, segments: segments });
+				text = "";
+				segments = [];
+			}
+			function visit(node) {
+				if (node.nodeType === 3) {
+					if (node.data.length) {
+						segments.push({ node: node, start: text.length, end: text.length + node.data.length });
+						text += node.data;
+					}
+					return;
+				}
+				if (node.nodeType !== 1 && node.nodeType !== 11) return;
+				if (SKIP_TAGS[node.tagName] || node.id === BAR_ID || node.tagName === "BR") {
+					// Excluded subtrees and br are hard boundaries, not empty text.
+					flush();
+					return;
+				}
+				var boundary = BLOCK_TAGS[node.tagName] || node.nodeType === 11 || node.shadowRoot;
+				if (boundary) flush();
+				for (var child = node.firstChild; child; child = child.nextSibling) visit(child);
+				if (boundary) flush();
+				// No Range may span a shadow root and its surrounding light DOM.
+				if (node.shadowRoot) visit(node.shadowRoot);
+			}
+			visit(root);
+			flush();
+			return blocks;
+		}
+
+		function collectRanges(query, root) {
 			var ranges = [];
-			if (!query || typeof document === "undefined" || document.body === null) return ranges;
-			var nodes = collectTextNodes(document.body, []);
-			for (var i = 0; i < nodes.length && ranges.length < MAX_MATCHES; i++) {
-				var node = nodes[i];
-				var indices = findIndices(node.data, query);
-				for (var j = 0; j < indices.length && ranges.length < MAX_MATCHES; j++) {
+			if (!query || !root || typeof document === "undefined") return ranges;
+			var blocks = collectTextBlocks(root);
+			for (var i = 0; i < blocks.length && ranges.length < MAX_MATCHES; i++) {
+				var block = blocks[i];
+				var matches = findMatches(block.text, query);
+				var start = 0, end = 0;
+				for (var j = 0; j < matches.length && ranges.length < MAX_MATCHES; j++) {
+					var match = matches[j];
+					// At a node junction, start at the following node and end at
+					// the preceding node. Non-overlapping matches move forwards.
+					while (match.start >= block.segments[start].end) start++;
+					while (match.end > block.segments[end].end) end++;
+					var first = block.segments[start], last = block.segments[end];
 					var range = document.createRange();
-					range.setStart(node, indices[j]);
-					range.setEnd(node, indices[j] + query.length);
+					range.setStart(first.node, match.start - first.start);
+					range.setEnd(last.node, match.end - last.start);
 					ranges.push(range);
 				}
 			}
@@ -270,56 +342,232 @@ window.__ModuleLoader__.load({
 			}
 		}
 
-		/** Cheap proxy for "how much history is rendered" — used to notice a page landing. */
-		function domSignature() {
-			if (typeof document === "undefined" || document.body === null) return 0;
-			return collectTextNodes(document.body, []).length;
+		//#region host adapter
+		// Official session-scoped header utility props supply identity. DOM selectors
+		// are intentionally isolated here: see docs/compatibility.md for tag sources.
+		// No global current-session state and no page-wide search fallback.
+		function visible(element) {
+			if (!element || !element.isConnected || !element.getClientRects().length) return false;
+			for (var node = element; node; node = node.parentElement) {
+				if (node.hidden || node.getAttribute("aria-hidden") === "true") return false;
+				var css = window.getComputedStyle(node);
+				if (css.display === "none" || css.visibility === "hidden" || css.visibility === "collapse" || css.opacity === "0") return false;
+			}
+			return true;
+		}
+
+		function conversationPanel(element) {
+			// The host composer has its own unrelated data-phase. A conversation
+			// root additionally owns the scrollport (official startup fixture).
+			for (var node = element; node && node !== document.body; node = node.parentElement) {
+				if (!node.hasAttribute || !node.hasAttribute("data-phase")) continue;
+				var phase = node.getAttribute("data-phase");
+				// Preserve even a broken declared panel boundary; never walk through
+				// it to a different ancestor conversation because its scroll is absent.
+				if (phase === "active" || phase === "hero" || phase === "settling" || node.querySelector('[data-conversation-scroll]')) return node;
+			}
+			return null;
 		}
 
-		/** Resolve once the rendered history differs from `before`, or the page times out. */
-		function waitForChange(before) {
+		function resolveScope(anchor, sessionId) {
+			if (!anchor || typeof sessionId !== "string" || !sessionId || !visible(anchor)) return null;
+			var panel = conversationPanel(anchor);
+			if (!panel || panel.getAttribute("data-phase") !== "active" || panel === document.documentElement) return null;
+			var anchors = panel.querySelectorAll('[data-find-all-session]');
+			if (anchors.length !== 1 || anchors[0] !== anchor) return null;
+			var scrolls = panel.querySelectorAll('[data-conversation-scroll]');
+			if (scrolls.length !== 1) return null;
+			var content = scrolls[0].closest('[data-conversation-content]');
+			// 0.1.6-alpha.2 has the content wrapper but no identity attribute.
+			// Identity still comes from the unique session-scoped header anchor.
+			if (content && content.hasAttribute('data-conversation-session') && content.getAttribute('data-conversation-session') !== sessionId) return null;
+			var flows = scrolls[0].querySelectorAll('[data-chat-flow]');
+			if (flows.length !== 1 || !visible(flows[0])) return null;
+			return { panel: panel, root: flows[0] };
+		}
+
+		function createHostAdapter(ctx, changed) {
+			var entries = new Map();
+			var scopeUnavailable = false;
+			// Only a never-selected adapter may discover an initial neutral context.
+			// Explicit rejection or loss of a selection must never select a substitute.
+			var selectionState = "pristine";
+			function candidates() {
+				var out = [];
+				entries.forEach(function (id, anchor) {
+					// Keep unsupported/invisible instances in the identity roster. Dropping
+					// them before routing could silently choose a different valid session.
+					out.push({ id: id, anchor: anchor, panel: conversationPanel(anchor), scope: resolveScope(anchor, id) });
+				});
+				return out;
+			}
+			function choose(entry) {
+				if (!entry) return null;
+				if (!entry.scope) { selectionState = "rejected"; scopeUnavailable = true; return null; }
+				selectionState = "selected";
+				return { id: entry.id, anchor: entry.anchor, panel: entry.scope.panel, root: entry.scope.root };
+			}
+
+			function visibleEntry(entry) {
+				var container = entry.panel || entry.anchor.closest('[data-phase], [data-conversation-content]');
+				return visible(entry.anchor) || visible(container);
+			}
+
+			function discoverInitial(all) {
+				var shown = all.filter(visibleEntry);
+				var nodes = Array.prototype.filter.call(document.querySelectorAll('[data-phase], [data-conversation-content], [data-conversation-scroll], [data-chat-flow]'), visible);
+				scopeUnavailable = false;
+				if (shown.length === 0) {
+					// An empty resident Hero is not a session choice. A known active
+					// or identified but unregistered view is unavailable, not pristine.
+					if (nodes.some(function (node) { return node.getAttribute('data-phase') === 'active' || node.getAttribute('data-content-phase') === 'active' || node.hasAttribute('data-conversation-session') || node.hasAttribute('data-chat-flow'); })) {
+						selectionState = "rejected"; scopeUnavailable = true;
+					}
+					return null;
+				}
+				if (shown.length !== 1) { selectionState = "rejected"; return null; }
+				var entry = shown[0], scope = entry.scope;
+				if (!scope) return choose(entry);
+				var content = scope.root.closest('[data-conversation-content]');
+				var scroll = scope.root.closest('[data-conversation-scroll]');
+				// One main panel and its own content/scroll/flow count as one view.
+				// Any other visible known container, including a headerless embedded
+				// sidebar, makes neutral discovery ambiguous even if unsupported.
+				var other = nodes.some(function (node) {
+					if (node.hasAttribute('data-conversation-content') && node !== content) return true;
+					if (node.hasAttribute('data-conversation-scroll') && node !== scroll) return true;
+					if (node.hasAttribute('data-chat-flow') && node !== scope.root) return true;
+					return node.hasAttribute('data-phase') && conversationPanel(node) === node && node !== scope.panel;
+				});
+				if (other) { selectionState = "rejected"; return null; }
+				return choose(entry);
+			}
+
+			function refresh(entry) {
+				if (!entry) return null;
+				// Passive checks and repeated shortcuts may only retain this exact
+				// registered instance and identity. They never discover a substitute.
+				if (entries.get(entry.anchor) !== entry.id) { selectionState = "rejected"; scopeUnavailable = true; return null; }
+				scopeUnavailable = false;
+				return choose({ id: entry.id, anchor: entry.anchor, scope: resolveScope(entry.anchor, entry.id) });
+			}
+
+			return {
+				mount: function (anchor, id) {
+					entries.set(anchor, id);
+					changed();
+					return function () { entries.delete(anchor); changed(); };
+				},
+				refresh: refresh,
+				select: function (target, previous, retainNeutral) {
+					var all = candidates();
+					if (!target || !target.nodeType) target = document.activeElement;
+					if (target && state.bar && state.bar.contains(target)) return refresh(previous);
+					if (retainNeutral && (target === document.body || target === document.documentElement)) {
+						if (previous || selectionState !== "pristine") return refresh(previous);
+						return discoverInitial(all);
+					}
+					scopeUnavailable = false;
+					var direct = all.filter(function (entry) { return target && entry.anchor.contains(target); });
+					if (direct.length === 1) return choose(direct[0]);
+					var content = target && target.closest ? target.closest('[data-conversation-content]') : null;
+					var panel = conversationPanel(target) || content;
+					var hit = all.filter(function (entry) { return panel && entry.panel === panel; });
+					if (hit.length === 1) {
+						if (content && hit[0].scope && hit[0].scope.root.closest('[data-conversation-content]') !== content) {
+							selectionState = "rejected"; scopeUnavailable = true; return null;
+						}
+						return choose(hit[0]);
+					}
+					if (panel) {
+						// Before any session is selected, focus in the resident unbound
+						// Hero/settling composer is not a rejected conversation choice.
+						var phase = panel.getAttribute('data-phase') || panel.getAttribute('data-content-phase');
+						var unbound = !panel.hasAttribute('data-conversation-session') && !panel.querySelector('[data-conversation-session]');
+						if (selectionState === "pristine" && !previous && unbound && !all.some(visibleEntry) && (phase === "hero" || phase === "settling")) return null;
+						selectionState = "rejected"; scopeUnavailable = true; return null;
+					}
+					if (previous) selectionState = "rejected";
+					return null;
+				},
+				scopeUnavailable: function () { return scopeUnavailable; },
+				valid: function (entry) {
+					if (!entry || entries.get(entry.anchor) !== entry.id) return false;
+					var scope = resolveScope(entry.anchor, entry.id);
+					return !!scope && scope.root === entry.root;
+				},
+				face: function (entry) {
+					try {
+						if (!this.valid(entry) || !ctx.sessions || typeof ctx.sessions.binding !== "function") return null;
+						var binding = ctx.sessions.binding(entry.id);
+						var face = binding && binding.session;
+						return face && typeof face.loadOlder === "function" ? face : null;
+					} catch (error) { return null; }
+				},
+				clear: function () { entries.clear(); }
+			};
+		}
+
+		function domSignature(root) {
+			return root ? collectTextNodes(root, []).length : 0;
+		}
+
+		function waitForPage(check, isCancelled) {
 			return new Promise(function (resolve) {
 				var started = Date.now();
+				function finish(value) {
+					clearTimeout(state.settleTimer);
+					state.settleTimer = 0;
+					state.settleCancel = null;
+					resolve(value);
+				}
+				state.settleCancel = function () { finish({ reason: "cancelled" }); };
 				(function poll() {
-					if (domSignature() !== before) { resolve(true); return; }
-					if (Date.now() - started >= PAGE_SETTLE_MS) { resolve(false); return; }
-					setTimeout(poll, PAGE_POLL_MS);
+					if (isCancelled()) { finish({ reason: "cancelled" }); return; }
+					var value = check();
+					if (value) { finish(value); return; }
+					if (Date.now() - started >= PAGE_SETTLE_MS) { finish({ reason: "stalled" }); return; }
+					state.settleTimer = setTimeout(poll, PAGE_POLL_MS);
 				})();
 			});
 		}
 
-		//#region session bridge
-		//
-		// The `sessions` client service is provided by
-		// @deepseek-ai/dsh-api-session-controller; the per-session face it binds
-		// exposes loadOlder() plus a snapshot carrying hasMore/loadingOlder.
-		// Everything here is defensive: a host that changes shape must degrade to
-		// page-only search, never break the bar.
-
-		function resolveFace(ctx) {
+		function facePageState(face) {
 			try {
-				var sessions = ctx && ctx.sessions;
-				if (!sessions || !sessions.list || typeof sessions.list.getSnapshot !== "function") return null;
-				var id = sessions.list.getSnapshot().current;
-				if (!id) return null;
-				if (typeof sessions.binding !== "function") return null;
-				var binding = sessions.binding(id);
-				var face = binding && binding.session ? binding.session : null;
-				if (!face || typeof face.loadOlder !== "function") return null;
-				return { id: id, face: face };
-			} catch (error) {
-				return null;
-			}
+				var snapshot = typeof face.getSnapshot === "function" && face.getSnapshot();
+				if (!snapshot) return { reason: "unknown" };
+				if (snapshot.openError != null || snapshot.openState === "error") return { reason: "error" };
+				if (snapshot.openState === "cold" || snapshot.openState === "loading") return null;
+				if (snapshot.openState !== "open" || snapshot.openError !== null) return { reason: "unknown" };
+				if (snapshot.loadingOlder === true) return null;
+				if (snapshot.loadingOlder !== false) return { reason: "unknown" };
+				return { hasMore: typeof snapshot.hasMore === "boolean" ? snapshot.hasMore : null };
+			} catch (error) { return { reason: "unknown" }; }
 		}
 
-		function faceHasMore(face) {
-			try {
-				if (typeof face.getSnapshot !== "function") return null;
-				var snapshot = face.getSnapshot();
-				return snapshot && typeof snapshot.hasMore === "boolean" ? snapshot.hasMore : null;
-			} catch (error) {
-				return null;
-			}
+		// A cancelled UI task cannot abort SessionFace.loadOlder(). Keep its record
+		// until settlement so a later query/enable never starts a concurrent request.
+		var pendingLoads = new WeakMap();
+		async function loadPage(face, isCancelled) {
+			var status = facePageState(face);
+			if (!status || status.reason || status.hasMore === false || pendingLoads.has(face)) return { deferred: true };
+			var pending = { done: false, reason: null };
+			pendingLoads.set(face, pending);
+			var promise;
+			try { promise = Promise.resolve(face.loadOlder()); }
+			catch (error) { promise = Promise.reject(error); }
+			promise.then(function () {
+				pending.done = true;
+				pendingLoads.delete(face);
+			}, function () {
+				pending.done = true;
+				pending.reason = "error";
+				pendingLoads.delete(face);
+			});
+			await Promise.resolve();
+			return waitForPage(function () {
+				return pending.done ? { reason: pending.reason } : null;
+			}, isCancelled);
 		}
 		//#endregion
 
@@ -327,6 +575,10 @@ window.__ModuleLoader__.load({
 
 		var state = {
 			ctx: null,
+			adapter: null,
+			target: null,
+			settleTimer: 0,
+			settleCancel: null,
 			bar: null,
 			input: null,
 			count: null,
@@ -335,6 +587,7 @@ window.__ModuleLoader__.load({
 			query: "",
 			ranges: [],
 			index: -1,
+			selection: null,
 			capped: false,
 			observer: null,
 			debounce: 0,
@@ -370,6 +623,7 @@ window.__ModuleLoader__.load({
 		function setStatus(text, busy) {
 			if (!state.status) return;
 			state.status.textContent = text || "";
+			state.status.title = busy ? L.stopTip : (text || "");
 			if (busy) state.status.setAttribute("data-busy", "1");
 			else state.status.removeAttribute("data-busy");
 			updateCount();
@@ -384,32 +638,122 @@ window.__ModuleLoader__.load({
 			else state.scopeBtn.removeAttribute("data-whole");
 		}
 
+		function unavailableStatus() {
+			return state.target || (state.adapter && state.adapter.scopeUnavailable()) ? L.noRoot : L.noTarget;
+		}
+
+		// The code content wrapper survives the host's plain-pre -> Shiki tree
+		// swap (0.2.0-rc.2 CodeBlock). Otherwise use the nearest block boundary.
+		function selectionBlock(range, root) {
+			var nearest = null;
+			for (var node = range.startContainer.parentNode; node; node = node.parentNode) {
+				if (node === root || node.nodeType === 11) return nearest || node;
+				if (node.hasAttribute && node.hasAttribute("data-code-block-content")) return node;
+				if (!nearest && BLOCK_TAGS[node.tagName]) nearest = node;
+			}
+			return nearest;
+		}
+
+		function positionInBlocks(range, blocks) {
+			for (var i = 0; i < blocks.length; i++) {
+				var start = null, end = null;
+				for (var j = 0; j < blocks[i].segments.length; j++) {
+					var segment = blocks[i].segments[j];
+					if (segment.node === range.startContainer) start = segment.start + range.startOffset;
+					if (segment.node === range.endContainer) end = segment.start + range.endOffset;
+				}
+				if (start !== null && end !== null) return { run: i, start: start, end: end };
+			}
+			return null;
+		}
+
+		function matchNodes(blocks, position) {
+			if (!position) return [];
+			return blocks[position.run].segments.filter(function (segment) {
+				return segment.end > position.start && segment.start < position.end;
+			}).map(function (segment) {
+				return {
+					node: segment.node, text: segment.node.data,
+					start: Math.max(position.start, segment.start) - segment.start,
+					end: Math.min(position.end, segment.end) - segment.start
+				};
+			});
+		}
+
+		function rememberSelection() {
+			var range = state.ranges[state.index];
+			state.selection = null;
+			if (!range || !state.target) return;
+			var block = selectionBlock(range, state.target.root);
+			var blocks = block ? collectTextBlocks(block) : [];
+			var position = positionInBlocks(range, blocks);
+			var nodes = matchNodes(blocks, position);
+			state.selection = {
+				target: state.target, query: state.query, root: state.target.root,
+				startNode: range.startContainer, startOffset: range.startOffset,
+				endNode: range.endContainer, endOffset: range.endOffset,
+				block: block, position: position, nodes: nodes,
+				texts: blocks.map(function (item) { return item.text; })
+			};
+		}
+
+		function retainedIndex(saved) {
+			if (!saved || saved.target !== state.target || saved.query !== state.query || saved.root !== state.target.root) return -1;
+			if (!saved.block || !saved.block.isConnected || !saved.position) return -1;
+			var blocks = collectTextBlocks(saved.block);
+			var i, range;
+			for (i = 0; i < state.ranges.length; i++) {
+				range = state.ranges[i];
+				if (range.startContainer !== saved.startNode || range.startOffset !== saved.startOffset ||
+					range.endContainer !== saved.endNode || range.endOffset !== saved.endOffset) continue;
+				// Compare the new match's actual ordered participants. Old nodes can
+				// remain connected with unchanged text after moving outside this hit.
+				var nodes = matchNodes(blocks, positionInBlocks(range, blocks));
+				if (nodes.length > 0 && nodes.length === saved.nodes.length && nodes.every(function (item, index) {
+					var previous = saved.nodes[index];
+					return item.node === previous.node && item.text === previous.text && item.start === previous.start && item.end === previous.end;
+				})) return i;
+			}
+			if (blocks.length !== saved.texts.length || blocks.some(function (item, index) { return item.text !== saved.texts[index]; })) return -1;
+			var segments = blocks[saved.position.run].segments;
+			var first = null, last = null;
+			for (i = 0; i < segments.length; i++) {
+				if (saved.position.start >= segments[i].start && saved.position.start < segments[i].end) first = segments[i];
+				if (saved.position.end > segments[i].start && saved.position.end <= segments[i].end) last = segments[i];
+			}
+			if (!first || !last) return -1;
+			for (i = 0; i < state.ranges.length; i++) {
+				range = state.ranges[i];
+				if (range.startContainer === first.node && range.startOffset === saved.position.start - first.start &&
+					range.endContainer === last.node && range.endOffset === saved.position.end - last.start) return i;
+			}
+			return -1;
+		}
+
 		function runSearch(keepIndex) {
-			state.ranges = collectRanges(state.query);
+			var valid = state.adapter && state.adapter.valid(state.target);
+			state.ranges = valid ? collectRanges(state.query, state.target.root) : [];
+			if (!valid) setStatus(unavailableStatus(), false);
 			state.capped = state.ranges.length >= MAX_MATCHES;
-			if (!keepIndex || state.index >= state.ranges.length) state.index = state.ranges.length > 0 ? 0 : -1;
+			var retained = keepIndex && valid ? retainedIndex(state.selection) : -1;
+			if (!state.ranges.length) state.index = -1;
+			else if (!keepIndex) state.index = 0;
+			else state.index = retained >= 0 ? retained : Math.max(0, Math.min(state.index, state.ranges.length - 1));
+			rememberSelection();
 			paint();
 			updateCount();
-			if (state.index >= 0 && !highlightsSupported()) legacyFind(state.query, false);
+
 		}
 
 		function goTo(delta) {
+			if (!state.adapter || !state.adapter.valid(state.target)) { runSearch(false); return; }
 			var n = state.ranges.length;
 			if (n === 0) return;
-			if (highlightsSupported()) {
-				state.index = ((state.index + delta) % n + n) % n;
-				paint();
-				updateCount();
-				scrollToRange(state.ranges[state.index]);
-			} else {
-				legacyFind(state.query, delta < 0);
-			}
-		}
-
-		function legacyFind(query, backwards) {
-			if (typeof window.find === "function") {
-				try { window.find(query, false, backwards, true); } catch (error) {}
-			}
+			state.index = ((state.index + delta) % n + n) % n;
+			rememberSelection();
+			paint();
+			updateCount();
+			scrollToRange(state.ranges[state.index]);
 		}
 
 		function scheduleRescan() {
@@ -418,14 +762,14 @@ window.__ModuleLoader__.load({
 			if (state.paging) return;
 			clearTimeout(state.debounce);
 			state.debounce = setTimeout(function () {
-				if (state.bar) runSearch(true);
+				if (isOpen()) runSearch(true);
 			}, 250);
 		}
 
 		function startObserver() {
-			if (state.observer || typeof MutationObserver === "undefined") return;
+			if (state.observer || !state.target || typeof MutationObserver === "undefined") return;
 			state.observer = new MutationObserver(scheduleRescan);
-			state.observer.observe(document.documentElement, { childList: true, subtree: true, characterData: true });
+			state.observer.observe(state.target.root, { childList: true, subtree: true, characterData: true });
 		}
 
 		function stopObserver() {
@@ -438,6 +782,8 @@ window.__ModuleLoader__.load({
 
 		function cancelPageIn() {
 			state.pageToken += 1;
+			if (state.settleCancel) state.settleCancel();
+			clearTimeout(state.settleTimer);
 			clearTimeout(state.pageTimer);
 			state.pageTimer = 0;
 			state.paging = false;
@@ -453,57 +799,91 @@ window.__ModuleLoader__.load({
 
 		function startPageIn() {
 			if (state.scope !== "whole" || !state.query || !isOpen()) return;
-			var token = ++state.pageToken;
-			var resolved = resolveFace(state.ctx);
-			if (!resolved) {
-				setStatus(L.noService, false);
+			cancelPageIn();
+			var token = state.pageToken;
+			var target = state.target;
+			if (!state.adapter || !state.adapter.valid(target)) {
+				setStatus(unavailableStatus(), false);
 				return;
 			}
-			state.sessionId = resolved.id;
-			if (faceHasMore(resolved.face) === false) {
-				setStatus(L.allLoaded, false);
+			var face = state.adapter.face(target);
+			if (!face) {
+				setStatus(L.noService, false);
 				return;
 			}
+			state.sessionId = target.id;
+			function isCancelled() {
+				return token !== state.pageToken || !isOpen() || state.target !== target || !state.adapter || state.adapter.face(target) !== face;
+			}
+			function waitReady(failFast) {
+				return waitForPage(function () {
+					var status = facePageState(face);
+					if (status && status.reason) return status;
+					if (pendingLoads.has(face) || !status) return failFast ? { reason: "stalled" } : null;
+					return status;
+				}, isCancelled);
+			}
 			state.paging = true;
 			state.pages = 0;
 			setStatus(L.loading.replace("{n}", "0"), true);
 			runPageIn({
 				maxPages: MAX_PAGES,
-				isCancelled: function () { return token !== state.pageToken || !isOpen(); },
-				hasMore: function () { return faceHasMore(resolved.face); },
-				loadOlder: function () { return Promise.resolve(resolved.face.loadOlder()); },
-				signature: domSignature,
-				waitChange: waitForChange,
+				isCancelled: isCancelled,
+				waitReady: waitReady,
+				loadOlder: function () { return loadPage(face, isCancelled); },
+				signature: function () { return domSignature(target.root); },
+				waitChange: function (before) {
+					return waitForPage(function () {
+						var status = facePageState(face);
+						return domSignature(target.root) !== before || !status || status.reason || status.hasMore === false ? {} : null;
+					}, isCancelled);
+				},
 				onProgress: function (pages) {
-					if (token !== state.pageToken) return;
+					if (isCancelled()) return;
 					state.pages = pages;
 					setStatus(L.loading.replace("{n}", String(pages)), true);
 					runSearch(true);
 				}
 			}).then(function (result) {
-				if (token !== state.pageToken) return;
+				if (isCancelled()) {
+					// Face replacement cancels this task even if the DOM target survived.
+					if (token === state.pageToken) { state.paging = false; setStatus(L.incomplete, false); }
+					return;
+				}
+				var terminal = facePageState(face);
+				if (result.reason === "done" && (!terminal || terminal.reason || terminal.hasMore !== false || pendingLoads.has(face))) result.reason = "stalled";
 				state.paging = false;
 				state.pages = result.pages;
 				if (result.reason === "capped") setStatus(L.capped.replace("{n}", String(result.pages)), false);
-				else if (result.reason === "stalled" || result.reason === "error") setStatus(L.stalled, false);
-				else setStatus(result.pages > 0 ? L.allLoaded : "", false);
+				else if (result.reason !== "done") setStatus(L.incomplete, false);
+				else setStatus(L.available, false);
 				runSearch(true);
 			});
 		}
 
-		/** Drop everything paged for the previous session when the user switches. */
+		function syncTarget(target, passive, retainNeutral) {
+			if (!state.adapter) return;
+			var selected = passive ? state.adapter.refresh(state.target) : state.adapter.select(target || document.activeElement, state.target, retainNeutral);
+			if (selected && state.target && selected.id === state.target.id && selected.anchor === state.target.anchor && selected.root === state.target.root) return;
+			if (!selected && !state.target) {
+				if (isOpen()) runSearch(false);
+				return;
+			}
+			cancelPageIn();
+			stopObserver();
+			state.target = selected;
+			state.sessionId = selected ? selected.id : null;
+			if (!isOpen()) return;
+			setStatus(selected ? "" : unavailableStatus(), false);
+			runSearch(false);
+			startObserver();
+			if (selected && state.scope === "whole" && state.query) schedulePageIn();
+		}
+
 		function watchSession() {
 			clearInterval(state.sessionTimer);
 			state.sessionTimer = setInterval(function () {
-				if (!isOpen()) return;
-				var resolved = resolveFace(state.ctx);
-				var id = resolved ? resolved.id : null;
-				if (id === state.sessionId) return;
-				state.sessionId = id;
-				cancelPageIn();
-				setStatus("", false);
-				runSearch(false);
-				if (state.scope === "whole" && state.query) schedulePageIn();
+				if (isOpen()) syncTarget(null, true);
 			}, SESSION_POLL_MS);
 		}
 
@@ -582,7 +962,7 @@ window.__ModuleLoader__.load({
 			status.addEventListener("click", function () {
 				if (!state.paging) return;
 				cancelPageIn();
-				setStatus(L.stalled, false);
+				setStatus(L.incomplete, false);
 			});
 
 			bar.appendChild(input);
@@ -602,16 +982,17 @@ window.__ModuleLoader__.load({
 			document.body.appendChild(bar);
 		}
 
-		function open() {
+		function open(target) {
 			if (typeof document === "undefined" || document.body === null) return;
+			syncTarget(target || document.activeElement, false, true);
 			if (!state.bar) buildBar();
 			state.bar.style.display = "flex";
 			var selection = "";
 			try { selection = String(window.getSelection()).trim(); } catch (error) {}
-			if (selection && selection.length <= 200 && selection !== state.query) {
-				state.input.value = selection;
+			if (state.target && selection && selection.length <= 200 && selection !== state.query) {
 				state.query = selection;
 			}
+			state.input.value = state.query;
 			state.input.focus();
 			state.input.select();
 			runSearch(false);
@@ -624,9 +1005,9 @@ window.__ModuleLoader__.load({
 			cancelPageIn();
 			stopWatchingSession();
 			if (state.bar) state.bar.style.display = "none";
-			state.query = "";
 			state.ranges = [];
 			state.index = -1;
+			state.selection = null;
 			setStatus("", false);
 			paint(); // clears registered highlights
 			updateCount();
@@ -638,21 +1019,61 @@ window.__ModuleLoader__.load({
 		}
 
 		function apply(ctx) {
+			var react = require("react");
 			state.ctx = ctx;
-			injectCss();
-			var ops = {
-				open: open,
-				close: close,
-				goTo: goTo,
-				isOpen: isOpen,
-				isBarInput: function (target) { return target === state.input; }
-			};
-			window.addEventListener("keydown", createHandlers(ops), true);
+			state.adapter = createHostAdapter(ctx, function () {
+				syncTarget(null, true);
+			});
+			function SessionFind(props) {
+				var anchor = react.useRef(null);
+				react.useEffect(function () {
+					if (!anchor.current || !props.sessionId) return;
+					return state.adapter.mount(anchor.current, props.sessionId);
+				}, [props.sessionId]);
+				return react.createElement("button", {
+					ref: anchor, type: "button", title: L.find, "aria-label": L.find,
+					"data-find-all-session": props.sessionId,
+					onClick: function (event) { open(event.currentTarget); }
+				}, "⌕");
+			}
+			ctx.slots.inject("conversation.session.header.utilities", function () {
+				return ctx.slots.register({ name: "conversation.session.header.utilities", id: "dsh-find-all" }, SessionFind);
+			});
+			ctx.effect(function () {
+				injectCss();
+				var handler = createHandlers({
+					open: open, close: close, goTo: goTo, isOpen: isOpen,
+					isBarInput: function (target) { return target === state.input; }
+				});
+				function focus(event) {
+					if (!state.bar || !state.bar.contains(event.target)) syncTarget(event.target);
+				}
+				window.addEventListener("keydown", handler, true);
+				window.addEventListener("focusin", focus, true);
+				window.addEventListener("pointerdown", focus, true);
+				return function () {
+					window.removeEventListener("keydown", handler, true);
+					window.removeEventListener("focusin", focus, true);
+					window.removeEventListener("pointerdown", focus, true);
+					close();
+					state.query = "";
+					if (state.bar) state.bar.remove();
+					var style = document.querySelector('style[data-plugin-css="dsh-find-all/bar.css"]');
+					if (style) style.remove();
+					state.bar = state.input = state.count = state.status = state.scopeBtn = null;
+					state.adapter.clear();
+					state.target = state.ctx = null;
+				};
+			}, "find-all: browser lifecycle");
 		}
 
 		exports.apply = apply;
-		exports.inject = ["sessions"];
+		exports.inject = ["sessions", "slots"];
+		exports.resolveScope = resolveScope;
+		exports.createHostAdapter = createHostAdapter;
 		exports.findIndices = findIndices;         // for tests
+		exports.findMatches = findMatches;         // for tests
+		exports.collectRanges = collectRanges;     // for tests
 		exports.createHandlers = createHandlers;   // for tests
 		exports.runPageIn = runPageIn;             // for tests
 		return module.exports;