codesift-mcp 0.13.1 → 0.15.0

package/dist/storage/sqlite/runtime.js

@@ -0,0 +1,31 @@
+/**
+ * Runtime availability of `node:sqlite`.
+ *
+ * The memoised constructor lives HERE and nowhere else. ESM gives one instance per module, so a
+ * second copy of `sqliteCtor` (say, re-declared in the barrel rather than re-exported) would fork
+ * the memo: `setSqliteCtorForTesting` would pin one copy while the code under test read the other,
+ * and nothing about that failure looks like a wiring bug.
+ */
+/** `node:sqlite` landed in Node 22.5. The engines floor is still >=20, so its absence is a
+ *  supported state, not an error — callers fall back to the JSON backend. */
+let sqliteCtor;
+export async function loadSqliteCtor() {
+    if (sqliteCtor !== undefined)
+        return sqliteCtor;
+    try {
+        const mod = await import("node:sqlite");
+        sqliteCtor = mod.DatabaseSync;
+    }
+    catch {
+        sqliteCtor = null;
+    }
+    return sqliteCtor;
+}
+export async function isSqliteAvailable() {
+    return (await loadSqliteCtor()) !== null;
+}
+/** Tests need to prove the JSON fallback still works on a runtime that has sqlite. */
+export function setSqliteCtorForTesting(ctor) {
+    sqliteCtor = ctor;
+}
+//# sourceMappingURL=runtime.js.map

package/dist/storage/sqlite/runtime.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.js","sourceRoot":"","sources":["../../../src/storage/sqlite/runtime.ts"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AAEH;6EAC6E;AAC7E,IAAI,UAAsD,CAAC;AAE3D,MAAM,CAAC,KAAK,UAAU,cAAc;IAClC,IAAI,UAAU,KAAK,SAAS;QAAE,OAAO,UAAU,CAAC;IAChD,IAAI,CAAC;QACH,MAAM,GAAG,GAAG,MAAM,MAAM,CAAC,aAAa,CAAC,CAAC;QACxC,UAAU,GAAG,GAAG,CAAC,YAAY,CAAC;IAChC,CAAC;IAAC,MAAM,CAAC;QACP,UAAU,GAAG,IAAI,CAAC;IACpB,CAAC;IACD,OAAO,UAAU,CAAC;AACpB,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,iBAAiB;IACrC,OAAO,CAAC,MAAM,cAAc,EAAE,CAAC,KAAK,IAAI,CAAC;AAC3C,CAAC;AAED,sFAAsF;AACtF,MAAM,UAAU,uBAAuB,CAAC,IAAgD;IACtF,UAAU,GAAG,IAAI,CAAC;AACpB,CAAC"}

