dsh-reference-anything 0.3.1 → 0.3.2

package/lib/sources/local-agent/scan.js

@@ -0,0 +1,472 @@
+/**
+ * Filesystem access for local agent transcripts.
+ *
+ * Everything that touches the disk lives here, so the adapters stay pure and
+ * testable against inline fixtures. Two facts about the corpus shape every
+ * function below, both measured rather than assumed:
+ *
+ * - **Transcripts are large.** 541 Claude files totalling 734 MB and 212 Codex
+ *   rollouts totalling 2.24 GB sit on the machine this was written against, the
+ *   largest single rollout being 192 MB. Nothing here may read a whole file.
+ * - **Lines are large and wildly uneven.** In one 21 MB rollout: p50 = 812 B,
+ *   p90 = 14 KB, p99 = 1.4 MB, max = 4.0 MB. A fixed 32 KiB probe window
+ *   recovers exactly one complete line there — which is why probes escalate by
+ *   *lines wanted* under a byte ceiling, and why the streaming pass budgets in
+ *   bytes rather than lines.
+ *
+ * @module dsh-reference-anything/local-agent/scan
+ */
+import { createReadStream } from 'node:fs';
+import { open, readdir, stat } from 'node:fs/promises';
+import { join, relative } from 'node:path';
+import { ReferenceAnythingError } from "../../errors.js";
+import { withDatabase } from "./sqlite.js";
+import { isQueryAdapter } from "./types.js";
+/** Separates a database from the session inside it, in a reference id. */
+export const SESSION_SEPARATOR = '#';
+/** Directory depth walked below each root. */
+const MAX_DEPTH = 6;
+/** Probe windows, in bytes, tried in order until enough lines are recovered. */
+const PROBE_STEPS = [32 * 1024, 256 * 1024, 2 * 1024 * 1024];
+/** Chunk size for walking a large transcript backwards from its end. */
+const TAIL_CHUNK_BYTES = 1024 * 1024;
+/**
+ * Find every transcript under the given roots.
+ *
+ * Reads directory entries and stats only — no file contents — because this runs
+ * behind a keystroke debounce. A root that does not exist is an ordinary state
+ * (that agent is not installed) and is skipped rather than raised.
+ * @param roots - directories to search, each tagged with its agent.
+ * @param adapters - adapters by kind, used to test filenames.
+ * @param maxTranscripts - most descriptors to return, newest first.
+ * @param signal - cancellation from the caller.
+ * @returns descriptors sorted newest-modified first, at most `maxTranscripts`.
+ */
+export async function listTranscripts(roots, adapters, maxTranscripts, signal) {
+    const found = [];
+    for (const root of roots) {
+        const adapter = adapters.get(root.kind);
+        if (adapter === undefined)
+            continue;
+        await walk(root, root.path, 0, adapter, found, signal, maxTranscripts);
+    }
+    found.sort((left, right) => right.mtimeMs - left.mtimeMs);
+    return found.slice(0, maxTranscripts);
+}
+async function walk(root, dir, depth, adapter, found, signal, maxSessions = 200) {
+    signal?.throwIfAborted();
+    if (depth > MAX_DEPTH)
+        return;
+    // An unreadable directory is one nothing could be referenced from anyway;
+    // the remaining roots still list.
+    const entries = await readdir(dir, { withFileTypes: true }).catch(() => []);
+    for (const entry of entries) {
+        const path = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            await walk(root, path, depth + 1, adapter, found, signal, maxSessions);
+            continue;
+        }
+        if (!entry.isFile())
+            continue;
+        const relPath = relative(root.path, path);
+        if (!adapter.matches(relPath))
+            continue;
+        const stats = await stat(path).catch(() => undefined);
+        if (stats === undefined)
+            continue;
+        if (isQueryAdapter(adapter)) {
+            found.push(...await expandSessions(root.kind, path, relPath, stats.mtimeMs, stats.size, adapter, maxSessions));
+            continue;
+        }
+        found.push({ kind: root.kind, path, relPath, mtimeMs: stats.mtimeMs, size: stats.size });
+    }
+}
+/**
+ * Turn one database into a descriptor per conversation inside it.
+ *
+ * This is the only place discovery reads content rather than directory
+ * metadata, and it is affordable for the same reason the bookmark table exists:
+ * the session list is a single indexed query over a few hundred small rows,
+ * where the file-backed formats would need a byte probe per transcript.
+ * @param kind - the format this root holds.
+ * @param path - absolute path to the database.
+ * @param relPath - the database's path relative to its root.
+ * @param mtimeMs - the database file's modification time, used when a session has none.
+ * @param size - the database file's size, which is what a cursor is validated against.
+ * @param adapter - the adapter that knows this schema.
+ * @param limit - most sessions to take from this database.
+ * @returns one descriptor per session, or none when the database was unreadable.
+ */
+async function expandSessions(kind, path, relPath, mtimeMs, size, adapter, limit) {
+    const sessions = await withDatabase(path, db => adapter.sessions(db, limit));
+    if (sessions === undefined)
+        return [];
+    return sessions.map(session => ({
+        kind,
+        path,
+        relPath: `${relPath}${SESSION_SEPARATOR}${session.id}`,
+        // The session's own recency, so the menu orders conversations rather than
+        // giving every session in one database the same position.
+        mtimeMs: session.updatedAt > 0 ? session.updatedAt : mtimeMs,
+        size,
+        session,
+    }));
+}
+/**
+ * Look up the row that describes one conversation.
+ *
+ * A read may arrive without a listing having preceded it — the model can hold a
+ * reference id across turns, and `locate()` resolves a path rather than
+ * replaying discovery — so this is what gives a database-backed snapshot its
+ * title, working directory, and times.
+ * @param path - absolute path to the database.
+ * @param adapter - the adapter that knows this schema.
+ * @param sessionId - which conversation to describe.
+ * @param signal - cancellation from the caller.
+ * @returns the session row, or undefined when the database or the row is unreadable.
+ */
+export async function readSessionInfo(path, adapter, sessionId, signal) {
+    signal?.throwIfAborted();
+    return await withDatabase(path, db => adapter.session(db, sessionId));
+}
+/**
+ * Read one conversation out of a database.
+ * @param path - absolute path to the database.
+ * @param adapter - the adapter that knows this schema.
+ * @param sessionId - which conversation to fold.
+ * @param options - projection settings.
+ * @param maxRecords - most message rows to materialize, counted from the end.
+ * @param signal - cancellation from the caller.
+ * @returns the folded turns, oldest first.
+ */
+export async function readSessionTurns(path, adapter, sessionId, options, maxRecords, signal) {
+    signal?.throwIfAborted();
+    const page = await withDatabase(path, db => adapter.turns(db, sessionId, options, maxRecords));
+    if (page === undefined) {
+        throw new ReferenceAnythingError(`could not read ${JSON.stringify(adapter.displayName)} database ${JSON.stringify(path)}; it is missing, locked, or in a shape this adapter does not understand`, 'REFERENCE_READ_FAILED');
+    }
+    return page;
+}
+/**
+ * Recover complete records from both ends of a transcript.
+ *
+ * Escalates through {@link PROBE_STEPS} until enough complete lines are in hand
+ * or the byte ceiling is reached, because a fixed window cannot serve a corpus
+ * whose p99 line is 1.4 MB. Giving up returns whatever was recovered rather
+ * than throwing: a transcript with no readable metadata still lists, under a
+ * fallback label.
+ * @param path - absolute path to the transcript.
+ * @param size - its size in bytes, from a prior stat.
+ * @param limits - how many lines are wanted and how far to read for them.
+ * @param signal - cancellation from the caller.
+ * @returns the complete records found at each end.
+ */
+export async function probeEnds(path, size, limits, signal) {
+    signal?.throwIfAborted();
+    // Nothing to recover, but the absence is conclusive: an empty file holds no
+    // conversation, and saying so beats making the caller guess.
+    if (size === 0)
+        return { headLines: [], tailLines: [], complete: true };
+    const handle = await open(path, 'r');
+    try {
+        const head = await probeEnd(handle, size, limits.headLines, limits.maxProbeBytes, 'head', signal);
+        const tail = await probeEnd(handle, size, limits.tailLines, limits.maxProbeBytes, 'tail', signal);
+        return { headLines: head.lines, tailLines: tail.lines, complete: head.covered };
+    }
+    finally {
+        await handle.close();
+    }
+}
+async function probeEnd(handle, size, wanted, maxProbeBytes, end, signal) {
+    if (wanted <= 0)
+        return { lines: [], covered: false };
+    let recovered = [];
+    let covered = false;
+    for (const step of PROBE_STEPS) {
+        signal?.throwIfAborted();
+        const span = Math.min(step, maxProbeBytes, size);
+        const offset = end === 'head' ? 0 : size - span;
+        const buffer = Buffer.alloc(span);
+        const { bytesRead } = await handle.read(buffer, 0, span, offset);
+        // A partial line sits at the window's inner edge unless the window reached
+        // that end of the file, in which case the line really does terminate there.
+        recovered = splitComplete(buffer.subarray(0, bytesRead).toString('utf8'), {
+            dropFirst: end === 'tail' && offset > 0,
+            dropLast: end === 'head' && span < size,
+        });
+        covered = span >= size;
+        if (recovered.length >= wanted || covered || span >= maxProbeBytes)
+            break;
+    }
+    // A window that swallowed the file is returned whole rather than clipped to
+    // `wanted`. The extra lines cost nothing to fold, and they are what makes a
+    // "no turns here" answer trustworthy — and they sharpen titles besides, since
+    // a short session's opening prompt can sit past the line the clip would keep.
+    if (end === 'head')
+        return { lines: covered ? recovered : recovered.slice(0, wanted), covered };
+    return { lines: recovered.slice(-wanted), covered };
+}
+/** Split a window into the lines it holds whole. */
+function splitComplete(text, drop) {
+    const lines = text.split('\n');
+    if (drop.dropLast)
+        lines.pop();
+    if (drop.dropFirst)
+        lines.shift();
+    return lines.filter(line => line.trim() !== '');
+}
+/**
+ * Read one window of turns from a transcript.
+ *
+ * Takes one of two branches. Under `maxScanBytes` it streams the whole file
+ * once, so `startIndex` and `totalTurns` are exact. Over it — the 192 MB
+ * rollout — it walks backwards from the end far enough to fill the window,
+ * which is honest but cannot see the beginning: `totalTurns` is then undefined
+ * and the caller must report the snapshot as partial.
+ * @param path - absolute path to the transcript.
+ * @param size - its size in bytes, from a prior stat.
+ * @param adapter - the format's adapter.
+ * @param options - projection settings.
+ * @param request - which turns to return.
+ * @param limits - how much of the file this read may touch.
+ * @param signal - cancellation from the caller.
+ * @returns the turns and their position in the transcript.
+ */
+export async function readTurns(path, size, adapter, options, request, limits, signal) {
+    // A document adapter folds nothing per line and emits everything from
+    // `flush()`, so the tail-anchored path is not available to it: a region of a
+    // document is not a smaller document — half a JSON object parses as nothing,
+    // and half a branch tree has no leaf to walk back from. It would fold to zero
+    // turns and read as "this session was empty" rather than as "this file is too
+    // large to read". Refusing says which. The byte cursor is likewise moot here,
+    // since only `readFromTail` ever mints one.
+    if (adapter.document === true) {
+        if (size > limits.maxScanBytes) {
+            throw new ReferenceAnythingError(`this transcript is ${size} bytes and its format has to be read whole; raise maxScanBytes past that to read it`, 'REFERENCE_TRANSCRIPT_TOO_LARGE');
+        }
+        return await readWholeFile(path, adapter, options, request, limits, signal);
+    }
+    if (size <= limits.maxScanBytes && request.beforeOffset === undefined) {
+        return await readWholeFile(path, adapter, options, request, limits, signal);
+    }
+    return await readFromTail(path, size, adapter, options, request, limits, signal);
+}
+/** One sequential pass: exact indices, memory bounded by the window size. */
+async function readWholeFile(path, adapter, options, request, limits, signal) {
+    const state = adapter.createState();
+    const window = new TurnRing(request.limit);
+    let total = 0;
+    const collect = (turns) => {
+        for (const turn of turns) {
+            if (request.before === undefined || total < request.before)
+                window.push(turn, total);
+            total += 1;
+        }
+    };
+    for await (const line of iterateLines(path, limits.maxLineBytes, signal)) {
+        collect(adapter.step(line, state, options));
+    }
+    collect(adapter.flush(state, options));
+    const items = window.drain();
+    const startIndex = window.firstIndex ?? Math.min(request.before ?? total, total);
+    return {
+        items,
+        startIndex,
+        totalTurns: total,
+        hasOlder: startIndex > 0,
+        compacted: state.compacted,
+        anchored: false,
+    };
+}
+/**
+ * Walk backwards from the end until the window is full.
+ *
+ * Each chunk's leading partial line is discarded — except at offset 0, where
+ * the line genuinely starts — and the recovered region is then parsed forward,
+ * because an adapter folds records in order and cannot run in reverse.
+ */
+async function readFromTail(path, size, adapter, options, request, limits, signal) {
+    const end = Math.min(request.beforeOffset ?? size, size);
+    const handle = await open(path, 'r');
+    try {
+        let regionStart = end;
+        let attempt = {
+            turns: [], offsets: [], compacted: false,
+        };
+        while (regionStart > 0 && attempt.turns.length < request.limit && end - regionStart < limits.maxScanBytes) {
+            signal?.throwIfAborted();
+            regionStart = Math.max(0, regionStart - TAIL_CHUNK_BYTES);
+            const span = end - regionStart;
+            const buffer = Buffer.alloc(span);
+            const { bytesRead } = await handle.read(buffer, 0, span, regionStart);
+            attempt = foldRegion(buffer.subarray(0, bytesRead), regionStart, regionStart > 0, adapter, options, limits.maxLineBytes);
+        }
+        const kept = attempt.turns.slice(-request.limit);
+        const keptOffsets = attempt.offsets.slice(-request.limit);
+        const startOffset = keptOffsets[0] ?? regionStart;
+        // Reaching offset 0 with everything folded means this really is the whole
+        // transcript, so the exact answers are available after all.
+        const sawStart = regionStart === 0 && attempt.turns.length <= request.limit;
+        return {
+            items: kept,
+            startIndex: 0,
+            ...sawStart ? { totalTurns: attempt.turns.length } : {},
+            hasOlder: !sawStart,
+            compacted: attempt.compacted,
+            anchored: !sawStart,
+            ...sawStart ? {} : { startOffset },
+        };
+    }
+    finally {
+        await handle.close();
+    }
+}
+/**
+ * Fold one recovered byte region forward, remembering where each turn began.
+ *
+ * "Began" is the load-bearing word. An assistant run is emitted only when the
+ * *next* user record closes it, so attributing it to the line that flushed it
+ * would place it after records it actually precedes — and the next page back,
+ * reading everything below that offset, would emit it a second time. Each turn
+ * is therefore stamped with the offset of the first line that contributed to
+ * it, which makes the pages abut exactly.
+ */
+function foldRegion(region, regionStart, dropFirstLine, adapter, options, maxLineBytes) {
+    const state = adapter.createState();
+    const turns = [];
+    const offsets = [];
+    let runStart;
+    let cursor = 0;
+    let first = true;
+    while (cursor < region.length) {
+        const start = cursor;
+        const breakAt = region.indexOf(0x0a, start);
+        const stop = breakAt === -1 ? region.length : breakAt;
+        const offset = regionStart + start;
+        const skip = (first && dropFirstLine) || stop - start > maxLineBytes;
+        first = false;
+        cursor = stop + 1;
+        if (skip || stop === start)
+            continue;
+        for (const turn of adapter.step(region.subarray(start, stop).toString('utf8'), state, options)) {
+            turns.push(turn);
+            if (turn.role === 'assistant') {
+                offsets.push(runStart ?? offset);
+                runStart = undefined;
+            }
+            else {
+                offsets.push(offset);
+            }
+        }
+        if (state.pending.length === 0)
+            runStart = undefined;
+        else
+            runStart ??= offset;
+    }
+    for (const turn of adapter.flush(state, options)) {
+        turns.push(turn);
+        offsets.push(runStart ?? regionStart + region.length);
+    }
+    return { turns, offsets, compacted: state.compacted };
+}
+/**
+ * Yield a file's lines without ever holding more than one in memory.
+ *
+ * Splits on `\n` over raw bytes, so a multi-byte character straddling a chunk
+ * boundary cannot be corrupted: `0x0a` never appears inside a UTF-8 sequence.
+ * A line longer than `maxLineBytes` is dropped rather than materialized —
+ * the corpus contains 4 MB records, and the memory bound is the point.
+ */
+async function* iterateLines(path, maxLineBytes, signal) {
+    const stream = createReadStream(path);
+    let held = [];
+    let heldBytes = 0;
+    let skipping = false;
+    try {
+        for await (const chunk of stream) {
+            signal?.throwIfAborted();
+            let cursor = 0;
+            while (cursor < chunk.length) {
+                const breakAt = chunk.indexOf(0x0a, cursor);
+                if (breakAt === -1) {
+                    const rest = chunk.subarray(cursor);
+                    if (!skipping) {
+                        held.push(rest);
+                        heldBytes += rest.length;
+                        if (heldBytes > maxLineBytes) {
+                            skipping = true;
+                            held = [];
+                            heldBytes = 0;
+                        }
+                    }
+                    break;
+                }
+                if (!skipping) {
+                    held.push(chunk.subarray(cursor, breakAt));
+                    heldBytes += breakAt - cursor;
+                    if (heldBytes <= maxLineBytes) {
+                        const line = Buffer.concat(held).toString('utf8');
+                        if (line.trim() !== '')
+                            yield line;
+                    }
+                }
+                held = [];
+                heldBytes = 0;
+                skipping = false;
+                cursor = breakAt + 1;
+            }
+        }
+        if (!skipping && heldBytes > 0 && heldBytes <= maxLineBytes) {
+            const line = Buffer.concat(held).toString('utf8');
+            if (line.trim() !== '')
+                yield line;
+        }
+    }
+    finally {
+        stream.destroy();
+    }
+}
+/**
+ * The newest `capacity` turns seen so far, and where the oldest of them sits.
+ *
+ * A transcript can hold thousands of turns and a window asks for tens, so the
+ * pass keeps only what it will return.
+ */
+class TurnRing {
+    capacity;
+    slots;
+    indices;
+    filled = 0;
+    next = 0;
+    constructor(capacity) {
+        this.capacity = capacity;
+        this.slots = new Array(Math.max(capacity, 0));
+        this.indices = new Array(Math.max(capacity, 0));
+    }
+    push(turn, index) {
+        if (this.capacity <= 0)
+            return;
+        this.slots[this.next] = turn;
+        this.indices[this.next] = index;
+        this.next = (this.next + 1) % this.capacity;
+        if (this.filled < this.capacity)
+            this.filled += 1;
+    }
+    /** Index of the oldest retained turn, or undefined when none was kept. */
+    get firstIndex() {
+        if (this.filled === 0)
+            return undefined;
+        return this.indices[(this.next - this.filled + this.capacity) % this.capacity];
+    }
+    /** The retained turns in chronological order. */
+    drain() {
+        const out = [];
+        for (let step = 0; step < this.filled; step += 1) {
+            const slot = (this.next - this.filled + step + this.capacity) % this.capacity;
+            const turn = this.slots[slot];
+            if (turn !== undefined)
+                out.push(turn);
+        }
+        return out;
+    }
+}

