@loicngr/kobo 1.11.39 → 1.11.41

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();

package/dist/server/services/search-service.js

@@ -1,117 +1,111 @@
+import { Worker } from 'node:worker_threads';
 import { getDb } from '../db/index.js';
-/** Event types that carry user-authored or assistant-authored readable text. */
-const SEARCHABLE_TYPES = ['user:message', 'agent:event', 'agent:output'];
-const SNIPPET_CONTEXT = 100; // chars on each side of the match
-/**
- * Extract the readable text content of a ws_events payload, or `null` when
- * the event carries no natural-language content (system events, rate-limit
- * pings, etc.).
- */
-function extractReadableText(type, payload) {
-    if (!payload || typeof payload !== 'object')
-        return null;
-    const p = payload;
-    if (type === 'user:message') {
-        return typeof p.content === 'string' ? p.content : null;
-    }
-    if (type === 'agent:output') {
-        // Claude Code streams `{type: 'assistant', message: {content: [{type: 'text', text: '...'}, ...]}}`
-        const msg = p.message;
-        if (msg && Array.isArray(msg.content)) {
-            const parts = [];
-            for (const block of msg.content) {
-                if (block && typeof block === 'object') {
-                    const b = block;
-                    if (b.type === 'text' && typeof b.text === 'string')
-                        parts.push(b.text);
-                }
-            }
-            return parts.length > 0 ? parts.join('\n') : null;
+let active;
+let requestId = 0;
+/** Start lazily for service consumers, eagerly at server boot. Never opens another home directory. */
+export function startSearchIndex() {
+    const dbPath = getDb().name;
+    if (active?.dbPath === dbPath)
+        return;
+    if (active)
+        void stopSearchIndex();
+    const development = import.meta.url.endsWith('.ts');
+    const entry = new URL(`./search/worker.${development ? 'ts' : 'js'}`, import.meta.url);
+    const worker = development
+        ? new Worker(`const { workerData } = require('node:worker_threads'); import('tsx/esm/api').then(({ tsImport }) => tsImport(workerData.entry, workerData.parent));`, {
+            eval: true,
+            workerData: { dbPath, entry: entry.href, parent: import.meta.url },
+        })
+        : new Worker(entry, { workerData: { dbPath } });
+    const state = {
+        worker,
+        dbPath,
+        pending: new Map(),
+        status: { state: 'building', processed: 0, total: 0 },
+    };
+    active = state;
+    worker.unref();
+    const fail = (error) => {
+        state.status = { ...state.status, state: 'error', error: error.message };
+        for (const pending of state.pending.values()) {
+            pending.cleanup();
+            pending.reject(error);
         }
-    }
-    if (type === 'agent:event' && p.kind === 'message:text') {
-        return typeof p.text === 'string' ? p.text : null;
-    }
-    return null;
+        state.pending.clear();
+    };
+    worker.on('error', fail);
+    worker.on('exit', (code) => {
+        if (active === state)
+            fail(new Error(`Search worker stopped (${code})`));
+    });
+    worker.on('message', (message) => {
+        if (message.status)
+            state.status = message.status;
+        if (message.id !== undefined) {
+            const pending = state.pending.get(message.id);
+            if (!pending)
+                return;
+            state.pending.delete(message.id);
+            pending.cleanup();
+            if (message.error)
+                pending.reject(new Error(message.error));
+            else
+                pending.resolve(message.results ?? []);
+        }
+    });
 }
-function buildSnippet(text, matchIndex, query) {
-    const start = Math.max(0, matchIndex - SNIPPET_CONTEXT);
-    const end = Math.min(text.length, matchIndex + query.length + SNIPPET_CONTEXT);
-    const prefix = start > 0 ? '…' : '';
-    const suffix = end < text.length ? '…' : '';
-    return `${prefix}${text.slice(start, end).trim()}${suffix}`;
+export function getSearchIndexStatus() {
+    startSearchIndex();
+    return { ...active.status };
 }
-/**
- * Full-text-ish search across `ws_events.payload` joined with `workspaces`.
- *
- * - Trimmed empty queries return `[]` without hitting the database.
- * - SQLite does the first filter via `LIKE '%q%'` on the raw payload JSON.
- *   Results are then post-filtered in JS against the **readable** text
- *   (extracted from the JSON) to avoid false positives like matches inside
- *   field names or schema strings.
- * - Snippets are 100 chars of context on either side of the first match.
- */
-export function searchEvents(query, options = {}) {
-    const trimmed = query.trim();
-    if (trimmed.length === 0)
+export async function searchEvents(query, options = {}, signal) {
+    if (!query.trim())
         return [];
-    const { limit = 50, includeArchived = false } = options;
-    const db = getDb();
-    const typePlaceholders = SEARCHABLE_TYPES.map(() => '?').join(', ');
-    const archiveFilter = includeArchived ? '' : 'AND w.archived_at IS NULL';
-    const escapedQuery = trimmed.replace(/[\\%_]/g, '\\$&');
-    const likePattern = `%${escapedQuery}%`;
-    const needle = trimmed.toLowerCase();
-    const results = [];
-    const batchSize = Math.min(Math.max(limit * 3, 100), 500);
-    const statement = db.prepare(`SELECT e.id, e.workspace_id, e.session_id, e.type, e.created_at, e.payload,
-            w.name AS workspace_name, w.archived_at
-     FROM ws_events e
-     JOIN workspaces w ON e.workspace_id = w.id
-     WHERE e.type IN (${typePlaceholders})
-       AND e.payload LIKE ? ESCAPE '\\'
-       ${archiveFilter}
-       AND (? IS NULL OR e.created_at < ? OR (e.created_at = ? AND e.id < ?))
-     ORDER BY e.created_at DESC, e.id DESC
-     LIMIT ?`);
-    let cursorCreatedAt = null;
-    let cursorId = null;
-    while (results.length < limit) {
-        const rows = statement.all(...SEARCHABLE_TYPES, likePattern, cursorCreatedAt, cursorCreatedAt, cursorCreatedAt, cursorId, batchSize);
-        for (const row of rows) {
-            let parsed;
-            try {
-                parsed = JSON.parse(row.payload);
-            }
-            catch {
-                continue;
-            }
-            const text = extractReadableText(row.type, parsed);
-            if (!text)
-                continue;
-            const idx = text.toLowerCase().indexOf(needle);
-            if (idx < 0)
-                continue;
-            results.push({
-                eventId: row.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: buildSnippet(text, idx, trimmed),
-            });
-            if (results.length >= limit)
-                break;
-        }
-        if (rows.length < batchSize)
-            break;
-        const last = rows.at(-1);
-        if (!last)
-            break;
-        cursorCreatedAt = last.created_at;
-        cursorId = last.id;
+    if (signal?.aborted)
+        throw new Error('Search cancelled');
+    startSearchIndex();
+    const state = active;
+    if (state.status.state === 'error')
+        throw new Error(state.status.error ?? 'Search index unavailable');
+    const id = ++requestId;
+    return new Promise((resolve, reject) => {
+        const cancel = (message) => {
+            state.pending.delete(id);
+            cleanup();
+            state.worker.postMessage({ id, cancel: true });
+            reject(new Error(message));
+        };
+        const aborted = () => cancel('Search cancelled');
+        const timeout = setTimeout(() => cancel('Search timed out'), 10_000);
+        const cleanup = () => {
+            clearTimeout(timeout);
+            signal?.removeEventListener('abort', aborted);
+        };
+        state.pending.set(id, { resolve, reject, cleanup });
+        signal?.addEventListener('abort', aborted, { once: true });
+        state.worker.postMessage({ id, query, options });
+    });
+}
+export async function stopSearchIndex() {
+    const state = active;
+    if (!state)
+        return;
+    active = undefined;
+    for (const pending of state.pending.values()) {
+        pending.cleanup();
+        pending.reject(new Error('Search index stopped'));
     }
-    return results;
+    state.pending.clear();
+    if (state.worker.threadId === -1)
+        return;
+    await new Promise((resolve) => {
+        const timeout = setTimeout(() => {
+            void state.worker.terminate();
+        }, 5_000);
+        state.worker.once('exit', () => {
+            clearTimeout(timeout);
+            resolve();
+        });
+        state.worker.postMessage({ stop: true });
+    });
 }

package/dist/server/services/update-check-service.js

@@ -0,0 +1,119 @@
+import { getPackageVersion } from '../utils/paths.js';
+import { broadcastAll } from './websocket-service.js';
+export const UPDATE_CHECK_INTERVAL_MS = 20 * 60 * 1000;
+const REGISTRY_URL = 'https://registry.npmjs.org/@loicngr/kobo/latest';
+const STABLE_VERSION = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/;
+let latestVersion = null;
+let lastAttempt = null;
+let lastSuccessAt = null;
+let checkStatus = 'unknown';
+let inFlight = null;
+let controller = null;
+let timer = null;
+let running = false;
+let generation = 0;
+let stopped = false;
+export function getUpdateCheckSnapshot() {
+    return {
+        currentVersion: getPackageVersion(),
+        latestVersion,
+        lastAttemptAt: lastAttempt === null ? null : new Date(lastAttempt).toISOString(),
+        lastSuccessAt,
+        checkStatus,
+    };
+}
+/** Shared by HTTP loads and the single process-wide poller; failures are cached too. */
+export function refreshUpdateCheck() {
+    if (inFlight)
+        return inFlight;
+    if (stopped || (lastAttempt !== null && Date.now() - lastAttempt < UPDATE_CHECK_INTERVAL_MS)) {
+        return Promise.resolve(getUpdateCheckSnapshot());
+    }
+    lastAttempt = Date.now();
+    const owner = generation;
+    const abort = new AbortController();
+    controller = abort;
+    const timeout = setTimeout(() => abort.abort(), 5000);
+    timeout.unref?.();
+    const aborted = new Promise((_, reject) => {
+        abort.signal.addEventListener('abort', () => reject(new Error('Update lookup cancelled')), { once: true });
+    });
+    const lookup = (async () => {
+        const res = await fetch(REGISTRY_URL, { signal: abort.signal });
+        if (!res.ok)
+            throw new Error('Registry lookup failed');
+        const body = await res.json();
+        if (!body ||
+            typeof body !== 'object' ||
+            !('version' in body) ||
+            typeof body.version !== 'string' ||
+            !STABLE_VERSION.test(body.version)) {
+            throw new Error('Invalid registry version');
+        }
+        return body.version;
+    })();
+    inFlight = (async () => {
+        try {
+            const version = await Promise.race([lookup, aborted]);
+            if (owner !== generation)
+                return getUpdateCheckSnapshot();
+            latestVersion = version;
+            lastSuccessAt = new Date().toISOString();
+            checkStatus = 'success';
+        }
+        catch {
+            if (owner !== generation)
+                return getUpdateCheckSnapshot();
+            checkStatus = 'failed';
+        }
+        finally {
+            clearTimeout(timeout);
+            if (owner === generation) {
+                inFlight = null;
+                controller = null;
+            }
+        }
+        const snapshot = getUpdateCheckSnapshot();
+        broadcastAll('kobo:update-checked', snapshot);
+        return snapshot;
+    })();
+    return inFlight;
+}
+function scheduleNextCheck(owner) {
+    if (!running || owner !== generation)
+        return;
+    const delay = lastAttempt === null ? 0 : Math.max(0, UPDATE_CHECK_INTERVAL_MS - (Date.now() - lastAttempt));
+    timer = setTimeout(() => {
+        timer = null;
+        void refreshUpdateCheck().finally(() => scheduleNextCheck(owner));
+    }, delay);
+    timer.unref?.();
+}
+export function startUpdateChecker() {
+    if (running)
+        return;
+    running = true;
+    stopped = false;
+    const owner = generation;
+    void refreshUpdateCheck().finally(() => scheduleNextCheck(owner));
+}
+export function stopUpdateChecker() {
+    running = false;
+    if (timer)
+        clearTimeout(timer);
+    timer = null;
+    stopped = true;
+    generation++;
+    controller?.abort();
+    controller = null;
+    inFlight = null;
+}
+/** @internal test-only — clear the scheduler and registry cache. */
+export function _clearLatestVersionCache() {
+    stopUpdateChecker();
+    stopped = false;
+    latestVersion = null;
+    lastAttempt = null;
+    lastSuccessAt = null;
+    checkStatus = 'unknown';
+}