package/dist/storage/sqlite/schema.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Table definitions and the v1 -> v2 migration, as SQL text only.
+ *
+ * No behaviour here on purpose: `connection.ts` decides WHEN to run these, under which lock, and
+ * what to record afterwards. Keeping the statements inert makes the schema readable as a schema.
+ */
+/**
+ * v2 dropped the PRIMARY KEY on `symbols.id`.
+ *
+ * `id` is `repo:file:name:line`, which is NOT unique: a minified bundle puts hundreds of
+ * distinct symbols on line 1 of one file, and PHPDoc `@method` synthesis emits a `field`
+ * and a `method` at the same line. As a PRIMARY KEY with `ON CONFLICT DO UPDATE`, every
+ * such collision silently overwrote the previous row — so the store quietly held fewer
+ * symbols than it was given, and re-indexing reproduced the loss instead of repairing it.
+ *
+ * Measured over the 16 indexes that failed the migration's count check: 73,165 dropped
+ * rows, every one carrying content different from the row that survived, and 7,514 of them
+ * in real source rather than minified or vendored output.
+ *
+ * JSON never enforced uniqueness here, so this is parity, not a new tolerance. Lookups by
+ * id return the first match exactly as the array scan did.
+ */
+export declare const SCHEMA_VERSION = 2;
+export declare const SCHEMA_SQL = "\nCREATE TABLE IF NOT EXISTS meta (\n  key   TEXT PRIMARY KEY,\n  value TEXT NOT NULL\n);\n\nCREATE TABLE IF NOT EXISTS files (\n  path          TEXT PRIMARY KEY,\n  language      TEXT NOT NULL,\n  symbol_count  INTEGER NOT NULL,\n  last_modified INTEGER NOT NULL,\n  mtime_ms      INTEGER,\n  stale         INTEGER\n);\n\nCREATE TABLE IF NOT EXISTS symbols (\n  id          TEXT NOT NULL,\n  file        TEXT NOT NULL,\n  name        TEXT NOT NULL,\n  kind        TEXT NOT NULL,\n  start_line  INTEGER NOT NULL,\n  end_line    INTEGER NOT NULL,\n  start_col   INTEGER,\n  end_col     INTEGER,\n  start_byte  INTEGER,\n  end_byte    INTEGER,\n  signature   TEXT,\n  docstring   TEXT,\n  source      TEXT,\n  parent      TEXT,\n  is_async    INTEGER,\n  is_exported INTEGER,\n  extras      TEXT\n);\n\nCREATE INDEX IF NOT EXISTS idx_symbols_file ON symbols(file);\nCREATE INDEX IF NOT EXISTS idx_symbols_name ON symbols(name);\nCREATE INDEX IF NOT EXISTS idx_symbols_id ON symbols(id);\n";
+/**
+ * v1 -> v2: rebuild `symbols` without the PRIMARY KEY, keeping every row already stored.
+ *
+ * Rebuilt in place rather than by re-importing: for most repos the JSON source is gone, so
+ * the db IS the index — dropping it to force a reindex would trade a store that is merely
+ * incomplete for no store at all. This recovers nothing on its own; rows lost under v1 come
+ * back when the repo is next indexed from source, which now keeps them.
+ */
+export declare const MIGRATE_V1_TO_V2_SQL = "\nALTER TABLE symbols RENAME TO symbols_v1;\nCREATE TABLE symbols (\n  id          TEXT NOT NULL,\n  file        TEXT NOT NULL,\n  name        TEXT NOT NULL,\n  kind        TEXT NOT NULL,\n  start_line  INTEGER NOT NULL,\n  end_line    INTEGER NOT NULL,\n  start_col   INTEGER,\n  end_col     INTEGER,\n  start_byte  INTEGER,\n  end_byte    INTEGER,\n  signature   TEXT,\n  docstring   TEXT,\n  source      TEXT,\n  parent      TEXT,\n  is_async    INTEGER,\n  is_exported INTEGER,\n  extras      TEXT\n);\nINSERT INTO symbols SELECT * FROM symbols_v1;\nDROP TABLE symbols_v1;\nCREATE INDEX IF NOT EXISTS idx_symbols_file ON symbols(file);\nCREATE INDEX IF NOT EXISTS idx_symbols_name ON symbols(name);\nCREATE INDEX IF NOT EXISTS idx_symbols_id ON symbols(id);\n";
+//# sourceMappingURL=schema.d.ts.map

package/dist/storage/sqlite/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/storage/sqlite/schema.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,cAAc,IAAI,CAAC;AAEhC,eAAO,MAAM,UAAU,+9BAsCtB,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,oBAAoB,gwBA0BhC,CAAC"}

package/dist/storage/sqlite/schema.js

