@loicngr/kobo 1.11.39 → 1.11.40

package/dist/server/services/mcp-message-delivery-service.js

@@ -0,0 +1,59 @@
+import { getDb } from '../db/index.js';
+import { finishMessageRequest, markMessageDispatching, reserveMessageRequest, } from './mcp-message-request-service.js';
+import { broadcastPersistedEvent, persistWorkspaceEvent } from './websocket-service.js';
+import { deliverWorkspaceMessage } from './workspace-message-service.js';
+export async function deliverKeyedMcpMessage(workspaceId, key, message) {
+    const db = getDb();
+    const request = reserveMessageRequest(db, workspaceId, key, message.content, message.sessionId);
+    if (!request.fresh)
+        return request.result;
+    let dispatched = false;
+    let accepted;
+    try {
+        await deliverWorkspaceMessage(workspaceId, { ...message, clientMessageId: request.requestId }, {
+            beforeDispatch() {
+                // The normal closed-engine fallback may enter this boundary again
+                // while resuming the very same request, never a second reservation.
+                if (dispatched)
+                    return;
+                markMessageDispatching(db, request.requestId);
+                dispatched = true;
+            },
+            persist(payload, sessionId) {
+                const committed = db.transaction(() => {
+                    const event = persistWorkspaceEvent(workspaceId, 'user:message', payload, sessionId);
+                    const result = { accepted: true, requestId: request.requestId, eventId: event.id, sessionId };
+                    finishMessageRequest(db, request.requestId, 'accepted', result);
+                    return { event, result };
+                })();
+                accepted = committed.result;
+                broadcastPersistedEvent(committed.event);
+            },
+        });
+        if (!accepted)
+            throw new Error('Delivery completed without a durable receipt');
+        return accepted;
+    }
+    catch (error) {
+        // A notification failure cannot invalidate an already committed receipt.
+        if (accepted)
+            return accepted;
+        const result = {
+            accepted: false,
+            requestId: request.requestId,
+            code: dispatched ? 'delivery_unknown' : 'delivery_rejected',
+            message: dispatched
+                ? 'Delivery may have occurred; inspect history before sending a new request'
+                : error instanceof Error
+                    ? error.message
+                    : String(error),
+        };
+        try {
+            finishMessageRequest(db, request.requestId, dispatched ? 'unknown' : 'rejected', result);
+        }
+        catch {
+            /* The reserved/dispatching row still prevents redelivery if storage failed. */
+        }
+        return result;
+    }
+}

package/dist/server/services/mcp-message-request-service.js