package/lib/sources/local-agent/sqlite.d.ts

@@ -0,0 +1,45 @@
+/**
+ * The one place `node:sqlite` is touched.
+ *
+ * Three of the supported agents keep their history in SQLite rather than in a
+ * file per conversation, so reading them needs a database driver. Node has one
+ * built in — but only since 22.5, and it still prints an experimental warning
+ * on load. Both facts argue for the same shape: import it lazily, from here,
+ * and treat its absence as "that format is unreadable on this runtime" rather
+ * than as a failure of the plugin. A user with no opencode install never pays
+ * for it, because nothing below runs until a database file has actually been
+ * found on disk.
+ *
+ * @module dsh-reference-anything/local-agent/sqlite
+ */
+import type { SqliteReader } from './types.ts';
+/** The slice of `node:sqlite`'s `DatabaseSync` used here. */
+interface Database {
+    prepare(sql: string): {
+        all(...params: readonly (string | number)[]): unknown[];
+    };
+    close(): void;
+}
+type DatabaseConstructor = new (path: string, options?: {
+    readOnly?: boolean;
+}) => Database;
+/**
+ * Load Node's SQLite driver, once.
+ * @returns the constructor, or undefined on a runtime that has no `node:sqlite`.
+ */
+export declare function sqliteDriver(): Promise<DatabaseConstructor | undefined>;
+/**
+ * Open a database read-only and hand its reader to `use`.
+ *
+ * The handle never escapes: every query a caller wants happens inside the
+ * callback, and the database is closed on the way out however that goes. A
+ * database that cannot be opened at all — missing, locked by a live agent
+ * holding an exclusive lock, or not SQLite — yields `undefined` rather than
+ * throwing, because an agent's own database being busy is an ordinary state and
+ * must not take the `@` menu down with it.
+ * @param path - absolute path to the database file.
+ * @param use - what to read from it.
+ * @returns whatever `use` returned, or undefined when the database was unusable.
+ */
+export declare function withDatabase<T>(path: string, use: (db: SqliteReader) => T): Promise<T | undefined>;
+export {};