@@ -0,0 +1,98 @@
+/**
+ * Table definitions and the v1 -> v2 migration, as SQL text only.
+ *
+ * No behaviour here on purpose: `connection.ts` decides WHEN to run these, under which lock, and
+ * what to record afterwards. Keeping the statements inert makes the schema readable as a schema.
+ */
+/**
+ * v2 dropped the PRIMARY KEY on `symbols.id`.
+ *
+ * `id` is `repo:file:name:line`, which is NOT unique: a minified bundle puts hundreds of
+ * distinct symbols on line 1 of one file, and PHPDoc `@method` synthesis emits a `field`
+ * and a `method` at the same line. As a PRIMARY KEY with `ON CONFLICT DO UPDATE`, every
+ * such collision silently overwrote the previous row — so the store quietly held fewer
+ * symbols than it was given, and re-indexing reproduced the loss instead of repairing it.
+ *
+ * Measured over the 16 indexes that failed the migration's count check: 73,165 dropped
+ * rows, every one carrying content different from the row that survived, and 7,514 of them
+ * in real source rather than minified or vendored output.
+ *
+ * JSON never enforced uniqueness here, so this is parity, not a new tolerance. Lookups by
+ * id return the first match exactly as the array scan did.
+ */
+export const SCHEMA_VERSION = 2;
+export const SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS meta (
+  key   TEXT PRIMARY KEY,
+  value TEXT NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS files (
+  path          TEXT PRIMARY KEY,
+  language      TEXT NOT NULL,
+  symbol_count  INTEGER NOT NULL,
+  last_modified INTEGER NOT NULL,
+  mtime_ms      INTEGER,
+  stale         INTEGER
+);
+
+CREATE TABLE IF NOT EXISTS symbols (
+  id          TEXT NOT NULL,
+  file        TEXT NOT NULL,
+  name        TEXT NOT NULL,
+  kind        TEXT NOT NULL,
+  start_line  INTEGER NOT NULL,
+  end_line    INTEGER NOT NULL,
+  start_col   INTEGER,
+  end_col     INTEGER,
+  start_byte  INTEGER,
+  end_byte    INTEGER,
+  signature   TEXT,
+  docstring   TEXT,
+  source      TEXT,
+  parent      TEXT,
+  is_async    INTEGER,
+  is_exported INTEGER,
+  extras      TEXT
+);
+
+CREATE INDEX IF NOT EXISTS idx_symbols_file ON symbols(file);
+CREATE INDEX IF NOT EXISTS idx_symbols_name ON symbols(name);
+CREATE INDEX IF NOT EXISTS idx_symbols_id ON symbols(id);
+`;
+/**
+ * v1 -> v2: rebuild `symbols` without the PRIMARY KEY, keeping every row already stored.
+ *
+ * Rebuilt in place rather than by re-importing: for most repos the JSON source is gone, so
+ * the db IS the index — dropping it to force a reindex would trade a store that is merely
+ * incomplete for no store at all. This recovers nothing on its own; rows lost under v1 come
+ * back when the repo is next indexed from source, which now keeps them.
+ */
+export const MIGRATE_V1_TO_V2_SQL = `
+ALTER TABLE symbols RENAME TO symbols_v1;
+CREATE TABLE symbols (
+  id          TEXT NOT NULL,
+  file        TEXT NOT NULL,
+  name        TEXT NOT NULL,
+  kind        TEXT NOT NULL,
+  start_line  INTEGER NOT NULL,
+  end_line    INTEGER NOT NULL,
+  start_col   INTEGER,
+  end_col     INTEGER,
+  start_byte  INTEGER,
+  end_byte    INTEGER,
+  signature   TEXT,
+  docstring   TEXT,
+  source      TEXT,
+  parent      TEXT,
+  is_async    INTEGER,
+  is_exported INTEGER,
+  extras      TEXT
+);
+INSERT INTO symbols SELECT * FROM symbols_v1;
+DROP TABLE symbols_v1;
+CREATE INDEX IF NOT EXISTS idx_symbols_file ON symbols(file);
+CREATE INDEX IF NOT EXISTS idx_symbols_name ON symbols(name);
+CREATE INDEX IF NOT EXISTS idx_symbols_id ON symbols(id);
+`;
+//# sourceMappingURL=schema.js.map

package/dist/storage/sqlite/schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.js","sourceRoot":"","sources":["../../../src/storage/sqlite/schema.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,CAAC,CAAC;AAEhC,MAAM,CAAC,MAAM,UAAU,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsCzB,CAAC;AAEF;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;CA0BnC,CAAC"}

package/dist/storage/sqlite-index-store.d.ts

@@ -1,89 +1,49 @@
-import type { DatabaseSync as DatabaseSyncType } from "node:sqlite";
-import type { CodeIndex, CodeSymbol, FileEntry } from "../types.js";
-export declare function loadSqliteCtor(): Promise<typeof DatabaseSyncType | null>;
-export declare function isSqliteAvailable(): Promise<boolean>;
-/** Tests need to prove the JSON fallback still works on a runtime that has sqlite. */
-export declare function setSqliteCtorForTesting(ctor: typeof DatabaseSyncType | null | undefined): void;
 /**
- * A storage fault, as distinct from "this repo has no index".
+ * SQLite backend for the per-repo index. See docs/adr/ADR-003-index-storage-format.md.
  *
- * Both used to arrive at callers as `null`, so a locked or corrupt database was indistinguishable
- * from an unindexed repo: tools reported "not indexed" (prompting a pointless full reindex over a
- * database that was merely busy) or returned empty results that read as an authoritative "no
- * matches". Empty-because-broken is the worst answer an index can give, because nothing about it
- * looks wrong.
- */
-export declare class IndexStorageError extends Error {
-    readonly code: string;
-    readonly path: string;
-    constructor(message: string, code: string, path: string, options?: {
-        cause?: unknown;
-    });
-}
-/**
- * Structural check, not `instanceof`.
+ * The point of this module is NOT that SQL is nicer than JSON. It is that the JSON blob
+ * forced every write to cost the size of the whole repo: `saveIncremental` re-parsed and
+ * re-serialised 262 MB to record one edited file, and the PostToolUse hook — a fresh process
+ * per edit, so it can never batch — paid that on every single Write/Edit an agent made.
+ * Here a one-file re-index touches one row.
  *
- * A duplicated module instance (bundler, worker/thread boundary, a test importing through a
- * different specifier) makes `instanceof` false for an object that is in every observable way
- * the right error — and the failure mode is silent: the fault falls into the "unexpected error"
- * branch and gets reported as an unindexed repo, which is the exact bug this file exists to
- * prevent.
- */
-export declare function isIndexStorageError(err: unknown): err is IndexStorageError;
-/** The operational code for `err`, or null when it is not an operational failure. */
-export declare function classifyStorageError(err: unknown): string | null;
-export declare const SCHEMA_VERSION = 1;
-/**
- * Open (and cache) a connection, creating the schema on first use.
+ * Fidelity over elegance: hot fields get real columns (so a full load builds objects without
+ * parsing anything), and the rarely-populated tail (`tokens`, `decorators`, `extends`,
+ * `implements`, `meta`) is kept as one JSON `extras` column. That keeps the round-trip
+ * lossless for language-specific fields nobody here should have to know about, while the
+ * common symbol costs zero JSON.parse calls.
  *
- * WAL is the reason this migration solves a problem a sharded JSON layout would not: the MCP
- * server and the `codesift postindex-file` hook are separate processes writing the same
- * index, and WAL gives them concurrent readers with a single writer instead of a corruption
- * window. `busy_timeout` makes a writer wait its turn rather than throwing SQLITE_BUSY when
- * an agent edits files faster than the previous write settles.
- */
-export declare function openIndexDb(dbPath: string): Promise<DatabaseSyncType>;
-/** Close one cached connection (tests, and the shutdown path). */
-export declare function closeIndexDb(dbPath: string): void;
-export declare function closeAllIndexDbs(): void;
-/** Replace the entire index. Used by full (re)indexing and by JSON->SQLite migration. */
-export declare function saveIndexSqlite(dbPath: string, index: CodeIndex): Promise<void>;
-/**
- * Import a legacy JSON index, but only if this db is still empty — decided and written
- * inside ONE `BEGIN IMMEDIATE` transaction.
+ * ---------------------------------------------------------------------------
  *
- * The check-then-act cannot be done in JS: `codesift postindex-file` is a fresh process per
- * edit, so two of them (or one plus the server) can both observe an empty db, both read the
- * same legacy JSON, and the slower writer then overwrites an incremental update the faster
- * one already committed. An in-process guard cannot see the other process at all.
+ * This file is the FACADE. The implementation lives in `./sqlite/`:
  *
- * `BEGIN IMMEDIATE` takes the write lock before the emptiness check, so the second writer
- * either waits and then sees the committed import (returns false), or fails on busy_timeout —
- * never silently clobbers. Returns true when this call performed the import.
- */
-export declare function importLegacyIndexIfEmpty(dbPath: string, index: CodeIndex): Promise<boolean>;
-/** Materialise the whole index. Returns null when the db has never been written to. */
-export declare function loadIndexSqlite(dbPath: string): Promise<CodeIndex | null>;
-/**
- * One file's `mtime_ms`, without materialising the index.
+ *     runtime.ts     is node:sqlite present, and the memoised constructor
+ *     errors.ts      operational fault vs "nothing indexed here"
+ *     schema.ts      table definitions and the v1 -> v2 migration, as SQL text
+ *     rows.ts        row <-> domain mapping, and the byte accounting for it
+ *     connection.ts  open/close/cache, schema creation, migration, meta k/v
+ *     meta.ts        the optional meta fields, and the summary shape
+ *     index-io.ts    whole-index read and write — the paths that touch every row
+ *     accessors.ts   narrow reads that never materialise the index
  *
- * `file-indexer.ts` used to parse the whole blob for exactly this value and then
- * `saveIncremental` parsed it a second time — two full parses of 262 MB to decide whether a
- * 40-line file had changed.
- */
-export declare function getFileMtimeSqlite(dbPath: string, filePath: string): Promise<number | undefined>;
-/** One file's `files[]` entry, without materialising the index. */
-export declare function getFileEntrySqlite(dbPath: string, filePath: string): Promise<FileEntry | undefined>;
-/** Replace one file's symbols (and optionally its files[] entry) in a single transaction. */
-export declare function saveIncrementalSqlite(dbPath: string, updatedFile: string, newSymbols: CodeSymbol[], fileEntry?: FileEntry): Promise<void>;
-/** Drop a deleted file's symbols and its files[] entry. */
-export declare function removeFileFromIndexSqlite(dbPath: string, deletedFile: string): Promise<void>;
-/** All symbols for one file — lets per-file tools skip the whole-index load. */
-export declare function getSymbolsForFileSqlite(dbPath: string, filePath: string): Promise<CodeSymbol[]>;
-/**
- * Cross-process change counter. SQLite bumps `data_version` when *another* connection
- * commits, which is the invalidation signal a plain JSON file never had — and the reason an
- * in-memory index cache becomes safe here despite the hook writing from its own process.
+ * The path stays because 12 modules import it; keeping it as a re-export means the split is
+ * provably behaviour-preserving rather than an API change dressed as a refactor.
+ *
+ * Two invariants this arrangement rests on, both invisible to a type-check:
+ *
+ *   - The memoised `node:sqlite` constructor lives ONLY in `runtime.ts`, and the open-connection
+ *     cache ONLY in `connection.ts`. ESM gives one instance per module, so re-exporting is safe
+ *     and re-DECLARING is not: a second copy of either forks the state, and the result is a
+ *     `closeIndexDb` that closes a handle somebody else is still handing out.
+ *     `tests/storage/sqlite-module-state.test.ts` fails on exactly that fork.
+ *   - The re-exports below are an explicit list, not `export *`. Adding an export to a submodule
+ *     should be a decision about this facade, not a side effect of writing a helper.
  */
-export declare function getDataVersion(dbPath: string): Promise<number>;
+export { isSqliteAvailable, loadSqliteCtor, setSqliteCtorForTesting } from "./sqlite/runtime.js";
+export { IndexStorageError, classifyStorageError, isIndexStorageError } from "./sqlite/errors.js";
+export { SCHEMA_VERSION } from "./sqlite/schema.js";
+export { closeAllIndexDbs, closeIndexDb, openIndexDb } from "./sqlite/connection.js";
+export type { IndexSummary } from "./sqlite/meta.js";
+export { importLegacyIndexIfEmpty, loadIndexSqlite, saveIndexSqlite, wasLossilyMigrated, } from "./sqlite/index-io.js";
+export { getDataVersion, getFileEntrySqlite, getFileMtimeSqlite, getSymbolsForFileSqlite, loadIndexSummarySqlite, removeFileFromIndexSqlite, saveIncrementalSqlite, } from "./sqlite/accessors.js";
 //# sourceMappingURL=sqlite-index-store.d.ts.map

package/dist/storage/sqlite-index-store.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sqlite-index-store.d.ts","sourceRoot":"","sources":["../../src/storage/sqlite-index-store.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,IAAI,gBAAgB,EAAE,MAAM,aAAa,CAAC;AACpE,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,SAAS,EAAa,MAAM,aAAa,CAAC;AA0B/E,wBAAsB,cAAc,IAAI,OAAO,CAAC,OAAO,gBAAgB,GAAG,IAAI,CAAC,CAS9E;AAED,wBAAsB,iBAAiB,IAAI,OAAO,CAAC,OAAO,CAAC,CAE1D;AAED,sFAAsF;AACtF,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,OAAO,gBAAgB,GAAG,IAAI,GAAG,SAAS,GAAG,IAAI,CAE9F;AAMD;;;;;;;;GAQG;AACH,qBAAa,iBAAkB,SAAQ,KAAK;IAGxC,QAAQ,CAAC,IAAI,EAAE,MAAM;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM;IAHvB,YACE,OAAO,EAAE,MAAM,EACN,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACrB,OAAO,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE,EAI9B;CACF;AA2BD;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,iBAAiB,CAO1E;AAED,qFAAqF;AACrF,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAwBhE;AAoBD,eAAO,MAAM,cAAc,IAAI,CAAC;AA+ChC;;;;;;;;GAQG;AACH,wBAAsB,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,CAAC,CA2C3E;AAED,kEAAkE;AAClE,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CASjD;AAED,wBAAgB,gBAAgB,IAAI,IAAI,CAEvC;AAsLD,yFAAyF;AACzF,wBAAsB,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAWrF;AA4BD;;;;;;;;;;;;GAYG;AACH,wBAAsB,wBAAwB,CAC5C,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,SAAS,GACf,OAAO,CAAC,OAAO,CAAC,CAgBlB;AAED,uFAAuF;AACvF,wBAAsB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC,CA6C/E;AAMD;;;;;;GAMG;AACH,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAM7B;AAED,mEAAmE;AACnE,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC,CAMhC;AAED,6FAA6F;AAC7F,wBAAsB,qBAAqB,CACzC,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,MAAM,EACnB,UAAU,EAAE,UAAU,EAAE,EACxB,SAAS,CAAC,EAAE,SAAS,GACpB,OAAO,CAAC,IAAI,CAAC,CAsBf;AAED,2DAA2D;AAC3D,wBAAsB,yBAAyB,CAC7C,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,IAAI,CAAC,CAcf;AAED,gFAAgF;AAChF,wBAAsB,uBAAuB,CAC3C,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,UAAU,EAAE,CAAC,CAQvB;AAED;;;;GAIG;AACH,wBAAsB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAIpE"}
+{"version":3,"file":"sqlite-index-store.d.ts","sourceRoot":"","sources":["../../src/storage/sqlite-index-store.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AAEH,OAAO,EAAE,iBAAiB,EAAE,cAAc,EAAE,uBAAuB,EAAE,MAAM,qBAAqB,CAAC;AAEjG,OAAO,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAElG,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAEpD,OAAO,EAAE,gBAAgB,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAErF,YAAY,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAErD,OAAO,EACL,wBAAwB,EACxB,eAAe,EACf,eAAe,EACf,kBAAkB,GACnB,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EACL,cAAc,EACd,kBAAkB,EAClB,kBAAkB,EAClB,uBAAuB,EACvB,sBAAsB,EACtB,yBAAyB,EACzB,qBAAqB,GACtB,MAAM,uBAAuB,CAAC"}