@wrongstack/tools 0.306.4 → 0.307.1

package/dist/codebase-index/writer-graph-helpers.d.ts

@@ -54,7 +54,7 @@ export type WriterSymbolGraphRow = {
     signature: string;
     scope: string;
 };
-export declare function buildSymbolGraphNodes(symById: Map<number, WriterSymbolGraphRow>, relatedIds: Set<number>, fileFilter: string, packageOf: (file: string) => string): GraphNode[];
+export declare function buildSymbolGraphNodes(symById: Map<number, WriterSymbolGraphRow>, relatedIds: Set<number>, localFiles: ReadonlySet<string> | string, packageOf: (file: string) => string): GraphNode[];
 export type WeightedEdgeAccumulator = {
     weight: number;
     types: Map<string, number>;

package/dist/codebase-index/writer-helpers.d.ts

@@ -1,5 +1,17 @@
 import type { Ref, Symbol as IndexSymbol } from './schema.js';
 export declare function escapeLike(value: string): string;
+/** Normalize an indexed or user-supplied file path for comparison. */
+export declare function posixIndexPath(file: string): string;
+/**
+ * SQL predicate that matches a stored `file` column against a user-supplied
+ * path. Agents pass project-relative paths (`src/calc.ts`); the index stores
+ * absolute OS paths. Exact, slash-normalized, and suffix matches are accepted.
+ */
+export declare function indexedFileMatchSql(column?: string): string;
+/** Bind values for {@link indexedFileMatchSql}: exact, posix, suffix-LIKE. */
+export declare function indexedFileMatchArgs(file: string): [string, string, string];
+/** True when a stored file path belongs to a package name or path fragment. */
+export declare function matchesIndexedPackageFilter(storedFile: string, packageLabel: string, filter: string): boolean;
 export declare function assignRefsToSymbols(refs: Ref[], symbols: IndexSymbol[]): Ref[];
 /**
  * Resolve the per-project index directory. By default it lives under the

package/dist/codebase-index/writer-mutations.d.ts

@@ -0,0 +1,26 @@
+import type { DatabaseSync } from 'node:sqlite';
+import type { FileMeta, Symbol as IndexSymbol, Ref, SymbolLang } from './schema.js';
+export declare function commitBatchWithStatement(stmtFn: (sql: string) => ReturnType<DatabaseSync['prepare']>, maxSqlVars: number, ftsAvailable: boolean, vectorsAvailable: boolean, allocateSymbolIds: (count: number) => number, invalidateIncomingRefsForFiles: (files: readonly string[]) => Set<string>, resolveRefsForNamesUnsafe: (names: Iterable<string>) => number, entries: Array<{
+    file: string;
+    lang: SymbolLang;
+    symbols: IndexSymbol[];
+    refs: Ref[];
+    mtimeMs: number;
+    symbolCount: number;
+    contentHash?: string | undefined;
+}>, options?: {
+    deleteForFiles?: string[] | undefined;
+}): IndexSymbol[];
+export declare function replaceEmptyFileWithStatement(stmtFn: (sql: string) => ReturnType<DatabaseSync['prepare']>, ftsAvailable: boolean, vectorsAvailable: boolean, invalidateIncomingRefsForFiles: (files: readonly string[]) => Set<string>, resolveRefsForNamesUnsafe: (names: Iterable<string>) => number, meta: FileMeta): void;
+export declare function insertSymbolsWithStatement(stmtFn: (sql: string) => ReturnType<DatabaseSync['prepare']>, maxSqlVars: number, ftsAvailable: boolean, vectorsAvailable: boolean, allocateSymbolIds: (count: number) => number, symbols: IndexSymbol[]): IndexSymbol[];
+export declare function deleteSymbolsForFileWithStatement(stmtFn: (sql: string) => ReturnType<DatabaseSync['prepare']>, ftsAvailable: boolean, vectorsAvailable: boolean, invalidateIncomingRefsForFiles: (files: readonly string[]) => Set<string>, resolveRefsForNamesUnsafe: (names: Iterable<string>) => number, file: string): void;
+export declare function deleteFileWithStatement(stmtFn: (sql: string) => ReturnType<DatabaseSync['prepare']>, ftsAvailable: boolean, vectorsAvailable: boolean, invalidateIncomingRefsForFiles: (files: readonly string[]) => Set<string>, resolveRefsForNamesUnsafe: (names: Iterable<string>) => number, file: string): void;
+export declare function upsertFileWithStatement(stmtFn: (sql: string) => ReturnType<DatabaseSync['prepare']>, meta: FileMeta): void;
+export declare function setFilePackagesWithStatement(stmtFn: (sql: string) => ReturnType<DatabaseSync['prepare']>, entries: ReadonlyMap<string, string>): void;
+export declare function applyImportResolutionsWithStatement(db: DatabaseSync, stmtFn: (sql: string) => ReturnType<DatabaseSync['prepare']>, maxSqlVars: number, resolutions: ReadonlyArray<{
+    fromFile: string;
+    lang: string;
+    module: string;
+    toFile: string;
+}>): number;
+//# sourceMappingURL=writer-mutations.d.ts.map

package/dist/codebase-index/writer-refs.d.ts

@@ -0,0 +1,50 @@
+export declare const FAMILY_MATCH_SQL = "(\n  sym.lang = refs.lang\n  OR EXISTS (\n    SELECT 1 FROM lang_family lf1\n      JOIN lang_family lf2 ON lf1.family = lf2.family\n     WHERE lf1.lang = sym.lang AND lf2.lang = refs.lang\n  )\n  OR ? IN (\n    SELECT family FROM lang_family WHERE lang = refs.lang\n  )\n)";
+export declare function getNamespaceDeclarationsWithStatement(stmtFn: (sql: string) => {
+    all: () => unknown[];
+}): Array<{
+    name: string;
+    file: string;
+}>;
+export declare function getFilePackagesWithStatement(stmtFn: (sql: string) => {
+    all: () => unknown[];
+}): Map<string, string>;
+export declare function getUnresolvedImportsWithStatement(stmtFn: (sql: string) => {
+    all: (...args: (string | number)[]) => unknown[];
+}, maxSqlVars: number, onlyFiles?: readonly string[]): Array<{
+    fromFile: string;
+    lang: string;
+    module: string;
+}>;
+export declare function getAllResolvedRefsWithStatement(stmtFn: (sql: string) => {
+    all: () => unknown[];
+}): Array<{
+    fromId: number;
+    toId: number;
+    callType: string;
+}>;
+export declare function getAllImportRefsWithStatement(stmtFn: (sql: string) => {
+    all: () => unknown[];
+}): Array<{
+    sourceFile: string | null;
+    toName: string;
+    toId: number | null;
+    callType: string;
+    line: number;
+}>;
+export declare function resolveRefsWithStatement(stmtFn: (sql: string) => {
+    run: (...args: (string | number)[]) => unknown;
+}): number;
+export declare function applyImportResolutionsWithStatement(db: {
+    exec: (sql: string) => unknown;
+}, stmtFn: (sql: string) => {
+    run: (...args: string[]) => unknown;
+}, runWithRetry: <T>(fn: () => T) => T, maxSqlVars: number, resolutions: ReadonlyArray<{
+    fromFile: string;
+    lang: string;
+    module: string;
+    toFile: string;
+}>): number;
+export declare function resolveRefsForNamesUnsafe(stmtFn: (sql: string) => {
+    run: (...args: (string | number)[]) => unknown;
+}, maxSqlVars: number, names: Iterable<string>): number;
+//# sourceMappingURL=writer-refs.d.ts.map

package/dist/codebase-index/writer-search.d.ts

@@ -0,0 +1,30 @@
+import { type Bm25Index } from './bm25.js';
+import type { SearchResult } from './schema.js';
+import { type WriterSearchFilter } from './writer-search-helpers.js';
+export declare function searchWithStatement(stmtFn: (sql: string) => {
+    all: (...args: (string | number)[]) => unknown[];
+}, query: string, filter?: WriterSearchFilter, opts?: {
+    limit?: number | undefined;
+}): SearchResult[];
+export declare function countSearchWithStatement(stmtFn: (sql: string) => {
+    get: (...args: (string | number)[]) => unknown;
+}, query: string, filter?: WriterSearchFilter | undefined): number;
+export declare function searchRankedWithStatement(stmtFn: (sql: string) => {
+    all: (...args: (string | number)[]) => unknown[];
+    get: (...args: (string | number)[]) => unknown;
+}, searchFn: (query: string, filter?: WriterSearchFilter, opts?: {
+    limit?: number | undefined;
+}) => SearchResult[], ftsAvailable: boolean, vectorsAvailable: boolean, getOrBuildBm25: () => Bm25Index, query: string, filter: WriterSearchFilter | undefined, limit: number): {
+    results: SearchResult[];
+    total: number;
+};
+export declare function searchRankedFallbackWithStatement(stmtFn: (sql: string) => {
+    all: (...args: (string | number)[]) => unknown[];
+    get: (...args: (string | number)[]) => unknown;
+}, searchFn: (query: string, filter?: WriterSearchFilter, opts?: {
+    limit?: number | undefined;
+}) => SearchResult[], getOrBuildBm25: () => Bm25Index, query: string, filter: WriterSearchFilter | undefined, limit: number): {
+    results: SearchResult[];
+    total: number;
+};
+//# sourceMappingURL=writer-search.d.ts.map

package/dist/codebase-index/writer.d.ts

@@ -1,194 +1,53 @@
 import type { CallSite, CodeMapGraph, FileMeta, IndexStats, Symbol as IndexSymbol, Ref, SearchResult, SymbolKind, SymbolLang } from './schema.js';
-import { type WriterSearchFilter } from './writer-search-helpers.js';
+import type { WriterSearchFilter } from './writer-search-helpers.js';
 import { StorePool } from './writer-store-pool.js';
 export { codebaseIndexDirOverride, resolveIndexDir } from './writer-helpers.js';
 export { StorePool } from './writer-store-pool.js';
 export declare class IndexStore {
     private db;
-    /**
-     * True while an index run owns one outer SQLite transaction. Individual
-     * writer methods normally protect themselves with BEGIN/COMMIT, but during
-     * a refresh they join this transaction so readers observe either the last
-     * completed index or the next completed index, never an in-between batch.
-     */
     private atomicIndexUpdateActive;
     private writeSavepointSequence;
-    /** Absolute path to this project's index directory. */
     private readonly indexDir;
-    /**
-     * True when the SQLite build provides FTS5 (Node's bundled SQLite does).
-     * When false, ranked search falls back to the LIKE + in-process BM25 path.
-     */
     private ftsAvailable;
-    /**
-     * Phase 3: true when the `symbol_vectors` table was created successfully.
-     * When false, hybrid search skips the vector pass and falls back to FTS5
-     * (or LIKE) only.
-     */
     private vectorsAvailable;
-    /**
-     * Cache of prepared statements keyed by their SQL text. `DatabaseSync`
-     * compiles SQL on every `.prepare()` call; for the fixed-SQL methods
-     * (upsertFile, getFileMeta, deleteFile, insertRefs, …) that runs thousands
-     * of times during a full reindex. `StatementSync` objects are reusable
-     * across calls on the same connection, so we compile each distinct SQL once
-     * and reuse it. Cleared in {@link close} when the connection is torn down.
-     */
     private readonly stmtCache;
-    /**
-     * Cached full-corpus BM25 index for the FTS5-unavailable fallback path.
-     * Built lazily on the first `searchRankedFallback` call and invalidated
-     * (via `bm25Dirty`) whenever the `symbols` table is mutated. Computing
-     * IDF over the full corpus is also more correct than the old per-query
-     * candidate-subset IDF.
-     *
-     * Cache-lifecycle invariants (single source of truth lives at the
-     * `invalidateBm25()` helper — see its docblock for the "every mutation
-     * MUST call this" contract):
-     *   - declaration: this field + `bm25Dirty` (here)
-     *   - invalidation: `invalidateBm25()` flips the flag and nulls the cache
-     *   - build: `getOrBuildBm25()` rebuilds against current `symbols` rows
-     *   - teardown: `close()` resets the flag and nulls the cache
-     */
     private bm25Cache;
     private bm25Dirty;
-    /**
-     * Prepare-once helper: compile `sql` on first use, reuse thereafter.
-     *
-     * Bounded LRU rather than an open Map. The cache is keyed by SQL TEXT, and
-     * the fallback search builder emits one `text LIKE ?` clause per query token
-     * — so the SQL varies with the token count and a stream of differently-sized
-     * queries grew the cache without limit. Sage's store already bounds its
-     * equivalent at 128 (WS-096).
-     *
-     * Re-inserting on a hit keeps the hot fixed-SQL statements (upsertFile,
-     * insertRefs, …) at the young end, so a burst of one-off search SQL evicts
-     * itself rather than the reindex hot path.
-     */
     private stmt;
     constructor(projectRoot: string, opts?: {
         indexDir?: string | undefined;
     });
     runWithRetry<T>(fn: () => T): T;
-    /** Run a complete index mutation as one WAL-visible publication. */
     runAtomicIndexUpdate<T>(job: () => Promise<T>): Promise<T>;
-    /**
-     * Begin a method-local transaction. Inside an atomic index publication a
-     * SAVEPOINT preserves the old per-batch rollback boundary, which is needed
-     * when commitBatch falls back to per-file writes after one batch fails.
-     */
     private beginWriteTransaction;
     private commitWriteTransaction;
     private rollbackWriteTransaction;
-    /**
-     * Mirror the in-process language→family map into SQLite.
-     *
-     * Rewritten on every open rather than only on schema bumps: the mapping is
-     * static lookup data, so a code-side change (a new language, a language
-     * moving families) must take effect without forcing a full reindex.
-     */
     private seedLangFamilies;
-    /**
-     * Add any column the current schema expects but the on-disk table lacks.
-     *
-     * `CREATE TABLE IF NOT EXISTS` silently keeps an existing table's old shape,
-     * and the version check above only rebuilds on a version *mismatch*. That
-     * leaves a real gap: several wstack processes share this database, and while
-     * a version upgrade is rolling out one of them may still be running the
-     * previous build. That older process sees the newer version number, drops the
-     * tables, and recreates them from *its* DDL — without the newer columns —
-     * while the metadata row still reads the new version. Every later query for
-     * one of those columns then fails with `no such column`, and no amount of
-     * reindexing fixes it, because the version numbers already agree.
-     *
-     * Repairing column-by-column makes the schema self-healing from any of those
-     * states. Table and column names are compile-time literals from this module,
-     * never user input.
-     */
     private repairMissingColumns;
     private initSchema;
     private static readonly NEXT_SYMBOL_ID_KEY;
-    /** Stay under typical SQLite SQLITE_MAX_VARIABLE_NUMBER (often 999). */
     private static readonly MAX_SQL_VARS;
-    /**
-     * Correlated predicate: the ref in `refs` and the candidate symbol aliased
-     * `sym` belong to the same language family — or the ref carries no language,
-     * in which case the wildcard bind matches everything.
-     *
-     * Each textual occurrence consumes one `?` bind of {@link LANG_FAMILY_WILDCARD}.
-     */
-    private static readonly FAMILY_MATCH_SQL;
-    /**
-     * Ensure `metadata.next_symbol_id` exists. Safe to call outside a write
-     * transaction on open; the first concurrent writer under BEGIN IMMEDIATE
-     * re-reads and advances the counter atomically.
-     */
     private ensureNextSymbolIdSeeded;
-    /**
-     * Reserve `count` consecutive symbol ids. MUST run inside BEGIN IMMEDIATE
-     * so concurrent indexers cannot hand out overlapping ranges.
-     */
     private allocateSymbolIds;
-    /**
-     * Disconnect inbound refs before their target symbols are replaced and
-     * return the affected names for scoped re-resolution.
-     *
-     * This also repairs a long-standing dangling-id edge case: `refs.to_id` has
-     * no physical FK, so deleting a symbol previously left callers pointing at a
-     * non-existent row.
-     */
     private invalidateIncomingRefsForFiles;
-    /** Resolve only refs whose target names may have changed. */
     private resolveRefsForNamesUnsafe;
-    /**
-     * Insert symbols, assigning IDs atomically inside `BEGIN IMMEDIATE` /
-     * `COMMIT`. Id ranges come from the `next_symbol_id` metadata counter
-     * (O(1)); multi-row INSERT amortizes bind overhead for large files.
-     *
-     * @returns The symbols array with `id` fields populated so the caller can
-     *          use them for refs without re-reading from the DB.
-     */
     insertSymbols(symbols: IndexSymbol[]): IndexSymbol[];
     deleteSymbolsForFile(file: string): void;
-    /**
-     * Remove every trace of a file (refs, symbols, FTS rows, file meta). Used
-     * when a source file disappears between index runs — previously this only
-     * dropped the `files` row, leaving its symbols orphaned but still searchable.
-     */
     deleteFile(file: string): void;
     upsertFile(meta: FileMeta): void;
     getFileMeta(file: string): FileMeta | null;
     getAllFileMetas(): FileMeta[];
-    /** Store the Code Atlas grouping label for each indexed file. */
     setFilePackages(entries: ReadonlyMap<string, string>): void;
-    /**
-     * Every indexed `namespace`/`module` declaration, for ecosystems whose import
-     * specifiers name a namespace rather than a path (C#, PHP, Elixir, Haskell).
-     * Ordered so the resolver's choice among duplicate declarations is stable.
-     */
     getNamespaceDeclarations(): Array<{
         name: string;
         file: string;
     }>;
-    /** `file → package` for every indexed file that has a label. */
     getFilePackages(): Map<string, string>;
-    /**
-     * Distinct `(fromFile, lang, module)` triples needing module resolution.
-     *
-     * Distinct rather than per-ref because resolution depends only on these three
-     * values: a file importing the same module twenty times resolves it once.
-     */
     getUnresolvedImports(onlyFiles?: readonly string[]): Array<{
         fromFile: string;
         lang: string;
         module: string;
     }>;
-    /**
-     * Write resolved import targets back onto `refs.to_file`.
-     *
-     * Applied through a temp table and a single UPDATE: one statement per
-     * resolution would mean thousands of round-trips on a first index.
-     */
     applyImportResolutions(resolutions: ReadonlyArray<{
         fromFile: string;
         lang: string;
@@ -198,111 +57,25 @@ export declare class IndexStore {
     search(query: string, filter?: WriterSearchFilter, opts?: {
         limit?: number | undefined;
     }): SearchResult[];
-    /** Shared WHERE builder for {@link search} / empty-query ranked totals. */
-    private buildSearchWhere;
-    private countSearch;
-    /**
-     * Ranked search — the one-stop query the codebase-search tool and plug-lsp
-     * use. With FTS5 this is a single indexed `MATCH` ranked by SQLite's native
-     * `bm25()` with a built-in `snippet()`; without FTS5 it falls back to the
-     * legacy LIKE scan + in-process BM25 (identical semantics, slower).
-     *
-     * Tokens are matched as prefixes (`"tok"*`), mirroring the old
-     * `LIKE '%tok%'` recall for the common symbol-search shapes ("user" finds
-     * "users", camelCase-split text makes "complex" find "complexOperation").
-     */
+    countSearch(query: string, filter?: WriterSearchFilter | undefined): number;
     searchRanked(query: string, filter: WriterSearchFilter | undefined, limit: number): {
         results: SearchResult[];
         total: number;
     };
-    /**
-     * Invalidate the cached BM25 index.
-     *
-     * **Contract: every method that mutates `symbols` MUST call this before
-     * returning.** (`refs` mutations do not affect the BM25 fallback because
-     * the corpus is built from `symbols.text` via `getAllIndexable()` and the
-     * BM25 score is filtered by the LIKE-selected candidate set in
-     * `searchRankedFallback`.) Today the call sites are `repairDrift`,
-     * `insertSymbols`, `deleteSymbolsForFile`, `deleteFile`, `clearAll`, and
-     * `commitBatch`. A future mutation that adds a new write path (e.g.
-     * `renameFile`, `updateSignature`) MUST also call this — otherwise the
-     * FTS5-unavailable fallback will serve stale search results. The
-     * `close()` reset at L1820-1821 tears the cache down on store shutdown,
-     * which is the only legitimate place that flips the flag outside this
-     * helper.
-     *
-     * Called *before* `runWithRetry` on purpose: if the write fails all
-     * retries the flag stays set, forcing a rebuild on the next search rather
-     * than trusting a cache that may not reflect the intended mutation.
-     * Do not move this inside the retry closure.
-     */
     private invalidateBm25;
-    /**
-     * Return the cached full-corpus BM25 index, rebuilding it only when the
-     * symbols table has been mutated since the last build. The full-corpus IDF
-     * is more correct than the old per-query candidate-subset IDF, and the
-     * amortized build cost drops from O(symbols × tokens) per search to once
-     * per write batch.
-     *
-     * Note: the first call after a long idle (or on a freshly opened store)
-     * pays the full corpus rebuild synchronously on the search path. For a
-     * 5 500+ symbol corpus this is a visible one-time latency spike.
-     */
     private getOrBuildBm25;
-    /** Legacy ranked path: LIKE candidates + in-process BM25 + JS snippets. */
-    private searchRankedFallback;
     getAllIndexable(): Array<{
         id: number;
         text: string;
     }>;
-    /**
-     * Largest symbol id currently in the table (0 when empty). New ids must be
-     * allocated from this, NOT from `COUNT(*)`: incremental reindexes delete a
-     * changed file's rows, so the row count drops below the max id and a
-     * count-based id would collide with a surviving row (UNIQUE constraint on
-     * `symbols.id`). Ids may have gaps — that is fine.
-     */
     getMaxSymbolId(): number;
     getStats(): IndexStats;
     setLastIndexed(ts: number): void;
     getMetadata(key: string): string | undefined;
     setMetadata(key: string, value: string): void;
     clearAll(): void;
-    /**
-     * Insert cross-references for a given source symbol id.
-     * Replaces any existing refs from the same source (idempotent on re-index).
-     */
     insertRefs(fromId: number, refs: Ref[]): void;
-    /**
-     * Bulk-insert refs for many source symbols in a single transaction.
-     *
-     * Unlike {@link insertRefs} this does NOT delete per source id — the caller
-     * (the indexer) has already cleared stale refs for the file via
-     * {@link deleteRefsForFile}, so the per-source DELETE would be redundant work
-     * repeated once per symbol. One transaction for the whole file instead of one
-     * per symbol turns an O(symbols) transaction count into O(1).
-     *
-     * Each ref's own {@link Ref.fromId} is used; pass an empty array to no-op.
-     */
     insertRefsBatch(refs: Ref[]): void;
-    /**
-     * Commit a batch of file-level symbol/refs/upserts in a single transaction.
-     *
-     * Used by the indexer to amortize SQLite commit overhead across many files.
-     * Before this, the indexer issued one transaction per file (BEGIN IMMEDIATE
-     * for symbols, plus per-file deletes and an upsertFile call), so a 20-file
-     * parallel batch cost ~5+ transactions × 20 files = 100+ commits. With
-     * this entry point we do exactly one BEGIN/COMMIT per parallel batch.
-     *
-     * Each entry must already be a fully-parsed FileSymbols (symbols + refs).
-     * The caller is responsible for the per-file prefix accounting
-     * (refsByLine → flat list with `fromId` populated). `deleteForFiles` lets
-     * the caller clear stale symbols/refs for any files being re-indexed before
-     * the inserts run (required to keep refs → symbols FK invariants).
-     *
-     * Returns the symbols back with their assigned `id` (same shape as
-     * {@link insertSymbols}) so callers can build final per-file results.
-     */
     commitBatch(entries: Array<{
         file: string;
         lang: SymbolLang;
@@ -314,119 +87,45 @@ export declare class IndexStore {
     }>, options?: {
         deleteForFiles?: string[] | undefined;
     }): IndexSymbol[];
-    /**
-     * Delete all refs whose source symbols are in a given file.
-     * Used when re-indexing a file to clear stale refs.
-     */
     deleteRefsForFile(file: string): void;
-    /**
-     * Resolve `to_name` → `to_id` for all refs that have a name but no id.
-     * Call this after all symbols have been inserted to fill in cross-references.
-     *
-     * A match additionally requires the referencing ref and the target symbol to
-     * be in the same {@link LangFamily}. Without that guard a name match is a
-     * cross-language accident waiting to happen — `main`, `New`, `Parse` and
-     * `Config` are declared in most languages at once, and each collision draws a
-     * Code Atlas edge between files that never reference each other. Refs stored
-     * without a language keep the old global behaviour via the `'*'` wildcard row.
-     */
     resolveRefs(): number;
     resolveRefsForNames(names: Iterable<string>): number;
-    /**
-     * Clear symbols/refs for a file and mark it as indexed with zero symbols.
-     * Used by the indexer for empty-parse results so three writes share one txn.
-     */
     replaceEmptyFile(meta: FileMeta): void;
-    /** Best-effort query planner refresh after a large reindex. */
     optimize(): void;
-    /**
-     * Reclaim page churn left by repeated force rebuilds.
-     *
-     * SQLite's DROP/CREATE path makes rebuilds fast but leaves pages on the
-     * freelist. Compact only large, materially sparse databases and only when the
-     * caller is already on a full-index maintenance path.
-     */
     compactIfNeeded(options?: {
         minBytes?: number;
         minFreeRatio?: number;
     }): boolean;
-    /**
-     * Find all symbols that reference the named target symbol (incoming callers).
-     * Accepts a name instead of an id so the agent doesn't need a prior lookup.
-     */
     findIncomingCallsByName(symbolName: string, file?: string, limit?: number): {
         calls: CallSite[];
         symbolFound: boolean;
         ambiguous: boolean;
         totalMatches: number;
     };
-    /**
-     * Find all symbols that the named source symbol references (outgoing callees).
-     * Accepts a name instead of an id so the agent doesn't need a prior lookup.
-     */
     findOutgoingCallsByName(symbolName: string, file?: string, limit?: number): {
         calls: CallSite[];
         symbolFound: boolean;
         unresolvedCount: number;
         totalMatches: number;
     };
-    /**
-     * Transitive incoming-call tree: all symbols that transitively call the
-     * target, to an unbounded depth (cycle-safe via SQL UNION deduplication).
-     * Used by `codebase-incoming-calls` when the caller wants the full call
-     * chain rather than just direct callers.
-     */
     findTransitiveIncomingCallsByName(symbolName: string, file?: string, limit?: number): {
         calls: CallSite[];
         symbolFound: boolean;
         ambiguous: boolean;
         totalMatches: number;
     };
-    /**
-     * Transitive outgoing-call tree: all symbols the target transitively calls.
-     * Used by `codebase-outgoing-calls` when the caller wants the full
-     * dependency chain rather than just direct callees.
-     */
     findTransitiveOutgoingCallsByName(symbolName: string, file?: string, limit?: number): {
         calls: CallSite[];
         symbolFound: boolean;
         unresolvedCount: number;
         totalMatches: number;
     };
-    /**
-     * Compute the set of symbol IDs reachable from the given seed IDs using a
-     * native SQLite recursive CTE. Used by dead-code detection to replace the
-     * in-memory BFS.
-     */
     findReachableSymbolIds(seedIds: number[]): Set<number>;
-    /**
-     * Find all references TO a given symbol (who calls / uses this symbol?).
-     */
     findRefsTo(symbolId: number): Ref[];
-    /**
-     * Find all references FROM a given symbol (what does this symbol call/use?).
-     */
     findRefsFrom(symbolId: number): Ref[];
-    /**
-     * Package-level graph: each workspace package is a node; edges are derived
-     * from cross-package symbol references (a symbol in package A references a
-     * symbol resolved in package B). Node metadata includes symbol/file counts.
-     */
     getPackageGraph(): CodeMapGraph;
-    /**
-     * File-level graph for a single package: each file is a node; edges are
-     * derived from cross-file symbol references within the package.
-     */
     getFileGraph(packageFilter: string): CodeMapGraph;
-    /**
-     * Symbol-level graph for a single file: each symbol is a node; edges are
-     * derived from intra-file and cross-file symbol references (who calls whom).
-     */
     getSymbolGraph(fileFilter: string): CodeMapGraph;
-    /**
-     * Returns every symbol in the index. Used by dead-code analysis to
-     * build the full symbol universe for the reachability scan.
-     */
     getAllSymbols(): Array<{
         id: number;
         name: string;
@@ -434,36 +133,19 @@ export declare class IndexStore {
         kind: SymbolKind;
         line: number;
     }>;
-    /**
-     * Returns every resolved reference (to_id IS NOT NULL). Used by
-     * dead-code analysis to build the consumer-ship graph. Refs whose
-     * target symbol id is null (unresolved imports) are excluded.
-     */
     getAllResolvedRefs(): Array<{
         fromId: number;
         toId: number;
         callType: string;
     }>;
-    /**
-     * Returns ALL import refs (including unresolved) with their source-file
-     * path and resolved target id.  Used by the dead-code scan's file-level
-     * graph traversal to handle barrel-only entry points where no symbol
-     * carries the ref.
-     *
-     * Refs whose `from_id` doesn't match a known symbol (e.g. pure-barrel
-     * files with no declarations) will have `sourceFile === null`.
-     */
     getAllImportRefs(): Array<{
-        /** Source-file path (null when the owning symbol can't be resolved). */
         sourceFile: string | null;
         toName: string;
-        /** Resolved target symbol id (null when the name couldn't be matched). */
         toId: number | null;
         callType: string;
         line: number;
     }>;
     close(): void;
 }
-/** Process-wide singleton pool. */
 export declare const indexStorePool: StorePool<IndexStore>;
 //# sourceMappingURL=writer.d.ts.map