@@ -0,0 +1,64 @@
+import { createHash } from 'node:crypto';
+import { nanoid } from 'nanoid';
+export function reserveMessageRequest(db, workspaceId, key, content, sessionId) {
+    const fingerprint = createHash('sha256')
+        .update(JSON.stringify([content, sessionId ?? null]))
+        .digest('hex');
+    return db
+        .transaction(() => {
+        const requestId = `mcp-${nanoid()}`;
+        const now = new Date().toISOString();
+        const inserted = db
+            .prepare(`INSERT INTO mcp_message_requests(workspace_id,idempotency_key,request_id,fingerprint,state,created_at,updated_at)
+      VALUES (?,?,?,?,'reserved',?,?) ON CONFLICT(workspace_id,idempotency_key) DO NOTHING`)
+            .run(workspaceId, key, requestId, fingerprint, now, now);
+        if (inserted.changes)
+            return { fresh: true, requestId };
+        const row = db
+            .prepare('SELECT request_id,fingerprint,state,result_json FROM mcp_message_requests WHERE workspace_id=? AND idempotency_key=?')
+            .get(workspaceId, key);
+        let result;
+        if (row.fingerprint !== fingerprint)
+            result = {
+                accepted: false,
+                requestId: row.request_id,
+                code: 'idempotency_conflict',
+                message: 'This key was already used for different content or a different session',
+            };
+        else if (row.result_json) {
+            result = JSON.parse(row.result_json);
+            if (result.accepted)
+                result = { ...result, replayed: true };
+        }
+        else
+            result = {
+                accepted: false,
+                requestId: row.request_id,
+                code: row.state === 'unknown' ? 'delivery_unknown' : 'in_progress',
+                message: row.state === 'unknown'
+                    ? 'Delivery may have occurred; inspect history before sending a new request'
+                    : 'This request is still in progress; retry the same key to check its outcome',
+            };
+        return { fresh: false, requestId: row.request_id, result };
+    })
+        .immediate();
+}
+export function markMessageDispatching(db, requestId) {
+    const result = db
+        .prepare("UPDATE mcp_message_requests SET state='dispatching',updated_at=? WHERE request_id=? AND state='reserved'")
+        .run(new Date().toISOString(), requestId);
+    if (result.changes !== 1)
+        throw new Error('MCP request is no longer reserved');
+}
+export function finishMessageRequest(db, requestId, state, result) {
+    const changed = db
+        .prepare(`UPDATE mcp_message_requests SET state=?,result_json=?,event_id=?,session_id=?,updated_at=?
+    WHERE request_id=? AND state IN ('reserved','dispatching')`)
+        .run(state, JSON.stringify(result), result.accepted ? result.eventId : null, result.accepted ? (result.sessionId ?? null) : null, new Date().toISOString(), requestId);
+    if (changed.changes !== 1)
+        throw new Error('MCP request is no longer pending');
+}
+/** Backend startup only: never assume an interrupted engine delivery did not happen. */
+export function reconcileMessageRequests(db) {
+    db.prepare("UPDATE mcp_message_requests SET state='unknown',updated_at=? WHERE state IN ('reserved','dispatching')").run(new Date().toISOString());
+}

package/dist/server/services/pr-checkout-service.js

@@ -9,7 +9,7 @@ import { fingerprintWorktree } from '../utils/git-worktree-fingerprint.js';
 import { withWorkspaceLifecycleGuard } from '../utils/workspace-lifecycle-guard.js';
 import { resolveWorkspaceWorktreePath } from '../utils/worktree-paths.js';
 import { hasController } from './agent/orchestrator.js';
-import { createWorktree, listWorktrees, removeWorktreeUnlocked } from './worktree-service.js';
+import { createWorktreeUnlocked, listWorktrees, removeWorktreeUnlocked } from './worktree-service.js';
 /**
  * A `pathCollision.worktreePath` decision is untrusted input reaching
  * `git worktree add` directly — including from a network-access client that
@@ -81,9 +81,9 @@ function hasCommonAncestor(repoPath, branch) {
     }
 }
 /** Locate any worktree already sitting on `branch`, or at the target path. */
