@tobq/boardclip 2.1.110 → 2.1.111

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/main.js

@@ -41,6 +41,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 +157,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 +4393,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 });
@@ -6717,10 +6739,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 +6753,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.111",
   "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

@@ -352,6 +352,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

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

@@ -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;
@@ -5784,14 +5954,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 +5991,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 +6002,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 +6027,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 +6107,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 +7104,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 });
+  }
+};