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

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## 0.1.6
+
+Fix text matching, history feedback and search state after the 0.1.5 compatibility release.
+
+- Match phrases across inline text and syntax-highlighting spans within one text block, while keeping separate messages, block elements, `<br>` elements and excluded content apart.
+- Preserve original UTF-16 offsets during case-insensitive Unicode matching, so characters such as `İ` no longer shift later highlights. Matching remains literal, without locale-specific folding or normalization.
+- Report “已搜索当前可用历史” when the host stops offering earlier pages. Recheck readiness and the final results before showing that status; it does not guarantee that the host's history is complete.
+- Keep the last query in the active plugin instance so reopening the bar can restore it. A valid new text selection takes priority; disabling the plugin, refreshing or restarting clears the query.
+- Preserve a verifiable current match when history is prepended or the page rescans, without scrolling automatically. Restore it across replaced text nodes only when the original block text is unchanged; otherwise clamp the previous result index. A new query or conversation selects the first result.
+- Add regression coverage for observer cleanup, conversation and embedded-panel isolation, cross-node text matching, history feedback, query retention and stable selection.
+
+The supported host-version list is unchanged. This patch does not add new Web or Desktop host-matrix acceptance evidence; the 0.1.5 compatibility notes and their documented limits still apply.
+
 ## 0.1.5
 
 Fix compatibility with newer DSH hosts while preserving the existing find controls and matching behavior.

package/README.md

@@ -1,6 +1,6 @@
 # dsh-find-all
 
-DSH Desktop 的 **⌘F / Ctrl+F 查找**插件。它有一个和浏览器查找不一样的地方：**搜的是整段会话，不只是屏幕上已经显示出来的那一截。**
+DSH Desktop 的 **⌘F / Ctrl+F 查找**插件。它有一个和浏览器查找不一样的地方：**会向宿主请求更早的历史，不只搜索当前已经显示出来的部分。**
 
 ## 为什么需要它
 
@@ -8,17 +8,18 @@ DSH 桌面窗口是 Electron 壳，本身没有浏览器那种查找栏。而会
 
 所以拿普通查找条搜一个较早的词，结果永远是 0，哪怕这段会话里确实有。
 
-这个插件在你输入关键词之后，通过会话服务把更早的历史一页页加载进来，每加载一页就重搜一次，直到整段会话都在页面里。这样命中计数和高亮覆盖的是**整个会话**。
+这个插件在你输入关键词之后，通过会话服务把更早的历史一页页加载进来，每加载一页就重搜一次。宿主不再提供更早页时，最后重搜并提示“已搜索当前可用历史”。宿主公开接口不能证明历史完整性，插件不会把终止信号当作“全部搜完”。
 
 ## 功能
 
-- **⌘F / Ctrl+F** 唤起查找栏，自动带入当前选中的文字
+- **⌘F / Ctrl+F** 唤起查找栏，优先带入有效的选中文字；没有新选词时恢复上次关键词。关键词仅保留在当前插件实例内存中，禁用、刷新或重启后清空
 - **范围切换**：`整段`（默认）↔ `本页`，点那个胶囊按钮切换
 - **边搜边加载**：整段模式下自动分页加载历史，高亮与计数随加载实时更新
 - **进度可见**：显示「正在加载更早的历史… 已 3 页」，**点一下这段文字即可停止加载**
 - **安全上限**：最多加载 400 页（约 2 万条消息）；历史不再增长时会自行停止
 - **导航**：Enter / Shift+Enter 上下一个；⌘G（Ctrl+G）/ F3 下一个，加 Shift 反向；Esc 关闭查找栏并清除高亮
-- 切换会话时自动重置，并在新会话里重新开始搜索
+- 切换会话时清除旧结果，并在新会话里重搜同一关键词
+- 后台重扫首次找到结果时选中第一项；前插历史时优先保留可确认的当前命中，不自动滚动。原节点可对应，或同一正文块仍在且原文完全未变时，可在 Text/span 换树后恢复当前项；无法确认时把旧序号夹到新结果范围，换词或换会话则选第一项
 
 ## 安装
 
@@ -65,6 +66,8 @@ dsh plugin --profile desktop remove dsh-find-bar
 - 单次搜索最多记 5000 个命中
 - 折叠起来的工具调用和思考块，正文不在页面里，搜不到——先展开再搜
 - 整段模式要真的翻历史，所以很长的会话首次搜索需要等几秒
+- 宿主尚未就绪、公开报错、无进展或到达上限时，保留已找到的结果并提示未完成；再次打开查找或输入关键词可手动重试。停止、关闭、换词或切换会话会取消插件任务，但不会中断宿主已经发出的请求
+- “已搜索当前可用历史”不保证历史完整。宿主可能在正常末页和不连续页错误时都不再提供更早页；此时重新查找也不保证恢复缺失历史
 
 ## 卸载 / 回退
 

package/lib/client.js

@@ -21,14 +21,14 @@
 //   * 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.
