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

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## 0.1.7
+
+- Use the host-native icon button for the conversation search entry, including theme, hover and keyboard-focus styles.
+- Clarify that search covers loaded conversation content and can continue loading available earlier history; status text no longer implies complete history when the host cannot provide it.
+- Retain the current match during history loading when its identity can still be verified.
+
+The runtime code is unchanged from the accepted PR #17 merge (`f945fb9ccd581c808bc7f50128c3a7d7d2fca6da`). The existing 195 checks, release-artifact verification and RC2 Web acceptance passed; the user also confirmed their real-device test passed before this release. The exact supported host-version list is unchanged.
+
+## 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,19 @@ DSH 桌面窗口是 Electron 壳，本身没有浏览器那种查找栏。而会
 
 所以拿普通查找条搜一个较早的词，结果永远是 0，哪怕这段会话里确实有。
 
-这个插件在你输入关键词之后，通过会话服务把更早的历史一页页加载进来，每加载一页就重搜一次，直到整段会话都在页面里。这样命中计数和高亮覆盖的是**整个会话**。
+这个插件在你输入关键词之后，通过会话服务把更早的历史一页页加载进来，每加载一页就重搜一次。宿主不再提供更早页时，最后重搜并提示“已搜索当前可用历史”。宿主公开接口不能证明历史完整性，插件不会把终止信号当作“全部搜完”。
 
 ## 功能
 
-- **⌘F / Ctrl+F** 唤起查找栏，自动带入当前选中的文字
-- **范围切换**：`整段`（默认）↔ `本页`，点那个胶囊按钮切换
-- **边搜边加载**：整段模式下自动分页加载历史，高亮与计数随加载实时更新
+- **⌘F / Ctrl+F** 唤起查找栏，优先带入有效的选中文字；没有新选词时恢复上次关键词。关键词仅保留在当前插件实例内存中，禁用、刷新或重启后清空
+- **范围切换**：`包含更早内容`（默认）↔ `已加载内容`，点那个胶囊按钮切换
+- **已加载内容**：只搜索当前会话中已经加载到页面的内容，包括滚动区域外的内容；不会继续加载历史，也不会移除先前已经加载的内容
+- **边搜边加载**：“包含更早内容”模式下自动分页加载历史，高亮与计数随加载实时更新
 - **进度可见**：显示「正在加载更早的历史… 已 3 页」，**点一下这段文字即可停止加载**
 - **安全上限**：最多加载 400 页（约 2 万条消息）；历史不再增长时会自行停止
 - **导航**：Enter / Shift+Enter 上下一个；⌘G（Ctrl+G）/ F3 下一个，加 Shift 反向；Esc 关闭查找栏并清除高亮
-- 切换会话时自动重置，并在新会话里重新开始搜索
+- 切换会话时清除旧结果，并在新会话里重搜同一关键词
+- 后台重扫首次找到结果时选中第一项；前插历史时优先保留可确认的当前命中，不自动滚动。原节点可对应，或同一正文块仍在且原文完全未变时，可在 Text/span 换树后恢复当前项；无法确认时把旧序号夹到新结果范围，换词或换会话则选第一项
 
 ## 安装
 
@@ -53,7 +55,7 @@ dsh plugin --profile desktop remove dsh-find-bar
 | 打开查找栏 | `⌘F` / `Ctrl+F` |
 | 下一个 / 上一个命中 | `Enter` / `Shift+Enter` |
 | 下一个 / 上一个命中（另一套） | `⌘G`（`Ctrl+G`）/ `F3`，加 `Shift` 反向 |
-| 切换范围 `整段` ↔ `本页` | 点查找栏上的胶囊按钮 |
+| 切换范围 `包含更早内容` ↔ `已加载内容` | 点查找栏上的胶囊按钮 |
 | 停止加载更早的历史 | 点「正在加载更早的历史…」那行文字 |
 | 关闭并清除高亮 | `Esc` |
 
@@ -62,9 +64,11 @@ dsh plugin --profile desktop remove dsh-find-bar
 ## 已知限制
 
 - 大小写不敏感，没有「区分大小写」开关
-- 单次搜索最多记 5000 个命中
+- 单次搜索仅显示前 5000 处匹配
 - 折叠起来的工具调用和思考块，正文不在页面里，搜不到——先展开再搜
-- 整段模式要真的翻历史，所以很长的会话首次搜索需要等几秒
+- “包含更早内容”模式要真的翻历史，所以很长的会话首次搜索需要等几秒
+- 宿主尚未就绪、公开报错、无进展或到达上限时，保留已找到的结果并提示未完成；再次打开查找或输入关键词可手动重试。停止、关闭、换词或切换会话会取消插件任务，但不会中断宿主已经发出的请求
+- “已搜索当前可用历史”不保证历史完整。宿主可能在正常末页和不连续页错误时都不再提供更早页；此时重新查找也不保证恢复缺失历史
 
 ## 卸载 / 回退
 
