@tobq/boardclip 2.1.110 → 2.1.112

package/index.html

@@ -242,22 +242,54 @@ function renderGroupFilters() {
 // relaxCache: the same for the empty-result nudge (Core.search.bestRelaxation).
 const searchRefineCache = {};
 const relaxCache = {};
+// A query with a /regex/ is searched on a worker (Core.createSearchWorker): the
+// list keeps its rows, dimmed after a moment, until the answer arrives.
+// shownQuery is the query the rows on screen were found with, so a row built
+// meanwhile (a scroll) highlights against it, never against a pattern the
+// worker has not run yet. regexFirst: where each regex match first sits in its
+// body (the worker found it; the row never scans the body itself).
+let shownQuery = '';
+let regexFirst = null;
+const searchWorker = Core.createSearchWorker({
+  onBusy: (busy) => { listEl.classList.toggle('searching', busy); listEl.setAttribute('aria-busy', busy ? 'true' : 'false'); updateCount(); },
+  onError: (message) => { const p = window.api.recordDiagnostics?.('renderer.search_worker_error', { message }); if (p && p.catch) p.catch(() => {}); },
+});
 function applyFilter() {
   const startedAt = performance.now();
-  const firstTerm = parsedQuery().terms.find(c => !c.regex && c.scope !== 'title');
+  if (Core.search.hasRegexTerm(parsedQuery())) {
+    const q = query;
+    const docs = searchDocs;
+    searchWorker.search({ docs, hays: searchTextLower, query: q, sortMode, now: Date.now() }, (r) => {
+      if (docs !== searchDocs) { scheduleRerenderList(); return; } // the history moved on: search again
+      regexFirst = new Map();
+      r.indexes.forEach((ri, k) => regexFirst.set(ri, r.first[k]));
+      showFiltered(q, r.indexes, r.relax);
+      updateCount();
+      recordRendererPerf('list.regex_search', startedAt, { rendered: renderedCount(), regex: true }, 400);
+    });
+    return;
+  }
+  searchWorker.cancel();
+  regexFirst = null;
+  showFiltered(query, Core.filterItemIndexes(items, { query, docs: searchDocs, searchTextLower, sortMode, cache: searchRefineCache }));
+  recordRendererPerf('list.apply_filter', startedAt, { rendered: renderedCount(), regex: searchBox.getRegex() }, 60);
+}
+// relax: the worker's empty-result nudge (a regex query), else worked out here.
+function showFiltered(q, rows, relax) {
+  shownQuery = q;
+  const parsed = Core.search.parseQuery(q);
+  const firstTerm = parsed.terms.find(c => !c.regex && c.scope !== 'title');
   previewTerm = firstTerm ? String(firstTerm.value).trim().toLowerCase() || null : null;
-  filtered = Core.filterItemIndexes(items, { query, docs: searchDocs, searchTextLower, sortMode, cache: searchRefineCache });
-  const rows = filtered;
+  filtered = rows;
   const rowItems = items;
   clipList.update({
     ids: rows.map(ri => itemId(rowItems[ri])),
     tsAt: (i) => Number(rowItems[rows[i]] && rowItems[rows[i]].ts) || 0,
-    mode: Core.search.rankMode(parsedQuery(), sortMode),
-    queryKey: query,
+    mode: Core.search.rankMode(parsed, sortMode),
+    queryKey: q,
     // Only when the list IS empty: the one filter whose removal brings clips back.
-    emptyHtml: () => Core.renderEmptyState({ total: items.length, query, groups, nudgeHtml: Core.renderRelaxNudge(Core.search.bestRelaxation(searchDocs, query, { searchTextLower, cache: relaxCache })) }),
+    emptyHtml: () => Core.renderEmptyState({ total: items.length, query: q, groups, nudgeHtml: Core.renderRelaxNudge(relax !== undefined ? relax : Core.search.bestRelaxation(searchDocs, q, { searchTextLower, cache: relaxCache })) }),
   });
-  recordRendererPerf('list.apply_filter', startedAt, { rendered: renderedCount(), regex: searchBox.getRegex() }, 60);
 }
 function renderedCount() { const w = clipList.window(); return w.end - w.start; }
 
@@ -299,6 +331,7 @@ function scheduleRelativeTimeRefresh() {
 // haystack (no scan of the body itself); null lets the preview search instead.
 let previewTerm = null;
 function previewMatchIndex(ri) {
+  if (regexFirst) return regexFirst.has(ri) ? regexFirst.get(ri) : -1;
   if (!previewTerm || !searchDocs[ri]) return null;
   return Core.search.bodyIndexOf(searchDocs[ri], searchTextLower[ri], previewTerm);
 }
@@ -308,7 +341,7 @@ function buildItem(it, ri) {
   // similar rows (it lives in the shared controller).
   return Core.renderClipItem(it, {
     imageSrc: item => `clip-img:///${esc(item.image)}`,
-    query,
+    query: shownQuery,
     matchIndex: previewMatchIndex(ri),
     selection: controller ? controller.selection() : null,
     actionsHtml: Core.renderClipActions(it),
@@ -318,7 +351,7 @@ function buildItem(it, ri) {
 function updateCount() {
   const total = items.length;
   const visible = filtered.length;
-  countEl.textContent = Core.itemCountLabel(total, visible, { query });
+  countEl.textContent = searchWorker.busy() ? 'Searching...' : Core.itemCountLabel(total, visible, { query });
 }
 
 // The clear / sort / mode / options buttons slide in and out with the field's

package/lib/mcp-search-thread.js

@@ -0,0 +1,58 @@
+'use strict';
+
+// search_clips for the MCP helper and the app's approved full search, with a
+// query that holds a /regex/ run on a worker thread: one pattern can backtrack
+// for minutes on a long line (12 Oct 2026, the popup froze on
+// y.*t.*b.*\?.*t= against a 20,000-char line), and on the calling thread that
+// would hang the helper, or the app's main process for an approved search.
+// The worker ends when the caller gives up (its abort signal) or, as a
+// backstop for a caller that never does, after MAX_MS. A query without a regex
+// runs right here, as before (a literal scan is linear).
+//
+// This file is also the worker's entry (workerData.mcpSearch).
+
+const { Worker, isMainThread, parentPort, workerData } = require('worker_threads');
+const mcpCore = require('./mcp-core');
+const search = require('../site/shared/clip-search');
+
+const MAX_MS = 2 * 60 * 1000;
+
+if (!isMainThread && workerData && workerData.mcpSearch) {
+  const { history, settings, opts } = workerData.mcpSearch;
+  parentPort.postMessage(mcpCore.searchClips(history, settings, opts));
+}
+
+function hasRegex(opts) {
+  const o = opts || {};
+  return search.hasRegexTerm(search.parseQuery(o.regex ? search.legacyRegexQuery(o.query) : o.query));
+}
+
+// Resolves to searchClips' result; rejects with a message for the AI client
+// when the pattern ran past the caller's patience.
+function searchClipsOffThread(history, settings, opts, { signal, maxMs = MAX_MS } = {}) {
+  if (!hasRegex(opts)) return Promise.resolve(mcpCore.searchClips(history, settings, opts));
+  return new Promise((resolve, reject) => {
+    const worker = new Worker(__filename, { workerData: { mcpSearch: { history, settings, opts } } });
+    let done = false;
+    const finish = (fn, value) => {
+      if (done) return;
+      done = true;
+      clearTimeout(timer);
+      if (signal) signal.removeEventListener('abort', onAbort);
+      worker.terminate().catch(() => {});
+      fn(value);
+    };
+    const tooSlow = () => new Error('This regular expression took too long on the clips (a few .* in a row backtrack on long lines). Narrow it, e.g. anchor it with literal text.');
+    const onAbort = () => finish(reject, new Error('cancelled'));
+    const timer = setTimeout(() => finish(reject, tooSlow()), maxMs);
+    if (signal) {
+      if (signal.aborted) { onAbort(); return; }
+      signal.addEventListener('abort', onAbort);
+    }
+    worker.once('message', (result) => finish(resolve, result));
+    worker.once('error', (error) => finish(reject, error));
+    worker.once('exit', (code) => finish(reject, new Error(`search worker exited (${code})`)));
+  });
+}
+
+module.exports = { searchClipsOffThread, MAX_MS };

package/lib/window-placement.js

@@ -0,0 +1,80 @@
+'use strict';
+
+// Where a clip window (editor, viewer, unify, conflict) opens, as pure maths so
+// it is unit-tested (test/window-placement.test.js); main.js supplies the saved
+// bounds, the display's work area, the clip windows already showing and the
+// popup's bounds when the popup stays up. Owner 2026-10-13: "spawns under BC
+// itself" / "multi spawning they dont stack, it jsut all sits on top".
+// - A clip window already open at the spot pushes the new one a cascade step on,
+//   wrapping inside the work area, like the OS cascades documents.
+// - With the popup up (keepPopup opens) the window goes beside the popup, never
+//   under it: the popup is always on top. It fans out away from the popup.
+
+const CASCADE_STEP = 28;
+const POPUP_GAP = 8;
+function rectsOverlap(a, b) {
+  return a.x < b.x + b.width && b.x < a.x + a.width && a.y < b.y + b.height && b.y < a.y + a.height;
+}
+function clampInto(rect, area) {
+  return {
+    ...rect,
+    x: Math.max(area.x, Math.min(rect.x, area.x + area.width - rect.width)),
+    y: Math.max(area.y, Math.min(rect.y, area.y + area.height - rect.height)),
+  };
+}
+// Pure placement (unit-tested): base = the saved bounds (x/y may be missing),
+// area = the work area to stay in, taken = top-left corners of the clip windows
+// already showing, avoid = the open popup's bounds when it stays up.
+function placeClipWindowBounds(base, { area, taken = [], avoid = null } = {}) {
+  const width = Math.min(base.width, area.width);
+  const height = Math.min(base.height, area.height);
+  let start = Number.isFinite(base.x) && Number.isFinite(base.y)
+    ? clampInto({ x: base.x, y: base.y, width, height }, area)
+    : { x: Math.round(area.x + (area.width - width) / 2), y: Math.round(area.y + (area.height - height) / 2), width, height };
+  // Cascade direction: down and right, unless the window sits left of / above
+  // the popup, where it fans out away from the popup instead.
+  let dx = 1;
+  let dy = 1;
+  if (avoid && rectsOverlap(start, avoid)) {
+    const midY = avoid.y + Math.round((avoid.height - height) / 2);
+    const midX = avoid.x + Math.round((avoid.width - width) / 2);
+    const sides = [
+      { x: avoid.x + avoid.width + POPUP_GAP, y: midY, dx: 1, dy: 1 },
+      { x: avoid.x - POPUP_GAP - width, y: midY, dx: -1, dy: 1 },
+      { x: midX, y: avoid.y + avoid.height + POPUP_GAP, dx: 1, dy: 1 },
+      { x: midX, y: avoid.y - POPUP_GAP - height, dx: 1, dy: -1 },
+    ].map((s) => ({ ...s, rect: clampInto({ x: s.x, y: s.y, width, height }, area) }));
+    const overlapArea = (r) => Math.max(0, Math.min(r.x + width, avoid.x + avoid.width) - Math.max(r.x, avoid.x))
+      * Math.max(0, Math.min(r.y + height, avoid.y + avoid.height) - Math.max(r.y, avoid.y));
+    const best = sides.find((s) => !rectsOverlap(s.rect, avoid))
+      || sides.slice().sort((a, b) => overlapArea(a.rect) - overlapArea(b.rect))[0];
+    start = best.rect;
+    dx = best.dx;
+    dy = best.dy;
+  }
+  // The cascade walks diagonals (one step down and along per window); a
+  // diagonal that leaves the work area starts the next one a step further
+  // along at the area's top (or bottom, when fanning upward), like the OS
+  // cascade. The first spot no showing clip window holds wins.
+  const near = (p, q) => Math.abs(p.x - q.x) < 8 && Math.abs(p.y - q.y) < 8;
+  const fits = (p) => p.x >= area.x && p.y >= area.y && p.x + width <= area.x + area.width && p.y + height <= area.y + area.height;
+  // A wrapped spot never lands under the popup (unless no side had room for
+  // the window, when the least-covered spot is the best there is).
+  const besideFits = !(avoid && rectsOverlap(start, avoid));
+  const underPopup = (r) => !!avoid && besideFits && rectsOverlap(r, avoid);
+  const spanX = Math.max(1, area.width - width + 1);
+  const wrapX = (x) => area.x + ((((x - area.x) % spanX) + spanX) % spanX);
+  for (let column = 0; column < 64; column += 1) {
+    const x0 = wrapX(start.x + dx * column * CASCADE_STEP);
+    const y0 = column === 0 ? start.y : dy > 0 ? area.y : area.y + area.height - height;
+    for (let step = 0; step < 64; step += 1) {
+      const p = { x: x0 + dx * step * CASCADE_STEP, y: y0 + dy * step * CASCADE_STEP };
+      if (!fits(p)) break;
+      if (underPopup({ ...p, width, height })) continue;
+      if (!taken.some((t) => near(t, p))) return { x: p.x, y: p.y, width, height };
+    }
+  }
+  return { x: start.x, y: start.y, width, height };
+}
+
+module.exports = { placeClipWindowBounds, rectsOverlap, clampInto, CASCADE_STEP, POPUP_GAP };

package/main.js

@@ -14,6 +14,7 @@ const macPaste = require('./lib/macos-paste');
 const winClipboard = require('./lib/windows-clipboard');
 const { createQuickPaster } = require('./lib/quick-paste');
 const { createClipboardFollower } = require('./lib/clipboard-follow');
+const { placeClipWindowBounds } = require('./lib/window-placement');
 const { dragFileNames } = require('./lib/drag-files');
 const { createHistoryFeed } = require('./lib/history-feed');
 // Shared UI core (pure UMD, no DOM at load): main reuses its chord tests.
@@ -41,6 +42,7 @@ const syncJournal = require('./lib/sync-journal');
 const fsProbe = require('./lib/fs-probe');
 const tailscale = require('./lib/tailscale');
 const mcpCore = require('./lib/mcp-core');
+const mcpSearchThread = require('./lib/mcp-search-thread');
 const mcpPaths = require('./lib/mcp-paths');
 const mcpInstallers = require('./lib/mcp-installers');
 const { Worker } = require('worker_threads');
@@ -156,6 +158,9 @@ const HISTORY_BACKUP_MAX_BYTES = 1024 * 1024 * 1024;
 const HISTORY_BACKUP_MAX_MANIFESTS = 2000;
 const HISTORY_BACKUP_MIN_INTERVAL_MS = 60 * 1000;
 const IMAGE_ORPHAN_RECOVERY_WINDOW_MS = 30 * 60 * 1000;
+// Once Chromium calls the popup renderer unresponsive, how long it may stay so
+// before it is ended and reloaded (createPopup's 'unresponsive' backstop).
+const POPUP_HANG_RELOAD_MS = 5000;
 const IMAGE_ORPHAN_RECOVERY_MAX_FILES = 20;
 const SYNC_REMOTE_WRITE_TIMEOUT_MS = 8000;
 const SYNC_PROVIDER_READ_TIMEOUT_MS = 12000;
@@ -4389,12 +4394,30 @@ function createPopup() {
       onFailed(null, null, error && error.message);
     }
   });
+  // Backstop: a popup renderer that STAYS hung (a page script that never
+  // returns, as a /regex/ on the page's thread did, 12 Oct 2026) used to sit
+  // dead until someone killed it. It is ended now and the render-process-gone
+  // recovery above reloads it; the popup holds no unsaved work. Every firing is
+  // a bug report (popup.renderer_hung_reload).
+  let popupHangTimer = null;
   win.webContents.on('unresponsive', () => {
     diagnostics.record('popup.renderer_unresponsive_native', {
       visible: isPopupOpen(),
     }, { forceFile: true });
+    if (popupHangTimer) return;
+    popupHangTimer = setTimeout(() => {
+      popupHangTimer = null;
+      if (!win || win.isDestroyed() || app.isQuitting) return;
+      diagnostics.record('popup.renderer_hung_reload', { visible: isPopupOpen(), after_ms: POPUP_HANG_RELOAD_MS }, { forceFile: true });
+      try {
+        win.webContents.forcefullyCrashRenderer();
+      } catch (error) {
+        diagnostics.record('popup.renderer_hung_reload_failed', { error: error && error.message }, { forceFile: true });
+      }
+    }, POPUP_HANG_RELOAD_MS);
   });
   win.webContents.on('responsive', () => {
+    if (popupHangTimer) { clearTimeout(popupHangTimer); popupHangTimer = null; }
     diagnostics.record('popup.renderer_responsive_native', {
       visible: isPopupOpen(),
     }, { forceFile: true });
@@ -5337,6 +5360,7 @@ function windowBoundsFromSettings(key, defaults) {
   return out;
 }
 const saveBoundsTimers = new Map();
+const placedBounds = new WeakMap(); // clip window -> the bounds it was opened at
 function scheduleWindowBoundsSave(childWin, key) {
   if (!childWin || childWin.isDestroyed()) return;
   const prior = saveBoundsTimers.get(key);
@@ -5346,6 +5370,14 @@ function scheduleWindowBoundsSave(childWin, key) {
     if (!childWin || childWin.isDestroyed()) return;
     const maximized = childWin.isMaximized() || childWin.isFullScreen();
     const { x, y, width, height } = maximized ? childWin.getNormalBounds() : childWin.getBounds();
+    // A window still where it was placed (a cascade step, beside the popup)
+    // never becomes the saved spot: only a move or resize by the user does, so
+    // untouched windows do not drift the next one's start.
+    const placed = placedBounds.get(childWin);
+    const savedNow = settings[key] || {};
+    if (placed && placed.x === x && placed.y === y && placed.width === width && placed.height === height
+      && maximized === (savedNow.maximized === true)) return;
+    placedBounds.delete(childWin);
     settings[key] = { x, y, width: Math.max(360, width), height: Math.max(240, height), maximized };
     saveSettingsFile({ localOnly: true });
   }, 300);
@@ -5367,15 +5399,45 @@ function restoreWindowMaximized(childWin, key, options) {
   if (!saved || saved.maximized !== true || (options && options.keepPopup)) return;
   try { childWin.maximize(); } catch {}
 }
-function editorBoundsFromSettings() { return windowBoundsFromSettings('editor_bounds', { width: 560, height: 520 }); }
+// Every clip window (editor, viewer, unify, conflict) opens at its kind's saved
+// bounds, then cascades past the clip windows already showing and, when the
+// popup stays up (keepPopup), goes beside the popup instead of under it
+// (lib/window-placement.js). The work area is the popup's display, else the
+// saved spot's, else the cursor's.
+const clipWindows = new Set();
+function trackClipWindow(childWin) {
+  clipWindows.add(childWin);
+  try { placedBounds.set(childWin, childWin.getBounds()); } catch {}
+  childWin.once('closed', () => clipWindows.delete(childWin));
+}
+function clipWindowBoundsFromSettings(key, defaults, options) {
+  const base = windowBoundsFromSettings(key, defaults);
+  const keepPopup = !!(options && options.keepPopup) && isPopupOpen();
+  const avoid = keepPopup && win && !win.isDestroyed() ? win.getBounds() : null;
+  const anchor = avoid
+    ? { x: avoid.x + Math.round(avoid.width / 2), y: avoid.y + Math.round(avoid.height / 2) }
+    : Number.isFinite(base.x) ? { x: base.x + Math.round(base.width / 2), y: base.y + Math.round(base.height / 2) }
+      : screen.getCursorScreenPoint();
+  const area = screen.getDisplayNearestPoint(anchor).workArea;
+  const taken = [];
+  for (const other of clipWindows) {
+    try {
+      if (other.isDestroyed() || !other.isVisible() || other.isMinimized() || other.isMaximized()) continue;
+      const b = other.getBounds();
+      taken.push({ x: b.x, y: b.y });
+    } catch {}
+  }
+  return placeClipWindowBounds(base, { area, taken, avoid });
+}
+function editorBoundsFromSettings(options) { return clipWindowBoundsFromSettings('editor_bounds', { width: 560, height: 520 }, options); }
 // The merge windows (unify, conflict) keep their own size: two or three panes
 // with a head each need width a plain editor does not (and a widened unify
 // must not leave the next editor wide).
-function mergeBoundsFromSettings() { return windowBoundsFromSettings('merge_bounds', { width: 780, height: 560 }); }
+function mergeBoundsFromSettings(options) { return clipWindowBoundsFromSettings('merge_bounds', { width: 780, height: 560 }, options); }
 
 function createEditorWindow(session, presentOptions = {}) {
   const editorWin = new BrowserWindow({
-    ...editorBoundsFromSettings(),
+    ...editorBoundsFromSettings(presentOptions),
     minWidth: 360,
     minHeight: 240,
     resizable: true,
@@ -5392,6 +5454,7 @@ function createEditorWindow(session, presentOptions = {}) {
     },
   });
   noteSecondarySurface(editorWin);
+  trackClipWindow(editorWin);
   session.win = editorWin;
   editorWin.loadFile(path.join(SCRIPT_DIR, 'editor.html'));
   // Show + focus the editor, then dismiss the popup so it doesn't linger behind
@@ -5455,7 +5518,7 @@ function sourceGroupsForNewNote(options) {
 // Bring an editor/viewer window on screen. Default = a deliberate hand-off: the
 // window takes focus and the popup is dismissed (a popup lingering behind the
 // editor felt "sticky" - you had to click back to it + Escape). With
-// options.keepPopup (mouse-driven opens: middle-click, alt+click, the row menu)
+// options.keepPopup (the "open several" gestures: middle-click, right-click on the open button, alt+click)
 // the window is shown WITHOUT activating and the popup stays where it is, so
 // several results can be opened one after another; the popup still hides on
 // its own blur the moment the user clicks into one of the windows.
@@ -5626,7 +5689,7 @@ function openImageViewer(id, options = {}) {
     return;
   }
   const viewerWin = new BrowserWindow({
-    ...windowBoundsFromSettings('viewer_bounds', { width: 720, height: 560 }),
+    ...clipWindowBoundsFromSettings('viewer_bounds', { width: 720, height: 560 }, options),
     minWidth: 360,
     minHeight: 240,
     resizable: true,
@@ -5643,6 +5706,7 @@ function openImageViewer(id, options = {}) {
     },
   });
   noteSecondarySurface(viewerWin);
+  trackClipWindow(viewerWin);
   viewerWindows.set(key, viewerWin);
   viewerWin.loadFile(path.join(SCRIPT_DIR, 'viewer.html'));
   viewerWin.once('ready-to-show', () => {
@@ -5799,6 +5863,7 @@ function openConflictWindow(conflictId) {
     },
   });
   noteSecondarySurface(conflictWin);
+  trackClipWindow(conflictWin);
   conflictWindows.set(id, conflictWin);
   const sessionId = `conflict:${id}`;
   conflictWin.loadFile(path.join(SCRIPT_DIR, 'editor.html'));
@@ -5916,6 +5981,7 @@ function openUnifyWindow(session) {
     },
   });
   noteSecondarySurface(unifyWin);
+  trackClipWindow(unifyWin);
   session.win = unifyWin;
   unifyWin.loadFile(path.join(SCRIPT_DIR, 'editor.html'));
   unifyWin.once('ready-to-show', () => {
@@ -6717,10 +6783,10 @@ async function mcpHandleRequest(reqPath, payload, ctx = {}) {
   // Re-check after the (possibly long) approval await: if AI access was toggled
   // off while the modal was open, refuse before performing the action.
   if (!settings.ai_access_enabled) throw new Error('ai_access_disabled');
-  return mcpExecute(tool, args);
+  return mcpExecute(tool, args, ctx);
 }
 
-function mcpExecute(tool, args) {
+function mcpExecute(tool, args, ctx = {}) {
   switch (tool) {
     case 'read_clip': {
       const item = findHistoryItem(args.id);
@@ -6731,7 +6797,8 @@ function mcpExecute(tool, args) {
       return { ...mcpCore.fullTextResult(item, sharedSet), viaApproval: true };
     }
     case 'search_all':
-      return mcpCore.searchClips(history, settings, { query: args.query, regex: !!args.regex, scope: 'all', limit: args.limit || mcpCore.DEFAULT_LIST_LIMIT });
+      // A /regex/ runs on a worker thread: it must never hang this process.
+      return mcpSearchThread.searchClipsOffThread(history, settings, { query: args.query, regex: !!args.regex, scope: 'all', limit: args.limit || mcpCore.DEFAULT_LIST_LIMIT }, { signal: ctx.signal });
     case 'image_path': {
       const item = findHistoryItem(args.id);
       if (!item || item.type !== 'image') throw new Error('not_an_image');

package/mcp/boardclip-mcp.js

@@ -26,6 +26,7 @@ const { StdioServerTransport } = require('@modelcontextprotocol/sdk/server/stdio
 const model = require('../lib/clipboard-model');
 const textBlobStore = require('../lib/text-blob-store');
 const mcpCore = require('../lib/mcp-core');
+const { searchClipsOffThread } = require('../lib/mcp-search-thread');
 const mcpPaths = require('../lib/mcp-paths');
 const controlClient = require('../lib/control-client');
 
@@ -136,14 +137,18 @@ server.registerTool('search_clips', {
     include_unshared: z.boolean().optional(),
     limit: z.number().int().min(1).max(200).optional(),
   },
-}, async ({ query, regex, include_unshared, limit }) => {
+}, async ({ query, regex, include_unshared, limit }, extra) => {
   if (include_unshared) {
     return runForward('search_all', { query, regex: !!regex, limit: limit || mcpCore.DEFAULT_LIST_LIMIT });
   }
-  const res = mcpCore.searchClips(readHistory(), readSettings(), {
-    query, regex: !!regex, limit: limit || mcpCore.DEFAULT_LIST_LIMIT,
-  });
-  return jsonResult(res);
+  try {
+    const res = await searchClipsOffThread(readHistory(), readSettings(), {
+      query, regex: !!regex, limit: limit || mcpCore.DEFAULT_LIST_LIMIT,
+    }, { signal: extra && extra.signal });
+    return jsonResult(res);
+  } catch (error) {
+    return errorResult(error && error.message ? error.message : String(error));
+  }
 });
 
 server.registerTool('get_clip', {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tobq/boardclip",
   "productName": "BoardClip",
-  "version": "2.1.110",
+  "version": "2.1.112",
   "description": "Cross-platform clipboard history tray app with numpad quick-paste and native cloud sync",
   "keywords": [
     "clipboard",

package/site/index.html

@@ -493,28 +493,54 @@
     // Rows render through the SAME shared list as the app (Core.createClipList,
     // created below): it keeps your place across every rebuild.
     let visibleRows = [];
+    // As in the app: a query with a /regex/ is searched on the shared worker
+    // (Core.createSearchWorker); the rows on screen keep the query they were
+    // found with (shownQuery) and where each regex match first sits (regexFirst).
+    let shownQuery = "";
+    let regexFirst = null;
+    const demoSearchWorker = Core.createSearchWorker({
+      onBusy: (busy) => { clipList.classList.toggle("searching", busy); clipList.setAttribute("aria-busy", busy ? "true" : "false"); if (busy) clipCount.textContent = "Searching..."; },
+    });
     function renderClipRow(clip) {
+      const id = Core.itemId(clip);
       return Core.renderClipItem(clip, {
         imageSrc: item => item.imageSrc,
-        query: state.query,
+        query: shownQuery,
+        ...(regexFirst ? { matchIndex: regexFirst.has(id) ? regexFirst.get(id) : -1 } : {}),
         selection: controller ? controller.selection() : null,
         actionsHtml: Core.renderClipActions(clip),
       });
     }
     function renderClips() {
-      const visible = Core.filterItems(clips, state);
-      clipCount.textContent = Core.itemCountLabel(clips.length, visible.length, state);
       updateClearControls();
       updateDemoSortButton(); // defined below; renderClips first runs at the bottom of this script
       renderFilterChips();
       renderDemoSettings();
+      const q = state.query;
+      if (Core.search.hasRegexTerm(Core.search.parseQuery(q))) {
+        const list = clips;
+        demoSearchWorker.search({ docs: demoSearchDocs(), query: q, sortMode: state.sortMode, now: Date.now() }, (r) => {
+          if (list !== clips) { renderClips(); return; } // the clips moved on: search again
+          regexFirst = new Map(r.indexes.map((i, k) => [Core.itemId(list[i]), r.first[k]]));
+          showDemoRows(q, r.indexes.map((i) => list[i]), r.relax);
+        });
+        return;
+      }
+      demoSearchWorker.cancel();
+      regexFirst = null;
+      showDemoRows(q, Core.filterItems(clips, state));
+    }
+    // relax: the worker's empty-result nudge (a regex query), else worked out here.
+    function showDemoRows(q, visible, relax) {
+      shownQuery = q;
+      clipCount.textContent = Core.itemCountLabel(clips.length, visible.length, { query: q });
       visibleRows = visible;
       demoList.update({
         ids: visible.map((clip) => Core.itemId(clip)),
         tsAt: (i) => Number(visible[i] && visible[i].ts) || 0,
-        mode: Core.search.rankMode(Core.search.parseQuery(state.query), state.sortMode),
-        queryKey: state.query,
-        emptyHtml: () => Core.renderEmptyState({ total: clips.length, query: state.query, groups: labels, nudgeHtml: Core.renderRelaxNudge(Core.search.bestRelaxation(demoSearchDocs(), state.query, { cache: demoRelaxCache })) }),
+        mode: Core.search.rankMode(Core.search.parseQuery(q), state.sortMode),
+        queryKey: q,
+        emptyHtml: () => Core.renderEmptyState({ total: clips.length, query: q, groups: labels, nudgeHtml: Core.renderRelaxNudge(relax !== undefined ? relax : Core.search.bestRelaxation(demoSearchDocs(), q, { cache: demoRelaxCache })) }),
       });
     }
 

package/site/shared/clip-search.js

@@ -1224,6 +1224,39 @@
     return scored.map((s) => s.i);
   }
 
+  // Does the query hold a /regex/ anywhere (a top-level term, an excluded one,
+  // or a leaf of a custom expression)? A regex is the one term whose cost has
+  // no bound: y.*t.*b.*\?.*t= backtracked for minutes on a 20,000-char line
+  // and froze the popup for good (12 Oct 2026), so such a query is searched
+  // off the page's thread (searchJob in Core.createSearchWorker's worker).
+  function hasRegexTerm(parsed) {
+    const p = parsed || {};
+    const inNode = (n) => !!n && (n.type === 'leaf' ? !!(n.leaf && n.leaf.regex) : (n.children || []).some(inNode));
+    return (p.content || []).some((c) => c.regex) || (p.terms || []).some((c) => c.regex) || (p.compound || []).some(inNode);
+  }
+  // One whole search, as the worker runs it: the ranked ORIGINAL indexes, where
+  // each match first sits in its body (the row's preview window; -1 = none),
+  // and the empty-result nudge. It also marks every match's title and body
+  // once (termSpans), so a pattern that takes too long on a matched clip
+  // stalls HERE, off the page's thread; the row highlight then only marks a
+  // short window of those same texts. req: { query, sortMode, now }.
+  function searchJob(docs, hays, req) {
+    const r = req || {};
+    const parsed = parseQuery(r.query || '');
+    const now = r.now || Date.now();
+    const list = docs || [];
+    const indexes = filterRankIndexes(null, parsed, { docs: list, searchTextLower: hays || null, now, sortMode: r.sortMode || null });
+    const first = new Array(indexes.length);
+    for (let k = 0; k < indexes.length; k += 1) {
+      const doc = list[indexes[k]];
+      first[k] = doc.type === 'image' ? -1 : firstMatchIndex(parsed, doc.body);
+      termSpans(parsed, doc.title, 'title', 100);
+      if (doc.type !== 'image') termSpans(parsed, doc.body, 'body', 100);
+    }
+    const relax = indexes.length ? null : bestRelaxation(list, parsed, { now, searchTextLower: hays || null });
+    return { indexes, first, relax };
+  }
+
   // ── IntelliJ camel-hump fuzzy matcher (ported from Forge src/renderer/lib/fuzzy.ts,
   //    React stripped). `sdi` -> "Sync Data-loss Incident". Returns {score, positions}|null. ──
   const F_BONUS_WORD_START = 24, F_BONUS_STRING_START = 12, F_BONUS_CONSECUTIVE = 16, F_BONUS_CASE = 2, F_PENALTY_GAP = -2, F_PENALTY_LEAD = -1, F_LEAD_CAP = -6;
@@ -2315,6 +2348,7 @@
     tokenizeQuery, quoteToken, parseQuery, scanQuery, serializeQuery, applyFacet, stripFacet, clearFacet, facetState, facetTokenState,
     anyFilterActive, hasSearchTerms, resolveTimeMs,
     matchDoc, relevanceScore, recencyScore, decayWeight, groupWeights, compareGroupUse, rankMode, filterRankIndexes, bodyIndexOf,
+    hasRegexTerm, searchJob,
     compileTerm, escapeRegExp, termSpans, firstMatchIndex,
     regexTypingEdit, regexBackspaceEdit, toggleRegexAt, legacyRegexQuery, dimConnective, setDimConnective, normalizeJoins,
     promptOptionState, promptOptionLabel, FIELD_EXAMPLE,

package/site/shared/clipboard-popup.css

@@ -316,7 +316,13 @@
               display: inline-flex; align-items: center; gap: var(--sp-1); vertical-align: top; font-family: inherit; }
 .filter-tag.icon-filter { min-width: var(--ctl-sm); height: var(--ctl-sm); justify-content: center; padding: 0 var(--sp-2); }
 .filter-tag:hover { background: var(--hover); color: var(--text); }
-.filter-tag.group-tag, .filter-tag.group-tag:hover { color: var(--accent-text); }
+/* A group name reads in the accent text shade wherever it shows: its chip, a
+   clip's meta line and window bar, every group picker and chip dropdown row,
+   Settings > Groups (owner 2026-10-09 on the chips: "too hard to see before
+   selected"; 2026-10-13: "blue tags should be consistent everywhere"). Hover
+   keeps the colour (the wash says hover); a picked chip's fill and an excluded
+   name's strike override it. */
+.filter-tag.group-tag, .filter-tag.group-tag:hover, .meta-tags > .meta-tag, .bc-menu-item.group-name > .bc-menu-label, .group-row .si-name { color: var(--accent-text); }
 .filter-tag.active, .filter-tag.active:hover { background: var(--accent); color: var(--active-fg); --icon-fill: 1; }
 .filter-tag.active:hover { background: var(--accent-hover); }
 .filter-tag.excluded { color: var(--text-dim); text-decoration: line-through; text-decoration-thickness: 1px; opacity: .6; }
@@ -352,6 +358,9 @@
    .bc-scroll-fade, Core.createClipList); scroll-padding keeps the keyboard
    cursor out of the fades when it is scrolled into view. */
 .list { flex: 1; overflow-y: auto; padding: 0 0 var(--sp-4); min-height: 0; scroll-padding-block: 36px; }
+/* A /regex/ search still running on the search worker: the rows on screen are the last answer, not this one. */
+.list { transition: opacity var(--dur) var(--ease); }
+.list.searching { opacity: .55; }
 .item { padding: var(--sp-4) var(--gutter); cursor: pointer; transition: background-color var(--dur) var(--ease); position: relative; border-bottom: 1px solid var(--line-faint); color: inherit; }
 /* Row states: hover = the --hover overlay; the keyboard cursor (the row Enter
    pastes) = --accent-bg; a candidate duplicate of the hovered or cursor row
@@ -411,7 +420,7 @@
 /* A group chip's dropdown holds menu rows (renderTagTreeMenuNode, depth > 0):
    an excluded group is struck through like its chip, a greyed one dims in the
    chips' two tiers, and a parent row stays lit while its submenu is out. */
-.bc-menu-item.excluded > .bc-menu-label { text-decoration: line-through; }
+.bc-menu-item.excluded > .bc-menu-label { color: var(--text-dim); text-decoration: line-through; }
 .bc-menu-item.is-disabled { opacity: .4; cursor: default; }
 .bc-menu-item.is-disabled.dis-structural { opacity: .25; }
 .bc-menu-item.is-disabled:hover { background: none; }
@@ -491,7 +500,8 @@
    at the last name and the + follows it instead of the box's far edge. */
 .item:hover .meta-tag.meta-cut, .item:focus-within .meta-tag.meta-cut, .item.actions-held .meta-tag.meta-cut { display: none; }
 .meta-tag { display: block; flex: 0 1 auto; min-width: 0; max-width: 140px; overflow: hidden; text-overflow: ellipsis; }
-.meta-np:hover, .meta-tag:hover, .meta-ghost:hover { color: var(--text); background: var(--hover); }
+.meta-np:hover, .meta-ghost:hover { color: var(--text); }
+.meta-np:hover, .meta-tag:hover, .meta-ghost:hover { background: var(--hover); }
 .meta-ghost { display: inline-flex; align-items: center; justify-content: center; width: var(--meta-h); padding: 0; }
 .meta-ghost .mi { font-size: var(--icon-sm); }
 .meta > .meta-reveal, .bc-tag-strip > .meta-reveal { margin-left: calc(-1 * var(--sp-3)); --reveal-gap: var(--sp-3); }

package/site/shared/clipboard-ui-core.js

@@ -220,7 +220,7 @@
         check: state === 'include',
         label: node.label || group,
         hint: disabled ? '' : String(count),
-        cls: `group-filter-row${state === 'exclude' ? ' excluded' : ''}${disabled ? ` is-disabled${v.kind === 'structural' ? ' dis-structural' : ''}` : ''}`,
+        cls: `group-filter-row group-name${state === 'exclude' ? ' excluded' : ''}${disabled ? ` is-disabled${v.kind === 'structural' ? ' dis-structural' : ''}` : ''}`,
         attrs: { 'data-group': group, title, 'aria-disabled': disabled ? 'true' : null },
       };
       return hasChildren
@@ -290,6 +290,176 @@
     const list = items || [];
     return filterItemIndexes(list, state).map((i) => list[i]);
   }
+  // A search that holds a /regex/ (and the find bar's regex) runs on a worker
+  // thread (search-worker.js beside this file): a pattern can backtrack for
+  // minutes on one long line (y.*t.*b.*\?.*t= froze the popup for good on a
+  // 20,000-char line, 12 Oct 2026), and nothing can interrupt a RegExp on the
+  // page's thread. The latest request wins. A worker still busy GRACE ms after
+  // its result stopped being wanted is ended (it may be stuck for hours) and
+  // the next request starts a fresh one. The worker holds its own copy of the
+  // docs, synced by doc OBJECT, so a new history revision sends only new or
+  // changed clips. opts: { url, graceMs, onBusy(busy) (a wanted result has been
+  // outstanding for busyMs), busyMs, onError(message) (the worker failed; the job
+  // then runs on the page, as before) }.
+  const SEARCH_WORKER_URL = (() => {
+    try { return new URL('search-worker.js', document.currentScript.src).href; } catch { return ''; }
+  })();
+  function createSearchWorker(opts) {
+    const o = opts || {};
+    const url = o.url || SEARCH_WORKER_URL;
+    const graceMs = o.graceMs != null ? o.graceMs : 250;
+    const busyMs = o.busyMs != null ? o.busyMs : 150;
+    const now = () => (typeof performance !== 'undefined' ? performance.now() : Date.now());
+    const keys = new WeakMap();
+    let nextKey = 1;
+    let worker = null;
+    let sent = new WeakSet();
+    let syncedDocs = null;
+    let running = null; // { job, startedAt }
+    let queued = null;
+    let wanted = 0;
+    let seq = 0;
+    let killTimer = null;
+    let busyTimer = null;
+    let busy = false;
+    let idleWaiters = [];
+    const setBusy = (next) => {
+      if (busy === next) return;
+      busy = next;
+      if (typeof o.onBusy === 'function') o.onBusy(next);
+    };
+    const settleIdle = () => {
+      if (wanted) return;
+      clearTimeout(busyTimer);
+      setBusy(false);
+      const waiters = idleWaiters;
+      idleWaiters = [];
+      waiters.forEach((fn) => fn());
+    };
+    function kill() {
+      clearTimeout(killTimer);
+      killTimer = null;
+      if (worker) worker.terminate();
+      worker = null;
+      running = null;
+      sent = new WeakSet();
+      syncedDocs = null;
+    }
+    function keyOf(doc) {
+      let k = keys.get(doc);
+      if (!k) { k = nextKey; nextKey += 1; keys.set(doc, k); }
+      return k;
+    }
+    function sync(docs, hays) {
+      if (docs === syncedDocs) return;
+      const list = docs || [];
+      const order = new Array(list.length);
+      const add = [];
+      for (let i = 0; i < list.length; i += 1) {
+        const doc = list[i];
+        if (!doc) { order[i] = 0; continue; }
+        const k = keyOf(doc);
+        order[i] = k;
+        if (!sent.has(doc)) { sent.add(doc); add.push([k, doc, hays ? hays[i] : null]); }
+      }
+      worker.postMessage({ type: 'sync', order, add });
+      syncedDocs = docs;
+    }
+    // No worker (it failed to load): the job runs here, as before.
+    function runHere(job) {
+      const m = job.msg;
+      if (m.type === 'search') return { type: 'search', id: m.id, ...Search.searchJob(job.docs, job.hays, m) };
+      const term = Search.compileTerm(m.query, { regex: !!m.regex, caseSensitive: !!m.caseSensitive });
+      return { type: 'find', id: m.id, matches: term.all(String(m.text || '')), valid: term.valid, error: term.error };
+    }
+    function deliver(job, result) {
+      if (job.id !== wanted) return;
+      wanted = 0;
+      try { job.cb(result); } finally { settleIdle(); }
+    }
+    function start(job) {
+      if (!worker && url && typeof Worker === 'function') {
+        try {
+          worker = new Worker(url);
+          worker.onmessage = onMessage;
+          worker.onerror = onError;
+        } catch { worker = null; }
+      }
+      if (!worker) { deliver(job, runHere(job)); return; }
+      if (job.msg.type === 'search') sync(job.docs, job.hays);
+      running = { job, startedAt: now() };
+      worker.postMessage(job.msg);
+    }
+    function next() {
+      const job = queued;
+      queued = null;
+      if (job) start(job);
+    }
+    function onMessage(event) {
+      const m = event.data || {};
+      if (!running || m.id !== running.job.id) return;
+      const job = running.job;
+      running = null;
+      clearTimeout(killTimer);
+      killTimer = null;
+      deliver(job, m);
+      next();
+    }
+    // The worker failed (it could not load, or ran out of memory): it is
+    // ended, and the job it held runs here so its answer still arrives.
+    function onError(event) {
+      if (event && typeof event.preventDefault === 'function') event.preventDefault();
+      if (typeof o.onError === 'function') o.onError(String(event && event.message || 'search worker failed'));
+      const job = running && running.job;
+      kill();
+      if (job) deliver(job, runHere(job));
+      next();
+    }
+    // The running job's result is not wanted any more: end its worker once it
+    // has had graceMs (a quick job just finishes and the queue moves on).
+    function armKill() {
+      if (!running || running.job.id === wanted) return;
+      clearTimeout(killTimer);
+      killTimer = setTimeout(() => {
+        killTimer = null;
+        if (!running || running.job.id === wanted) return;
+        kill();
+        next();
+      }, Math.max(0, graceMs - (now() - running.startedAt)));
+    }
+    function request(type, msg, cb, docs, hays) {
+      seq += 1;
+      const job = { id: seq, msg: { ...msg, type, id: seq }, cb, docs, hays };
+      wanted = job.id;
+      clearTimeout(busyTimer);
+      busyTimer = setTimeout(() => { if (wanted) setBusy(true); }, busyMs);
+      if (running) { queued = job; armKill(); } else start(job);
+      return job.id;
+    }
+    return {
+      // req: { docs, hays (the lowercased haystacks, or null), query, sortMode, now }
+      search(req, cb) {
+        const r = req || {};
+        return request('search', { query: r.query || '', sortMode: r.sortMode || null, now: r.now || Date.now() }, cb, r.docs || [], r.hays || null);
+      },
+      // req: { text, query, regex, caseSensitive }
+      find(req, cb) {
+        const r = req || {};
+        return request('find', { text: String(r.text || ''), query: String(r.query || ''), regex: !!r.regex, caseSensitive: !!r.caseSensitive }, cb);
+      },
+      // The outstanding result is not wanted any more.
+      cancel() {
+        wanted = 0;
+        queued = null;
+        armKill();
+        settleIdle();
+      },
+      busy: () => busy,
+      // Resolves once no wanted result is outstanding (QA drivers await it).
+      whenIdle: () => (wanted ? new Promise((resolve) => idleWaiters.push(resolve)) : Promise.resolve()),
+      dispose() { wanted = 0; queued = null; kill(); settleIdle(); },
+    };
+  }
   function itemCountLabel(total, visible, state) {
     const count = Number(total) || 0;
     const shown = Number(visible) || 0;
@@ -996,7 +1166,7 @@
       const group = normalizeTagName(node && node.name);
       if (!group) return '';
       const [icon, checked] = MEMBERSHIP_GLYPH[state(group)] || MEMBERSHIP_GLYPH.none;
-      const row = { icon, check: true, label: node.label || group, role: 'menuitemcheckbox', attrs: { 'data-action': action, 'data-group': group, 'aria-checked': checked, title: group } };
+      const row = { icon, check: true, label: node.label || group, cls: 'group-name', role: 'menuitemcheckbox', attrs: { 'data-action': action, 'data-group': group, 'aria-checked': checked, title: group } };
       return node.children && node.children.length
         ? submenuNodeHtml(row, renderGroupChecklist(node.children, state, action))
         : menuRowHtml(row);
@@ -4816,18 +4986,19 @@
         refresh();
         return true;
       }
-      // The row's primary open button is the "normal" open: a hand-off (the
-      // popup closes, like before). Only the detached "..."/right-click MENU's
-      // Open in editor / Open image keeps the popup, alongside middle/alt-click.
-      const fromMenu = !!t.closest('.bc-menu-item');
+      // A plain click on any Open (the row's own open button or the clip menu's
+      // Open in editor / Open image) is a hand-off: the window takes the focus
+      // and the popup closes. Only the "open several" gestures keep the popup:
+      // middle-click, right-click on the open button, Alt+click (owner
+      // 2026-10-13: "when i click on note, bc doesnt close... inconsisntent").
       const openImg = t.closest('[data-action="open-img"]');
-      if (openImg) { event.stopPropagation(); await a.openImage(a.itemById(openImg.dataset.id), fromMenu ? KEEP_POPUP : undefined); return true; }
+      if (openImg) { event.stopPropagation(); await a.openImage(a.itemById(openImg.dataset.id)); return true; }
       const openImgExt = t.closest('[data-action="open-img-ext"]');
       if (openImgExt) { event.stopPropagation(); if (a.openImageExternal) await a.openImageExternal(a.itemById(openImgExt.dataset.id)); return true; }
       const saveImg = t.closest('[data-action="save-img"]');
       if (saveImg) { event.stopPropagation(); toast(await a.saveImage(a.itemById(saveImg.dataset.id))); return true; }
       const edit = t.closest('[data-action="edit"]');
-      if (edit) { event.stopPropagation(); await a.editClip(edit.dataset.id, edit.closest('.item'), fromMenu ? KEEP_POPUP : undefined); return true; }
+      if (edit) { event.stopPropagation(); await a.editClip(edit.dataset.id, edit.closest('.item')); return true; }
       const rename = t.closest('[data-action="rename"]');
       if (rename) { event.stopPropagation(); await renameClip(rename.dataset.id); return true; }
       const revert = t.closest('[data-action="revert"]');
@@ -5784,14 +5955,30 @@
       findHl.innerHTML = `${html}\n`;
       syncHlScroll();
     }
-    function recomputeMatches() {
-      const term = findInput.value ? Search.compileTerm(findInput.value, { regex: findRegex, caseSensitive: findCase }) : null;
-      matches = term ? term.all(area.value) : [];
-      findCount.title = term && !term.valid ? `Not a valid regular expression: ${term.error}.` : '';
-      findBar.classList.toggle('bad-pattern', !!(term && !term.valid));
-      if (!matches.length) { findIdx = -1; findCount.textContent = term && !term.valid ? 'Invalid' : findInput.value ? '0/0' : ''; }
-      else if (findIdx < 0 || findIdx >= matches.length) findIdx = 0;
-      renderFindHighlights();
+    // A regex runs on the search worker (createSearchWorker): one pattern can
+    // backtrack for minutes on a long line, and the page's thread cannot stop
+    // it. A plain word is a linear scan, done here. `after` runs once the
+    // matches are in (at once for a word, on the worker's answer for a regex).
+    let findWorker = null;
+    function recomputeMatches(after) {
+      const query = findInput.value;
+      const term = query ? Search.compileTerm(query, { regex: findRegex, caseSensitive: findCase }) : null;
+      const apply = (list) => {
+        matches = list;
+        findCount.title = term && !term.valid ? `Not a valid regular expression: ${term.error}.` : '';
+        findBar.classList.toggle('bad-pattern', !!(term && !term.valid));
+        if (!matches.length) { findIdx = -1; findCount.textContent = term && !term.valid ? 'Invalid' : query ? '0/0' : ''; }
+        else if (findIdx < 0 || findIdx >= matches.length) findIdx = 0;
+        renderFindHighlights();
+        if (after) after();
+      };
+      if (term && term.valid && term.regex) {
+        if (!findWorker) findWorker = createSearchWorker({ onBusy: (busy) => { if (busy) findCount.textContent = '...'; } });
+        findWorker.find({ text: area.value, query, regex: true, caseSensitive: findCase }, (r) => apply(r.matches || []));
+        return;
+      }
+      if (findWorker) findWorker.cancel();
+      apply(term ? term.all(area.value) : []);
     }
     function step(dir) {
       if (!matches.length) return;
@@ -5805,8 +5992,7 @@
       if (opt.regex != null) findRegex = !!opt.regex;
       updateFindButtons();
       findIdx = -1;
-      recomputeMatches();
-      selectMatch({ preserveFocus: true });
+      recomputeMatches(() => selectMatch({ preserveFocus: true }));
       findInput.focus();
       if (opt.select !== false) findInput.select();
     }
@@ -5817,8 +6003,7 @@
       if (sel && !sel.includes('\n')) findInput.value = sel.slice(0, 120);
       updateFindButtons();
       findIdx = -1;
-      recomputeMatches();
-      selectMatch({ preserveFocus: true });
+      recomputeMatches(() => selectMatch({ preserveFocus: true }));
       findInput.focus();
       findInput.select();
     }
@@ -5843,12 +6028,12 @@
       else if ((e.ctrlKey || e.metaKey) && e.key.toLowerCase() === 'f') { e.preventDefault(); openFind(); }
       else if (e.key === 'Enter') { e.preventDefault(); commit(); area.focus(); } // done naming: back to the text
     });
-    findInput.addEventListener('input', () => { findIdx = -1; recomputeMatches(); selectMatch({ preserveFocus: true }); });
+    findInput.addEventListener('input', () => { findIdx = -1; recomputeMatches(() => selectMatch({ preserveFocus: true })); });
     findInput.addEventListener('keydown', (e) => {
       if (e.key === 'Enter') { e.preventDefault(); step(e.shiftKey ? -1 : 1); }
       else if (e.key === 'Escape') { e.preventDefault(); closeFind(); }
     });
-    const refind = () => { updateFindButtons(); findIdx = -1; recomputeMatches(); selectMatch({ preserveFocus: true }); };
+    const refind = () => { updateFindButtons(); findIdx = -1; recomputeMatches(() => selectMatch({ preserveFocus: true })); };
     // The shared chord toggles: Regex (Alt+R) and match case (Alt+C).
     const findRegexToggle = attachToggle(findRegexBtn, {
       label: 'Regex',
@@ -5923,7 +6108,7 @@
       revert,
       // A host that drops the editor without closing its window (the demo's
       // overlay) lets go of its chords.
-      destroy() { findRegexToggle.destroy(); findCaseToggle.destroy(); },
+      destroy() { findRegexToggle.destroy(); findCaseToggle.destroy(); if (findWorker) findWorker.dispose(); },
     };
   }
   // Shared in-app IMAGE VIEWER — the image twin of createEditor, mounted by the
@@ -6920,6 +7105,7 @@
     createImageZoom,
     createClipController,
     findAllMatches,
+    createSearchWorker,
     editorFindFor,
     flipChildren,
     attachToggle,

package/site/shared/search-worker.js

@@ -0,0 +1,33 @@
+// BoardClip search worker: runs every search that holds a /regex/, and the
+// editor find bar's regex, off the page's thread. Hosted by
+// Core.createSearchWorker (clipboard-ui-core.js), which ends this worker when a
+// pattern runs on after its result is no longer wanted. Messages:
+//   { type: 'sync', order: [key], add: [[key, doc, hay]] }  the docs, by key
+//   { type: 'search', id, query, sortMode, now } -> { type, id, indexes, first, relax }
+//   { type: 'find', id, text, query, regex, caseSensitive } -> { type, id, matches, valid, error }
+importScripts('clip-search.js');
+const Search = self.BoardClipSearch;
+const byKey = new Map();
+let docs = [];
+let hays = null;
+
+self.onmessage = (event) => {
+  const m = event.data || {};
+  if (m.type === 'sync') {
+    for (const [key, doc, hay] of m.add) byKey.set(key, { doc, hay });
+    const keep = new Set(m.order);
+    for (const key of byKey.keys()) if (!keep.has(key)) byKey.delete(key);
+    const entries = m.order.map((key) => byKey.get(key) || { doc: null, hay: null });
+    docs = entries.map((e) => e.doc);
+    hays = entries.some((e) => e.hay != null) ? entries.map((e) => e.hay) : null;
+    return;
+  }
+  if (m.type === 'search') {
+    self.postMessage({ type: 'search', id: m.id, ...Search.searchJob(docs, hays, m) });
+    return;
+  }
+  if (m.type === 'find') {
+    const term = Search.compileTerm(m.query, { regex: !!m.regex, caseSensitive: !!m.caseSensitive });
+    self.postMessage({ type: 'find', id: m.id, matches: term.all(String(m.text || '')), valid: term.valid, error: term.error });
+  }
+};