@tobq/boardclip 2.1.109 → 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/clipboard-model.js

@@ -274,6 +274,13 @@ function conflictSnapshot(item, fallback = {}) {
   };
 }
 
+// Two sides with the same text and title leave nothing to merge.
+function withoutIdenticalSides(conflict) {
+  const { left, right } = conflict || {};
+  if (left && right && left.text === right.text && left.title === right.title) return null;
+  return conflict;
+}
+
 function titleConflict(localItem, remoteItem) {
   if (!localItem || !remoteItem || localItem.type === 'image' || remoteItem.type === 'image') return false;
   if (itemKey(localItem) !== itemKey(remoteItem)) return false;
@@ -890,7 +897,15 @@ function applyTextEdit(items, options = {}) {
     ensureItemId(item);
   }
 
-  const currentIndex = id ? history.findIndex(item => itemKey(item) === id) : -1;
+  let currentIndex = id ? history.findIndex(item => itemKey(item) === id) : -1;
+  // A base edited since this edit began (in another window or on another
+  // device) is gone under its old id. Its newest version is found through the
+  // edit lineage, so the fork below carries a conflict record against it and
+  // the two can be merged, instead of a second copy with nothing to merge.
+  if (currentIndex < 0 && id && options.supersedes) {
+    const headId = supersedeMap(options.supersedes).get(id);
+    if (headId) currentIndex = history.findIndex(item => item.type !== 'image' && itemKey(item) === headId);
+  }
   const current = currentIndex >= 0 ? history[currentIndex] : null;
   const originalTitle = titleEditRequested
     ? (options.originalTitle !== undefined ? cleanTitle(options.originalTitle) : titleOf(current))
@@ -949,13 +964,13 @@ function applyTextEdit(items, options = {}) {
     dedupeNumpadSlots(history);
     const titleMergeConflict = titleConflict(existingBefore, edited);
     const conflict = current && (!canUpdateCurrent || titleDiverged || titleMergeConflict)
-      ? {
+      ? withoutIdenticalSides({
         kind: titleDiverged || titleMergeConflict ? 'title' : 'editor',
         base: { id, type: 'text', text: originalText, title: originalTitle },
         left: titleMergeConflict ? existingBefore : (currentBefore || existingBefore),
         right: conflictSnapshot(edited, { text: newText, title: newTitle }),
         targetId: itemKey(existing),
-      }
+      })
       : null;
     return {
       changed: true,

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

@@ -0,0 +1,83 @@
+'use strict';
+
+// OS notifications with an optional action button, on Windows and macOS.
+// - Windows: Electron's Notification takes a button only through custom toast
+//   XML. A foreground-activated button reaches the app as the notification's
+//   'click' (Electron maps every activation to it), so the body and the button
+//   run the same action.
+// - macOS: Electron's `actions` ('action' event). They show only when the app's
+//   notification style is Alerts; otherwise the body click is the way in.
+// Clicking the notification runs the action everywhere: that is the generic
+// path, and a button is the extra a platform adds on top.
+
+function escapeXml(value) {
+  return String(value == null ? '' : value).replace(/[<>&"']/g, (ch) => ({
+    '<': '&lt;', '>': '&gt;', '&': '&amp;', '"': '&quot;', "'": '&apos;',
+  })[ch]);
+}
+
+function toastXml({ title, body, action, silent = true }) {
+  return '<toast activationType="foreground" launch="open">'
+    + '<visual><binding template="ToastGeneric">'
+    + `<text>${escapeXml(title)}</text>`
+    + (body ? `<text>${escapeXml(body)}</text>` : '')
+    + '</binding></visual>'
+    + (action ? `<actions><action content="${escapeXml(action)}" arguments="action" activationType="foreground"/></actions>` : '')
+    + (silent ? '<audio silent="true"/>' : '')
+    + '</toast>';
+}
+
+function notificationOptions({ title, body, action, silent = true, platform = process.platform } = {}) {
+  const options = { title: String(title || ''), body: String(body || ''), silent: !!silent };
+  if (action && platform === 'win32') options.toastXml = toastXml({ title, body, action, silent });
+  if (action && platform === 'darwin') options.actions = [{ type: 'button', text: String(action) }];
+  return options;
+}
+
+// show() keeps each notification referenced until it is acted on or closed:
+// an unreferenced Notification can be garbage-collected before its click.
+// A toast Windows rejects ('failed') is shown again without the button, so the
+// message still arrives and its click still runs the action; onError hears of
+// every failure (each one is a bug to fix, not a path to rely on).
+function createNotifier({ Notification, platform = process.platform, onError = () => {} } = {}) {
+  const live = new Set();
+  const present = (options, act) => {
+    const notification = new Notification(options);
+    live.add(notification);
+    const done = () => { live.delete(notification); };
+    notification.on('click', () => { done(); act(); });
+    notification.on('action', () => { done(); act(); });
+    notification.on('close', done);
+    notification.on('failed', (_event, error) => {
+      done();
+      onError(new Error(String(error || 'notification failed')));
+      if (options.toastXml) {
+        const { toastXml, ...plain } = options;
+        try { present(plain, act); } catch (retryError) { onError(retryError); }
+      }
+    });
+    notification.show();
+    return notification;
+  };
+  return {
+    show({ title, body, action, onAction, silent = true } = {}) {
+      try {
+        if (!Notification || typeof Notification.isSupported !== 'function' || !Notification.isSupported()) return null;
+        const withAction = typeof onAction === 'function';
+        let acted = false;
+        const act = () => {
+          if (!withAction || acted) return;
+          acted = true;
+          try { onAction(); } catch (error) { onError(error); }
+        };
+        return present(notificationOptions({ title, body, action: withAction ? action : '', silent, platform }), act);
+      } catch (error) {
+        onError(error);
+        return null;
+      }
+    },
+    liveCount: () => live.size,
+  };
+}
+
+module.exports = { escapeXml, toastXml, notificationOptions, createNotifier };

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');
@@ -49,6 +50,7 @@ const { ControlServer } = require('./lib/control-server');
 const windowsConsole = require('./lib/windows-console');
 const windowsDwm = require('./lib/windows-dwm');
 const appearance = require('./lib/appearance');
+const { createNotifier } = require('./lib/notifications');
 
 function guardBrokenPipe(stream) {
   try {
@@ -155,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;
@@ -931,6 +936,7 @@ function applyExternalTextEdit({ id, originalText, originalTitle, sourceGroups,
     newTitle,
     sourceGroups,
     groupTombstones: settings.group_tombstones,
+    supersedes: settings.supersedes,
     now: Date.now(),
     ignoreBlank: true,
   });
@@ -4387,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 });
@@ -5079,11 +5103,10 @@ function refreshTray() {
 //      prefix so they're retained but not resurrected).
 //   5. Disk retention - finished drafts are kept (LRU-pruned) as a last resort.
 //
-// editSessions: sessionId -> session. editWindowsByClip: originalId -> sessionId
-// (enforces one window per clip). A session re-anchors baseText/currentId after
-// each commit so the chain stays contiguous (in-place, not a fork).
+// editSessions: sessionId -> session (one window per note: findEditSessionForClip).
+// A session re-anchors baseText/currentId after each commit so the chain stays
+// contiguous (in-place, not a fork).
 const editSessions = new Map();
-const editWindowsByClip = new Map();
 const conflictWindows = new Map();
 const EDIT_DRAFT_RE = /^boardclip-edit-[0-9a-f]{12}-\d+(?:-\d+)?\.txt$/;   // in-flight drafts only (legacy `-<ts>` and current `-<ts>-<seq>` names)
 let editSessionSeq = 0;
@@ -5134,22 +5157,34 @@ function readDraftFile(sessionOrPath, fallback = {}) {
   return editorPayloadFrom(raw, fallback);
 }
 
+const notifier = createNotifier({
+  Notification,
+  onError: (error) => diagnostics.record('notification.error', { error: error && error.message }, { forceFile: true }),
+});
+
 function showEditNotification(title, body) {
-  try {
-    if (Notification && Notification.isSupported && Notification.isSupported()) {
-      new Notification({ title, body, silent: true }).show();
-    }
-  } catch {}
+  notifier.show({ title, body });
 }
 
-// Surface the conflict-fork outcome so a stale-based commit is never mistaken
-// for a clobber: the user's edit was kept as a new clip, untouched.
+// Surface a stale-based save so it is never mistaken for a clobber: the edit
+// was kept beside the note, and Merge (or a click on the notification) opens
+// the merge view that folds the two back into one note.
 function notifyEditOutcome(result) {
-  if (!result || (result.reason !== 'conflict_created' && result.reason !== 'conflict_merged')) return;
-  showEditNotification(
-    'BoardClip - saved as a separate clip',
-    'This clip changed while you were editing, so your version was kept as a new clip instead of overwriting. Nothing was lost.'
-  );
+  if (!result) return;
+  const record = result.conflictRecord;
+  if (record && record.kind === 'editor') {
+    notifier.show({
+      title: 'BoardClip - this note changed while you were editing',
+      body: 'Your version is kept as a separate clip, so nothing is lost.',
+      action: 'Merge',
+      onAction: () => showConflict(record.id),
+    });
+  } else if (!record && result.reason === 'conflict_created') {
+    showEditNotification(
+      'BoardClip - saved as a new clip',
+      'The clip you were editing was deleted, so your version is kept as a new clip.'
+    );
+  }
 }
 
 // --- Editor <-> clipboard follow (lib/clipboard-follow.js) ---
@@ -5218,6 +5253,7 @@ function commitEditSession(session, payload) {
     notifyEditOutcome(result);
     if (result.conflictRecord && session.win && !session.win.isDestroyed()) {
       session.inConflict = true;
+      session.conflictId = result.conflictRecord.id;
       try { session.win.webContents.send('editor-conflict', conflictModel.normalizeConflictRecord(result.conflictRecord)); } catch {}
     }
   }
@@ -5415,9 +5451,6 @@ function createEditorWindow(session, presentOptions = {}) {
   trackWindowBounds(editorWin, 'editor_bounds');
   editorWin.on('closed', () => {
     editSessions.delete(session.id);
-    if (session.originalId != null && editWindowsByClip.get(session.originalId) === session.id) {
-      editWindowsByClip.delete(session.originalId);
-    }
     // Safety net: commit the latest on-disk draft (the IPC commit may have raced
     // the window teardown), then mark the draft finished so it's retained but not
     // re-recovered, and prune. suppressCommit = the clip was deliberately deleted
@@ -5460,19 +5493,47 @@ function presentSecondaryWindow(targetWin, options = {}) {
   hidePopup();
 }
 
+// A note's id changes on every save (content-addressed), so its open editor is
+// found by the note's edit lineage, never by the id it opened with. Matching
+// only that id let a reopen start a second editor on the same note; the
+// first one's next save then left the second stale, and typing in it forked
+// the note.
+function findEditSessionForClip(id) {
+  const key = String(id || '');
+  if (!key) return null;
+  const lineage = clipboardModel.supersedeMap(settings.supersedes);
+  const head = (clipId) => lineage.get(clipId) || clipId;
+  const target = head(key);
+  for (const session of editSessions.values()) {
+    if (!session.currentId || !session.win || session.win.isDestroyed()) continue;
+    if (session.currentId === key || head(session.currentId) === target) return session;
+  }
+  return null;
+}
+
+// The merge view of a conflict: the editor already showing it (an editor turns
+// into the merge view when its save conflicts), else a conflict window.
+function showConflict(conflictId) {
+  const id = String(conflictId || '');
+  for (const session of editSessions.values()) {
+    if (session.conflictId === id && session.win && !session.win.isDestroyed()) {
+      presentSecondaryWindow(session.win);
+      return { ok: true };
+    }
+  }
+  return openConflictWindow(id);
+}
+
 function openEditor(id, options = {}) {
   if (id != null) {
-    const openSessionId = editWindowsByClip.get(id);
-    if (openSessionId) {
-      const s = editSessions.get(openSessionId);
-      if (s && s.win && !s.win.isDestroyed()) {
-        try {
-          presentSecondaryWindow(s.win, options);
-          if (options && options.find) s.win.webContents.send('editor-find', { query: options.find, findRegex: !!options.findRegex });
-          if (options && options.focusTitle) s.win.webContents.send('editor-find', { focusTitle: true });
-        } catch {}
-        return;
-      }
+    const s = findEditSessionForClip(id);
+    if (s) {
+      try {
+        presentSecondaryWindow(s.win, options);
+        if (options && options.find) s.win.webContents.send('editor-find', { query: options.find, findRegex: !!options.findRegex });
+        if (options && options.focusTitle) s.win.webContents.send('editor-find', { focusTitle: true });
+      } catch {}
+      return;
     }
   }
   let baseText = '';
@@ -5522,7 +5583,6 @@ function openEditor(id, options = {}) {
   session.follow.observe(editorNoteTexts(session));
   writeDraftFile(session);
   editSessions.set(session.id, session);
-  if (originalId != null) editWindowsByClip.set(originalId, session.id);
   createEditorWindow(session, options);
 }
 
@@ -5649,6 +5709,51 @@ function clipWindowState(id) {
   return { item, items, groups: [...(settings.groups || [])], aiGroup: mcpCore.AI_GROUP_NAME };
 }
 
+// A clip by an id a conflict record holds, followed to its newest version
+// when it was edited since.
+function liveTextClip(id) {
+  const key = String(id || '');
+  if (!key) return null;
+  const item = findHistoryItem(key) || findHistoryItem(clipboardModel.supersedeMap(settings.supersedes).get(key));
+  return item && item.type !== 'image' ? item : null;
+}
+
+// An editor conflict joins two clips: the note (left) and the edit kept beside
+// it (targetId). Resolving it makes them one note again.
+function conflictForkPair(record) {
+  if (!record || record.kind !== 'editor') return null;
+  const note = liveTextClip(record.left && record.left.id);
+  const fork = liveTextClip(record.targetId || (record.right && record.right.id));
+  return note && fork && note !== fork ? { note, fork } : null;
+}
+
+// The resolved text went into the note, which keeps its pin, numpad key and
+// lineage. The fork folds into it like an edit: its groups (and a numpad key
+// the note lacks) join the note, and a supersede link sends a stale copy or
+// an open editor of it to the note.
+function foldForkInto(fork, note) {
+  if (!fork || !note || fork === note) return;
+  const forkIndex = history.indexOf(fork);
+  if (forkIndex < 0) return; // the write already merged the two (same text)
+  const forkId = itemKey(fork);
+  const noteId = itemKey(note);
+  const forkSlot = numpadSlotOf(fork);
+  const noteGroups = groupsOf(note);
+  const newGroups = groupsOf(fork).filter(group => !noteGroups.includes(group));
+  if (newGroups.length) {
+    const pin = ensurePin(note);
+    pin.groups = [...(pin.groups || []), ...newGroups];
+    touchPinGroups(note);
+  }
+  if (isPinned(fork) && !note.pin) ensurePin(note);
+  deleteHistoryIndex(forkIndex, { tombstone: false });
+  addTombstone(forkId, null);
+  addSupersede({ from: forkId, to: noteId, updatedAt: Date.now() });
+  saveSettingsFile();
+  saveHistory();
+  if (forkSlot != null && numpadSlotOf(note) == null) applyNumpadAssign(noteId, forkSlot, clipboardModel.clipRevision(note));
+}
+
 function applyConflictResolution(resolution) {
   const payload = resolution && typeof resolution === 'object' ? resolution : {};
   const conflictId = String(payload.id || '');
@@ -5661,9 +5766,11 @@ function applyConflictResolution(resolution) {
     const text = write.text;
     const title = snapshot ? titleOf(snapshot) : clipboardModel.titleOf({ title: write.title });
     const targetId = record.targetId || snapshot && snapshot.id || record.right && record.right.id || record.left && record.left.id || '';
-    const target = findHistoryItem(targetId);
+    const fork = conflictForkPair(record);
+    const target = fork ? fork.note : findHistoryItem(targetId);
     if (target && target.type !== 'image') {
-      applyTextEditToItem(target, { newText: text, newTitle: title });
+      const written = applyTextEditToItem(target, { newText: text, newTitle: title });
+      if (fork) foldForkInto(fork.fork, (written && written.item) || fork.note);
     } else if (text.trim()) {
       applyExternalTextEdit({
         id: '',
@@ -6632,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);
@@ -6646,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');
@@ -6973,7 +7081,7 @@ function setupIPC() {
   });
   ipcMain.handle('resolve-conflict', (_, payload) => applyConflictResolution(payload));
   ipcMain.handle('get-conflicts', () => conflictListForRenderer());
-  ipcMain.handle('open-conflict', (_, id) => openConflictWindow(id));
+  ipcMain.handle('open-conflict', (_, id) => showConflict(id));
 
   // Multi-select bulk operations.
   ipcMain.handle('delete-items', (_, targets) => applyDeleteItems(targets));

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.109",
+  "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 });
+  }
+};