@@ -79,7 +83,7 @@ dsh plugin --profile desktop add dsh-find-bar               # 想换回上游那
 
 ## 关于这个项目
 
-本插件 fork 自 [secyborg/dsh-find-bar](https://github.com/secyborg/dsh-find-bar)（作者 secyborg，MIT），在上游的基础上加了「整段会话」搜索。上游原有的查找条界面、高亮、`n/N` 计数和键盘导航都保留了下来。
+本插件 fork 自 [secyborg/dsh-find-bar](https://github.com/secyborg/dsh-find-bar)（作者 secyborg，MIT），在上游的基础上加了自动加载更早内容的会话搜索。上游原有的查找条界面、高亮、`n/N` 计数和键盘导航都保留了下来。
 
 版权与许可为 MIT 双署名：`Copyright (c) 2026 secyborg` 与 `Copyright (c) 2026 Ryuu-64`。上游 README 原样保存在 `README.fork-origin.md`，改动清单与致谢见 `NOTICE.md`。
 

package/lib/client.js

@@ -17,18 +17,18 @@
 // nothing, even though the conversation demonstrably contains it.
 //
 // What this plugin adds:
-//   * A scope toggle in the bar: 「整段 / Whole」 (default) and 「本页 / Page」.
+//   * A scope toggle in the bar: 「包含更早内容 / Include earlier content」 (default) and 「已加载内容 / Loaded content」.
 //   * 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,44 +59,52 @@ 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 ? {
-			placeholder: "查找整段会话…",
+			placeholder: "在此会话中查找…",
 			prev: "上一个匹配",
 			next: "下一个匹配",
 			close: "关闭查找",
-			cap: "已达匹配上限，仅显示前 {n} 条",
-			scopeWhole: "整段",
-			scopePage: "本页",
-			scopeToPage: "搜索范围：整段会话。点击改为只搜当前页面",
-			scopeToWhole: "搜索范围：仅当前页面。点击改为搜索整段会话",
+			cap: "仅显示前 {n} 处匹配",
+			scopeWhole: "包含更早内容",
+			scopePage: "已加载内容",
+			scopeToPage: "搜索当前会话中已加载的内容，并继续加载更早内容。点击改为仅搜索已加载内容",
+			scopeToWhole: "仅搜索当前会话中已加载的内容，不再加载更早内容。点击改为包含更早内容",
 			loading: "正在加载更早的历史… 已 {n} 页",
-			allLoaded: "整段会话已就绪",
-			capped: "已到加载上限（{n} 页），停止加载",
-			stalled: "没有更早的历史了",
+			available: "已搜索当前可用历史；宿主未提供更早页，无法确认历史完整性",
+			capped: "搜索未完成：已到更早内容的加载上限（{n} 页），已保留找到的结果",
 			stopTip: "点击停止加载",
-			noService: "会话接口不可用，仅保留已显示的部分结果",
+			noService: "搜索未完成：会话接口不可用，已保留找到的结果",
 			noTarget: "请先选择可见的会话，再打开查找",
 			noRoot: "当前会话的搜索范围不可用",
-			incomplete: "历史尚未搜完，保留部分结果",
+			incomplete: "搜索未完成，已保留找到的结果",
 			find: "查找会话"
 		} : {
-			placeholder: "Find in conversation…",
+			placeholder: "Find in this conversation…",
 			prev: "Previous match",
 			next: "Next match",
 			close: "Close find",
-			cap: "Match limit reached, showing first {n}",
-			scopeWhole: "Whole",
-			scopePage: "Page",
-			scopeToPage: "Scope: the whole conversation. Click to search only the rendered page",
-			scopeToWhole: "Scope: the rendered page only. Click to search the whole conversation",
+			cap: "Showing only the first {n} matches",
+			scopeWhole: "Include earlier content",
+			scopePage: "Loaded content",
+			scopeToPage: "Search loaded content in this conversation and load earlier content. Click to search loaded content only",
+			scopeToWhole: "Search only content already loaded in this conversation, without loading more. Click to include earlier content",
 			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: loading limit reached ({n} pages); partial results retained",
 			stopTip: "Click to stop loading",
-			noService: "Session service unavailable; rendered results only",
+			noService: "History search incomplete: session service unavailable; partial results retained",
 			noTarget: "Select a visible conversation before opening find",
 			noRoot: "Search scope unavailable for this conversation",
 			incomplete: "History search incomplete; partial results retained",
@@ -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,
@@ -524,11 +618,16 @@ window.__ModuleLoader__.load({
 			if (!state.query) state.count.textContent = "";
 			else if (n === 0) state.count.textContent = state.paging ? "…" : "0/0";
 			else state.count.textContent = (state.index + 1) + "/" + n + (state.capped ? "+" : "");
+			var cap = state.query && n > 0 && state.capped ? L.cap.replace("{n}", String(MAX_MATCHES)) : "";
+			state.count.title = cap;
+			if (cap) state.count.setAttribute("aria-label", state.count.textContent + "; " + cap);
+			else state.count.removeAttribute("aria-label");
 		}
 
 		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 +646,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 +754,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 +803,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 +816,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);
 			});
 		}