@@ -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,9 +82,8 @@ window.__ModuleLoader__.load({
 			scopeToPage: "搜索范围：整段会话。点击改为只搜当前页面",
 			scopeToWhole: "搜索范围：仅当前页面。点击改为搜索整段会话",
 			loading: "正在加载更早的历史… 已 {n} 页",
-			allLoaded: "整段会话已就绪",
-			capped: "已到加载上限（{n} 页），停止加载",
-			stalled: "没有更早的历史了",
+			available: "已搜索当前可用历史；宿主未提供更早页，无法确认历史完整性",
+			capped: "历史尚未搜完：已到加载上限（{n} 页）",
 			stopTip: "点击停止加载",
 			noService: "会话接口不可用，仅保留已显示的部分结果",
 			noTarget: "请先选择可见的会话，再打开查找",
@@ -92,9 +101,8 @@ 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 results only",
 			noTarget: "Select a visible conversation before opening find",
@@ -105,22 +113,30 @@ window.__ModuleLoader__.load({
 
 		//#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) {
@@ -151,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
 
@@ -221,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, {
@@ -247,17 +266,62 @@ window.__ModuleLoader__.load({
 			return into;
 		}
 
+		// 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 || !root || typeof document === "undefined") return ranges;
-			var nodes = collectTextNodes(root, []);
-			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++) {
+			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);
 				}
 			}
@@ -448,7 +512,7 @@ window.__ModuleLoader__.load({
 			return root ? collectTextNodes(root, []).length : 0;
 		}
 
-		function waitForChange(before, root, token) {
+		function waitForPage(check, isCancelled) {
 			return new Promise(function (resolve) {
 				var started = Date.now();
 				function finish(value) {
@@ -457,24 +521,53 @@ window.__ModuleLoader__.load({
 					state.settleCancel = null;
 					resolve(value);
 				}
-				state.settleCancel = function () { finish(false); };
+				state.settleCancel = function () { finish({ reason: "cancelled" }); };
 				(function poll() {
-					if (token !== state.pageToken || !state.adapter.valid(state.target)) { finish(false); return; }
-					if (domSignature(root) !== before) { finish(true); return; }
-					if (Date.now() - started >= PAGE_SETTLE_MS) { finish(false); return; }
+					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);
 				})();
 			});
 		}
 
-		function faceHasMore(face) {
+		function facePageState(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;
-			}
+				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" }; }
+		}
+
+		// 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
 
@@ -494,6 +587,7 @@ window.__ModuleLoader__.load({
 			query: "",
 			ranges: [],
 			index: -1,
+			selection: null,
 			capped: false,
 			observer: null,
 			debounce: 0,
@@ -529,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();
@@ -547,12 +642,104 @@ window.__ModuleLoader__.load({
 			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) {
 			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();
 
@@ -563,6 +750,7 @@ window.__ModuleLoader__.load({
 			var n = state.ranges.length;
 			if (n === 0) return;
 			state.index = ((state.index + delta) % n + n) % n;
+			rememberSelection();
 			paint();
 			updateCount();
 			scrollToRange(state.ranges[state.index]);
@@ -611,7 +799,8 @@ window.__ModuleLoader__.load({
 
 		function startPageIn() {
 			if (state.scope !== "whole" || !state.query || !isOpen()) return;
-			var token = ++state.pageToken;
+			cancelPageIn();
+			var token = state.pageToken;
 			var target = state.target;
 			if (!state.adapter || !state.adapter.valid(target)) {
 				setStatus(unavailableStatus(), false);
@@ -623,33 +812,51 @@ window.__ModuleLoader__.load({
 				return;
 			}
 			state.sessionId = target.id;
-			if (faceHasMore(face) === false) {
-				setStatus(L.allLoaded, false);
-				return;
+			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() || !state.adapter.valid(target); },
-				hasMore: function () { return faceHasMore(face); },
-				loadOlder: function () { return Promise.resolve(face.loadOlder()); },
+				isCancelled: isCancelled,
+				waitReady: waitReady,
+				loadOlder: function () { return loadPage(face, isCancelled); },
 				signature: function () { return domSignature(target.root); },
-				waitChange: function (before) { return waitForChange(before, target.root, token); },
+				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 !== "done") setStatus(L.incomplete, false);
-				else setStatus(result.pages > 0 ? L.allLoaded : "", false);
+				else setStatus(L.available, false);
 				runSearch(true);
 			});
 		}
@@ -783,9 +990,9 @@ window.__ModuleLoader__.load({
 			var selection = "";
 			try { selection = String(window.getSelection()).trim(); } catch (error) {}
 			if (state.target && selection && selection.length <= 200 && selection !== state.query) {
-				state.input.value = selection;
 				state.query = selection;
 			}
+			state.input.value = state.query;
 			state.input.focus();
 			state.input.select();
 			runSearch(false);
@@ -798,10 +1005,9 @@ window.__ModuleLoader__.load({
 			cancelPageIn();
 			stopWatchingSession();
 			if (state.bar) state.bar.style.display = "none";
-			state.query = "";
-			if (state.input) state.input.value = "";
 			state.ranges = [];
 			state.index = -1;
+			state.selection = null;
 			setStatus("", false);
 			paint(); // clears registered highlights
 			updateCount();
@@ -850,6 +1056,7 @@ window.__ModuleLoader__.load({
 					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();
@@ -865,6 +1072,8 @@ window.__ModuleLoader__.load({
 		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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ryuu-64/dsh-find-all",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "description": "Ctrl+F find bar for the DSH desktop app: it searches the whole conversation, not just the messages already on screen.",
   "type": "module",
   "license": "MIT",