package/lib/sources/local-agent/sqlite.js

@@ -0,0 +1,113 @@
+/**
+ * The one place `node:sqlite` is touched.
+ *
+ * Three of the supported agents keep their history in SQLite rather than in a
+ * file per conversation, so reading them needs a database driver. Node has one
+ * built in — but only since 22.5, and it still prints an experimental warning
+ * on load. Both facts argue for the same shape: import it lazily, from here,
+ * and treat its absence as "that format is unreadable on this runtime" rather
+ * than as a failure of the plugin. A user with no opencode install never pays
+ * for it, because nothing below runs until a database file has actually been
+ * found on disk.
+ *
+ * @module dsh-reference-anything/local-agent/sqlite
+ */
+/**
+ * Resolved driver, or `null` once the runtime has been found not to have one.
+ *
+ * Cached either way: a Node without `node:sqlite` will not grow one mid-process,
+ * and repeating the failed import per keystroke would be pure cost.
+ */
+let driver;
+/**
+ * Load Node's SQLite driver, once.
+ * @returns the constructor, or undefined on a runtime that has no `node:sqlite`.
+ */
+export async function sqliteDriver() {
+    if (driver !== undefined)
+        return driver ?? undefined;
+    try {
+        const module = await import('node:sqlite');
+        driver = module.DatabaseSync ?? null;
+    }
+    catch {
+        // Node older than 22.5, or a build compiled without SQLite. Neither is an
+        // error here — the three database-backed formats simply do not list.
+        driver = null;
+    }
+    return driver ?? undefined;
+}
+/**
+ * Open a database read-only and hand its reader to `use`.
+ *
+ * The handle never escapes: every query a caller wants happens inside the
+ * callback, and the database is closed on the way out however that goes. A
+ * database that cannot be opened at all — missing, locked by a live agent
+ * holding an exclusive lock, or not SQLite — yields `undefined` rather than
+ * throwing, because an agent's own database being busy is an ordinary state and
+ * must not take the `@` menu down with it.
+ * @param path - absolute path to the database file.
+ * @param use - what to read from it.
+ * @returns whatever `use` returned, or undefined when the database was unusable.
+ */
+export async function withDatabase(path, use) {
+    const DatabaseSync = await sqliteDriver();
+    if (DatabaseSync === undefined)
+        return undefined;
+    let handle;
+    try {
+        handle = new DatabaseSync(path, { readOnly: true });
+    }
+    catch {
+        return undefined;
+    }
+    try {
+        return use(readerFor(handle));
+    }
+    catch {
+        // A schema this build does not recognise reads as "no conversations here",
+        // which is what a user of a *different* agent's database would expect.
+        return undefined;
+    }
+    finally {
+        try {
+            handle.close();
+        }
+        catch {
+            // Closing a database that failed to open properly is not worth a report.
+        }
+    }
+}
+/** Wrap a live handle in the read-only surface adapters are given. */
+function readerFor(handle) {
+    const columnCache = new Map();
+    return {
+        all(sql, ...params) {
+            return handle.prepare(sql).all(...params).filter(isRow);
+        },
+        columns(table) {
+            const cached = columnCache.get(table);
+            if (cached !== undefined)
+                return cached;
+            let names;
+            try {
+                // The table name cannot be bound as a parameter in a PRAGMA, so it is
+                // constrained instead: only a plain identifier is ever passed, and
+                // anything else yields an empty set rather than reaching SQLite.
+                names = /^[A-Za-z_][A-Za-z0-9_]*$/u.test(table)
+                    ? new Set(handle.prepare(`PRAGMA table_info(${table})`).all()
+                        .filter(isRow)
+                        .map(row => String(row['name'])))
+                    : new Set();
+            }
+            catch {
+                names = new Set();
+            }
+            columnCache.set(table, names);
+            return names;
+        },
+    };
+}
+function isRow(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}