@@ -747,6 +958,7 @@ window.__ModuleLoader__.load({
 
 			var count = document.createElement("span");
 			count.className = "count";
+			count.setAttribute("role", "status");
 			count.setAttribute("aria-live", "polite");
 
 			var status = document.createElement("span");
@@ -783,9 +995,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 +1010,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();
@@ -814,6 +1025,8 @@ window.__ModuleLoader__.load({
 
 		function apply(ctx) {
 			var react = require("react");
+			var ui = require("@deepseek-ai/dsh-client-ui-primitives");
+			var SearchIcon = ui.IconSearchOutlineRegular || ui.IconSearchOutline16;
 			state.ctx = ctx;
 			state.adapter = createHostAdapter(ctx, function () {
 				syncTarget(null, true);
@@ -822,13 +1035,18 @@ window.__ModuleLoader__.load({
 				var anchor = react.useRef(null);
 				react.useEffect(function () {
 					if (!anchor.current || !props.sessionId) return;
-					return state.adapter.mount(anchor.current, props.sessionId);
+					// Older supported Button exports do not forward refs. Always
+					// register the real button rather than the sizing-neutral wrapper.
+					var button = anchor.current.querySelector("button[data-find-all-session]");
+					if (button) return state.adapter.mount(button, props.sessionId);
 				}, [props.sessionId]);
-				return react.createElement("button", {
-					ref: anchor, type: "button", title: L.find, "aria-label": L.find,
+				return react.createElement("span", { ref: anchor, style: { display: "inline-flex", flex: "none" } },
+					react.createElement(ui.Button, {
+					type: "button", size: "sm", variant: "ghost", title: L.find, "aria-label": L.find,
+					style: { flex: "none", width: 28, padding: 0, color: "var(--dsw-alias-label-secondary)" },
 					"data-find-all-session": props.sessionId,
 					onClick: function (event) { open(event.currentTarget); }
-				}, "⌕");
+				}, react.createElement(SearchIcon, { size: 15 })));
 			}
 			ctx.slots.inject("conversation.session.header.utilities", function () {
 				return ctx.slots.register({ name: "conversation.session.header.utilities", id: "dsh-find-all" }, SessionFind);
@@ -850,6 +1068,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 +1084,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.7",
   "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",
@@ -38,7 +38,8 @@
   "peerDependencies": {
     "@deepseek-ai/dsh-api-session-controller": "0.1.5-rc.2 || 0.1.5-rc.3 || 0.1.6-alpha.1 || 0.1.6-alpha.2 || 0.1.7-alpha.1 || 0.1.7-alpha.2 || 0.1.7-rc.1 || 0.1.7-rc.2 || 0.2.0-rc.1 || 0.2.0-rc.2",
     "@deepseek-ai/dsh-client-ui-chat": "0.1.5-rc.2 || 0.1.5-rc.3 || 0.1.6-alpha.1 || 0.1.6-alpha.2 || 0.1.7-alpha.1 || 0.1.7-alpha.2 || 0.1.7-rc.1 || 0.1.7-rc.2 || 0.2.0-rc.1 || 0.2.0-rc.2",
-    "@deepseek-ai/dsh-client-ui-conversation": "0.1.5-rc.2 || 0.1.5-rc.3 || 0.1.6-alpha.1 || 0.1.6-alpha.2 || 0.1.7-alpha.1 || 0.1.7-alpha.2 || 0.1.7-rc.1 || 0.1.7-rc.2 || 0.2.0-rc.1 || 0.2.0-rc.2"
+    "@deepseek-ai/dsh-client-ui-conversation": "0.1.5-rc.2 || 0.1.5-rc.3 || 0.1.6-alpha.1 || 0.1.6-alpha.2 || 0.1.7-alpha.1 || 0.1.7-alpha.2 || 0.1.7-rc.1 || 0.1.7-rc.2 || 0.2.0-rc.1 || 0.2.0-rc.2",
+    "@deepseek-ai/dsh-client-ui-primitives": "0.1.5-rc.2 || 0.1.5-rc.3 || 0.1.6-alpha.1 || 0.1.6-alpha.2 || 0.1.7-alpha.1 || 0.1.7-alpha.2 || 0.1.7-rc.1 || 0.1.7-rc.2 || 0.2.0-rc.1 || 0.2.0-rc.2"
   },
   "scripts": {
     "test": "node --test \"test/**/*.test.mjs\"",