-function diagnoseWorktree(projectPath, branch, targetPath, attachedPaths) {
+async function diagnoseWorktree(projectPath, branch, targetPath, attachedPaths) {
     const blockers = [];
-    const worktrees = listWorktrees(projectPath);
+    const worktrees = await listWorktrees(projectPath);
     const onBranch = worktrees.find((wt) => wt.branch === branch);
     if (onBranch) {
         if (!fs.existsSync(onBranch.path)) {
@@ -163,7 +163,7 @@ export async function computeFingerprint(report) {
  * `attachedPaths` maps worktree path -> workspace id; the route supplies it so
  * this function stays free of database access and easy to test.
  */
-export function diagnoseLocalState(projectPath, headBranch, worktreesPath, attachedPaths = new Map(), workspaces = []) {
+export async function diagnoseLocalState(projectPath, headBranch, worktreesPath, attachedPaths = new Map(), workspaces = []) {
     const targetWorktreePath = resolveWorkspaceWorktreePath(projectPath, headBranch, worktreesPath);
     const blockers = [];
     const lockPath = gitOps.getIndexLockPath(projectPath);
@@ -174,7 +174,7 @@ export function diagnoseLocalState(projectPath, headBranch, worktreesPath, attac
         !hasCommonAncestor(projectPath, headBranch)) {
         blockers.push({ kind: 'no-common-ancestor', branch: headBranch });
     }
-    const { worktree, blockers: worktreeBlockers } = diagnoseWorktree(projectPath, headBranch, targetWorktreePath, attachedPaths);
+    const { worktree, blockers: worktreeBlockers } = await diagnoseWorktree(projectPath, headBranch, targetWorktreePath, attachedPaths);
     blockers.push(...worktreeBlockers);
     const inspectPath = worktree.state === 'orphan' || worktree.state === 'attached' ? worktree.path : null;
     return {
@@ -256,8 +256,8 @@ export class StaleDiagnosisError extends Error {
  * `change-source-branch-service`, so it cannot interleave with a worktree purge
  * or a source-branch change.
  */
-export function resolvePrCheckout(input) {
-    const initial = diagnoseLocalState(input.projectPath, input.headBranch, input.worktreesPath, input.attachedPaths, input.workspaces);
+export async function resolvePrCheckout(input) {
+    const initial = await diagnoseLocalState(input.projectPath, input.headBranch, input.worktreesPath, input.attachedPaths, input.workspaces);
     const owner = initial.worktree.state === 'attached'
         ? initial.worktree.workspaceId
         : initial.workspace.state !== 'none'
@@ -274,7 +274,7 @@ function resolvePrCheckoutLocked(input, owner) {
         // 1. Refresh, then refuse a plan built on facts that no longer hold.
         gitOps.fetchSourceBranch(input.projectPath, input.headBranch);
         applied.push({ kind: 'fetch', detail: `origin/${input.headBranch}` });
-        const fresh = diagnoseLocalState(input.projectPath, input.headBranch, input.worktreesPath, input.attachedPaths ?? new Map(), input.workspaces ?? []);
+        const fresh = await diagnoseLocalState(input.projectPath, input.headBranch, input.worktreesPath, input.attachedPaths ?? new Map(), input.workspaces ?? []);
         if ((await computeFingerprint(fresh)) !== input.fingerprint)
             throw new StaleDiagnosisError(fresh);
         if ((fresh.worktree.state === 'orphan' || fresh.worktree.state === 'attached') &&
@@ -346,7 +346,7 @@ function resolvePrCheckoutLocked(input, owner) {
             const baseRef = gitOps.localBranchExists(input.projectPath, input.headBranch)
                 ? input.headBranch
                 : `origin/${input.headBranch}`;
-            const target = createWorktree(input.projectPath, input.headBranch, baseRef, input.worktreesPath, undefined, explicitPath);
+            const target = await createWorktreeUnlocked(input.projectPath, input.headBranch, baseRef, input.worktreesPath, undefined, explicitPath);
             worktreePath = target.worktreePath;
             created = true;
             applied.push({ kind: 'create-worktree', detail: worktreePath });
@@ -361,7 +361,7 @@ function resolvePrCheckoutLocked(input, owner) {
         catch (err) {
             if (created) {
                 try {
-                    removeWorktreeUnlocked(input.projectPath, worktreePath);
+                    await removeWorktreeUnlocked(input.projectPath, worktreePath);
                 }
                 catch (cleanupErr) {
                     console.error('[pr-checkout] rollback failed to remove the worktree:', cleanupErr);

package/dist/server/services/pr-watcher-service.js

@@ -1,7 +1,7 @@
 import fs from 'node:fs';
 import { fetchSourceBranchAsync } from '../utils/git-ops.js';
 import { withGitRepoLock } from '../utils/git-repo-lock.js';
-import { isWorkspaceLifecycleBusy } from '../utils/workspace-lifecycle-guard.js';
+import { isWorkspaceLifecycleBusy, withWorkspaceLifecycleGuard } from '../utils/workspace-lifecycle-guard.js';
 import { hasController } from './agent/orchestrator.js';
 import { stopDevServer } from './dev-server-service.js';
 import { getForgeProvider } from './forge/registry.js';
@@ -99,19 +99,24 @@ function markUnread(workspaceId) {
         console.error('[pr-watcher] markUnread failed:', err instanceof Error ? err.message : err);
     }
 }
-function autoRestoreManuallyRecreatedWorktrees() {
+async function autoRestoreManuallyRecreatedWorktrees() {
     for (const ws of listArchivedWorkspaces()) {
         if (!ws.worktreePurgedAt || !ws.worktreeOwned || isWorkspaceLifecycleBusy(ws.id))
             continue;
         if (!fs.existsSync(ws.worktreePath))
             continue;
-        if (!isMatchingWorkspaceWorktree(ws))
-            continue;
         try {
-            const restored = restoreWorktreeFromDisk(ws.id);
-            invalidateWorkspacePrCaches(ws.id);
-            emitEphemeral(ws.id, 'workspace:worktree-restored', { workspace: restored });
-            console.log(`[pr-watcher] auto-restored worktree for workspace '${ws.name}' (manual restore detected)`);
+            await withWorkspaceLifecycleGuard(ws.id, async () => {
+                const current = getWorkspace(ws.id);
+                if (!current?.worktreePurgedAt || !current.worktreeOwned)
+                    return;
+                if (!(await isMatchingWorkspaceWorktree(current)))
+                    return;
+                const restored = restoreWorktreeFromDisk(ws.id);
+                invalidateWorkspacePrCaches(ws.id);
+                emitEphemeral(ws.id, 'workspace:worktree-restored', { workspace: restored });
+                console.log(`[pr-watcher] auto-restored worktree for workspace '${ws.name}' (manual restore detected)`);
+            });
         }
         catch (err) {
             console.error(`[pr-watcher] auto-restore failed for '${ws.name}':`, err instanceof Error ? err.message : err);
@@ -119,7 +124,7 @@ function autoRestoreManuallyRecreatedWorktrees() {
     }
 }
 export async function checkPrStatuses() {
-    autoRestoreManuallyRecreatedWorktrees();
+    await autoRestoreManuallyRecreatedWorktrees();
     const workspaces = listWorkspaces(false); // non-archived only
     // Clean up entries for workspaces that no longer exist
     for (const id of lastKnownPr.keys()) {

package/dist/server/services/search/indexer.js

@@ -0,0 +1,232 @@
+export const normalizeSearchText = (text) => text.normalize('NFC').toLowerCase();
+const graphemes = new Intl.Segmenter(undefined, { granularity: 'grapheme' });
+function readable(row) {
+    let p;
+    try {
+        p = JSON.parse(row.payload);
+    }
+    catch {
+        return null;
+    }
+    if (!p || typeof p !== 'object')
+        return null;
+    let text;
+    let messageId = row.id;
+    if (row.type === 'user:message' && typeof p.content === 'string')
+        text = p.content;
+    if (row.type === 'agent:event' && p.kind === 'message:text' && typeof p.text === 'string') {
+        text = p.text;
+        if (typeof p.messageId === 'string')
+            messageId = p.messageId;
+    }
+    if (row.type === 'agent:output') {
+        const content = p.message?.content;
+        if (Array.isArray(content))
+            text = content.flatMap((b) => (b?.type === 'text' && typeof b.text === 'string' ? [b.text] : [])).join('\n');
+    }
+    return text === undefined
+        ? null
+        : { text, key: JSON.stringify([row.workspace_id, row.session_id, row.type, messageId]) };
+}
+/** Map lowercased UTF-16 offsets back to display text (e.g. İ expands to i + dot). */
+function snippet(text, match, needleLength) {
+    let normalizedOffset = 0;
+    let displayOffset = 0;
+    let startOffset = 0;
+    let endOffset = text.length;
+    for (const character of text) {
+        if (normalizedOffset <= match)
+            startOffset = displayOffset;
+        normalizedOffset += character.toLowerCase().length;
+        displayOffset += character.length;
+        if (normalizedOffset >= match + needleLength) {
+            endOffset = displayOffset;
+            break;
+        }
+    }
+    const start = Math.max(0, startOffset - 100);
+    const end = Math.min(text.length, endOffset + 100);
+    return `${start ? '…' : ''}${text.slice(start, end).trim()}${end < text.length ? '…' : ''}`;
+}
+/** Runs on a worker connection. Every batch is atomic and restartable. */
+export class SearchIndexer {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    state() {
+        return this.db.prepare('SELECT * FROM search_index_state WHERE id = 1').get();
+    }
+    status() {
+        const state = this.state();
+        const pending = this.db.prepare('SELECT 1 FROM search_changes LIMIT 1').get();
+        return {
+            state: state.complete && !pending ? 'ready' : 'building',
+            processed: state.processed,
+            total: Math.max(state.processed, state.total, 0),
+        };
+    }
+    rebuild(keys) {
+        const fragments = this.db.prepare('SELECT f.* FROM search_fragments f JOIN ws_events e ON e.id = f.event_id WHERE f.message_key = ? ORDER BY e.rowid');
+        const write = this.db.prepare(`INSERT INTO search_messages(message_key, workspace_id, session_id, event_id, type, created_at, text, normalized)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?) ON CONFLICT(message_key) DO UPDATE SET
+      workspace_id=excluded.workspace_id, session_id=excluded.session_id, event_id=excluded.event_id,
+      type=excluded.type, created_at=excluded.created_at, text=excluded.text, normalized=excluded.normalized`);
+        for (const key of keys) {
+            const rows = fragments.all(key);
+            const first = rows[0];
+            if (!first) {
+                this.db.prepare('DELETE FROM search_messages WHERE message_key = ?').run(key);
+                continue;
+            }
+            const text = rows
+                .map((row) => row.text)
+                .join('')
+                .normalize('NFC');
+            write.run(key, first.workspace_id, first.session_id, first.event_id, first.type, first.created_at, text, normalizeSearchText(text));
+        }
+    }
+    consume(row, eventId, order, keys) {
+        const old = this.db
+            .prepare('SELECT message_key, event_order FROM search_fragments WHERE event_id = ?')
+            .get(eventId);
+        if (old)
+            keys.add(old.message_key);
+        const value = row ? readable(row) : null;
+        if (!value || !row) {
+            this.db.prepare('DELETE FROM search_fragments WHERE event_id = ?').run(eventId);
+            return;
+        }
+        keys.add(value.key);
+        this.db
+            .prepare(`INSERT INTO search_fragments(event_id, message_key, workspace_id, session_id, type, created_at, event_order, text)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?) ON CONFLICT(event_id) DO UPDATE SET
+      message_key=excluded.message_key, workspace_id=excluded.workspace_id, session_id=excluded.session_id,
+      type=excluded.type, created_at=excluded.created_at, text=excluded.text`)
+            .run(row.id, value.key, row.workspace_id, row.session_id, row.type, row.created_at, old?.event_order ?? order, value.text);
+    }
+    tick(batchSize = 500) {
+        // Acquire the writer reservation before reading: a deferred WAL snapshot
+        // cannot be upgraded after another connection commits (SQLITE_BUSY_SNAPSHOT).
+        this.db
+            .transaction(() => {
+            const state = this.state();
+            if (state.total < 0)
+                this.db.prepare('UPDATE search_index_state SET total = (SELECT count(*) FROM ws_events) WHERE id = 1').run();
+            const keys = new Set();
+            const changeBudget = state.complete ? batchSize : Math.max(1, Math.floor(batchSize / 2));
+            const changes = this.db.prepare('SELECT * FROM search_changes ORDER BY id LIMIT ?').all(changeBudget);
+            for (const change of changes) {
+                const row = this.db.prepare('SELECT rowid AS rid, * FROM ws_events WHERE id = ?').get(change.event_id);
+                this.consume(row, change.event_id, change.operation === 'insert' ? state.base_order + change.id : (row?.rid ?? 0), keys);
+            }
+            if (changes.length)
+                this.db.prepare('DELETE FROM search_changes WHERE id <= ?').run(changes.at(-1).id);
+            const backfillBudget = batchSize - changes.length;
+            if (!state.complete && backfillBudget > 0) {
+                const rows = this.db
+                    .prepare('SELECT rowid AS rid, * FROM ws_events WHERE id > ? ORDER BY id LIMIT ?')
+                    .all(state.cursor, backfillBudget);
+                for (const row of rows)
+                    this.consume(row, row.id, row.rid, keys);
+                this.db
+                    .prepare('UPDATE search_index_state SET cursor = ?, processed = processed + ?, complete = ? WHERE id = 1')
+                    .run(rows.at(-1)?.id ?? state.cursor, rows.length, rows.length < backfillBudget ? 1 : 0);
+            }
+            this.rebuild(keys);
+        })
+            .immediate();
+        return this.status();
+    }
+    /** Drain deletions ahead of queries, including those behind an insertion backlog. */
+    removeDeleted() {
+        this.db
+            .transaction(() => {
+            const rows = this.db
+                .prepare(`SELECT DISTINCT f.event_id, f.message_key FROM search_changes c
+        JOIN search_fragments f ON f.event_id = c.event_id
+        WHERE NOT EXISTS (SELECT 1 FROM ws_events e WHERE e.id = c.event_id)`)
+                .all();
+            const keys = new Set();
+            for (const row of rows) {
+                keys.add(row.message_key);
+                this.db.prepare('DELETE FROM search_fragments WHERE event_id = ?').run(row.event_id);
+            }
+            this.rebuild(keys);
+        })
+            .immediate();
+    }
+    /** Resolve a normalized match to the original event used by history deep links. */
+    matchEventId(messageKey, match, fallback) {
+        const fragments = this.db
+            .prepare(`SELECT f.event_id, f.text FROM search_fragments f JOIN ws_events e ON e.id = f.event_id
+        WHERE f.message_key = ? ORDER BY e.rowid`)
+            .all(messageKey);
+        if (fragments.length < 2)
+            return fragments[0]?.event_id ?? fallback;
+        // Normalize whole graphemes: NFC can compose characters across fragment
+        // boundaries, and lowercasing can expand them (İ → i + combining dot).
+        const source = fragments.map((fragment) => fragment.text).join('');
+        let normalizedEnd = 0;
+        let sourceOffset = 0;
+        for (const { segment, index } of graphemes.segment(source)) {
+            normalizedEnd += normalizeSearchText(segment).length;
+            if (normalizedEnd > match) {
+                sourceOffset = index;
+                break;
+            }
+        }
+        let fragmentEnd = 0;
+        for (const fragment of fragments) {
+            fragmentEnd += fragment.text.length;
+            if (fragmentEnd > sourceOffset)
+                return fragment.event_id;
+        }
+        return fallback;
+    }
+    async search(query, options = {}, cancelled = () => false) {
+        this.removeDeleted();
+        const needle = normalizeSearchText(query.trim());
+        if (!needle)
+            return [];
+        const trigram = [...needle].length >= 3 && !needle.includes('\0');
+        const clauses = [options.includeArchived ? '1' : 'w.archived_at IS NULL'];
+        const args = [];
+        if (trigram) {
+            clauses.push('search_messages_fts MATCH ?');
+            args.push(`"${needle.replaceAll('"', '""')}"`);
+        }
+        if (options.workspaceId) {
+            clauses.push('m.workspace_id = ?');
+            args.push(options.workspaceId);
+        }
+        const statement = this.db.prepare(`SELECT m.*, w.name AS workspace_name, w.archived_at
+      FROM search_messages m ${trigram ? 'JOIN search_messages_fts ON search_messages_fts.rowid = m.id' : ''}
+      JOIN workspaces w ON w.id = m.workspace_id WHERE ${clauses.join(' AND ')} ORDER BY m.created_at DESC, m.event_id DESC`);
+        const results = [];
+        let scanned = 0;
+        const limit = Math.min(200, Math.max(1, options.limit ?? 50));
+        for (const row of statement.iterate(...args)) {
+            if (cancelled())
+                throw new Error('Search cancelled');
+            const index = row.normalized.indexOf(needle);
+            if (index >= 0) {
+                results.push({
+                    eventId: row.type === 'agent:event' ? this.matchEventId(row.message_key, index, row.event_id) : row.event_id,
+                    sessionId: row.session_id,
+                    workspaceId: row.workspace_id,
+                    workspaceName: row.workspace_name,
+                    archived: row.archived_at !== null,
+                    type: row.type,
+                    timestamp: row.created_at,
+                    snippet: snippet(row.text, index, needle.length),
+                });
+                if (results.length >= limit)
+                    break;
+            }
+            if (++scanned % 500 === 0)
+                await new Promise((resolve) => setImmediate(resolve));
+        }
+        return results;
+    }
+}

package/dist/server/services/search/worker.js

@@ -0,0 +1,76 @@
+import { parentPort, workerData } from 'node:worker_threads';
+import Database from 'better-sqlite3';
+import { SearchIndexer } from './indexer.js';
+const port = parentPort;
+const db = new Database(workerData.dbPath);
+db.pragma('journal_mode=WAL');
+db.pragma('foreign_keys=ON');
+db.pragma('busy_timeout=5000');
+const indexer = new SearchIndexer(db);
+const cancelled = new Set();
+const requests = new Set();
+let queue = Promise.resolve();
+let stopped = false;
+let timer;
+function report() {
+    port.postMessage({ status: indexer.status() });
+}
+function pump() {
+    if (stopped)
+        return;
+    queue = queue
+        .then(() => {
+        if (stopped)
+            return;
+        indexer.tick();
+        report();
+    })
+        .catch((err) => {
+        // A writer may outlast busy_timeout. The rolled-back batch remains queued
+        // in SQLite; retry it on the next pump instead of poisoning this worker.
+        if (err?.code === 'SQLITE_BUSY' || err?.code?.startsWith('SQLITE_BUSY_'))
+            return;
+        stopped = true;
+        port.postMessage({ status: { state: 'error', processed: 0, total: 0, error: String(err) } });
+    })
+        .finally(() => {
+        if (!stopped)
+            timer = setTimeout(pump, indexer.status().state === 'building' ? 10 : 200);
+    });
+}
+port.on('message', (message) => {
+    if (message.cancel) {
+        if (requests.has(message.id))
+            cancelled.add(message.id);
+        return;
+    }
+    if (message.stop) {
+        stopped = true;
+        clearTimeout(timer);
+        void queue.finally(() => {
+            db.close();
+            port.close();
+        });
+        return;
+    }
+    requests.add(message.id);
+    queue = queue
+        .then(async () => {
+        if (stopped)
+            throw new Error('Search index unavailable');
+        if (cancelled.has(message.id))
+            return;
+        indexer.tick();
+        const results = await indexer.search(message.query ?? '', message.options, () => cancelled.has(message.id));
+        report();
+        port.postMessage({ id: message.id, results });
+    })
+        .catch((err) => {
+        port.postMessage({ id: message.id, error: err instanceof Error ? err.message : String(err) });
+    })
+        .finally(() => {
+        cancelled.delete(message.id);
+        requests.delete(message.id);
+    });
+});
+pump();