@statewalker/indexer-sqlite 0.0.0-stage → 0.1.1

package/package.json

@@ -1,6 +1,64 @@
 {
   "name": "@statewalker/indexer-sqlite",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.1",
+  "private": false,
+  "type": "module",
+  "description": "SQLite-backed indexer: FTS5, vector and n-gram/grep sub-indexes in one @statewalker/db-api Db (Node, browser worker, Durable Objects).",
+  "bugs": {
+    "url": "https://github.com/statewalker/statewalker-search/issues"
+  },
+  "homepage": "https://github.com/statewalker/statewalker-search/tree/main/packages/indexer-sqlite#readme",
+  "author": {
+    "name": "Mikhail Kotelnikov",
+    "email": "mikhail.kotelnikov@gmail.com"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/statewalker/statewalker-search.git",
+    "directory": "packages/indexer-sqlite"
+  },
+  "exports": {
+    ".": {
+      "source": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "dependencies": {
+    "@statewalker/db-api": "^0.1.0",
+    "@statewalker/db-sqlite": "^0.1.0",
+    "@statewalker/db-sqlite-index": "^0.1.0",
+    "@statewalker/indexer-api": "^0.1.3",
+    "@statewalker/indexer-fulltext": "^0.1.4",
+    "@statewalker/indexer-core": "^0.1.3",
+    "@statewalker/indexer-ngram": "^0.1.0",
+    "@statewalker/indexer-vector": "^0.1.4"
+  },
+  "devDependencies": {
+    "@statewalker/db-sqlite-do": "^0.1.0",
+    "@statewalker/db-sqlite-node": "^0.3.0",
+    "rimraf": "^6.1.3",
+    "tsdown": "^0.23.0",
+    "typescript": "^7.0.2",
+    "vitest": "^5.0.3",
+    "@statewalker/indexer-tests": "^0.0.0"
+  },
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "test": "vitest run --passWithNoTests",
+    "typecheck": "tsc --noEmit",
+    "clean": "rimraf dist",
+    "lint": "biome check --write .",
+    "format": "biome format --write ."
+  }
 }

package/src/block-ids.ts

@@ -0,0 +1,75 @@
+import type { Db } from "@statewalker/db-api";
+import type { BlockReference, DocumentPath, PathSelector } from "@statewalker/indexer-api";
+import { compositeKey } from "@statewalker/indexer-core";
+import { pathPrefixSql } from "./path-sql.js";
+
+/**
+ * The Index-wide `{path, blockId} ↔ integer id` table shared by every sub-index.
+ * Every method takes the `Db` to run on, so it works on `tx` inside `inTransaction`.
+ * Rows are never deleted before `deleteIndex`: an id stays stable for its block.
+ */
+export interface BlockIds {
+  readonly table: string;
+  /** Ids for `refs`, in order; missing rows are created. */
+  ensure(db: Db, refs: readonly BlockReference[]): Promise<number[]>;
+  /** Ids of every known block matched by any selector (path prefix, or exact block). */
+  select(db: Db, selectors: readonly PathSelector[]): Promise<number[]>;
+  /** References of `ids`; unknown ids are absent. */
+  refs(db: Db, ids: readonly number[]): Promise<Map<number, BlockReference>>;
+}
+
+export async function openBlockIds(db: Db, table: string): Promise<BlockIds> {
+  await db.exec(
+    `CREATE TABLE IF NOT EXISTS ${table} (id INTEGER PRIMARY KEY, path TEXT NOT NULL, block_id TEXT NOT NULL, UNIQUE (path, block_id))`,
+  );
+  return {
+    table,
+    async ensure(tx, refs) {
+      if (refs.length === 0) return [];
+      const json = JSON.stringify(refs.map((r) => [r.path, r.blockId]));
+      // `WHERE true` disambiguates `SELECT … ON CONFLICT` for the SQLite parser.
+      await tx.query(
+        `INSERT INTO ${table} (path, block_id) SELECT json_extract(value, '$[0]'), json_extract(value, '$[1]') FROM json_each(?) WHERE true ON CONFLICT (path, block_id) DO NOTHING`,
+        [json],
+      );
+      const rows = await tx.query<{ id: number; path: string; block_id: string }>(
+        `SELECT b.id, b.path, b.block_id FROM ${table} b JOIN json_each(?) j ON b.path = json_extract(j.value, '$[0]') AND b.block_id = json_extract(j.value, '$[1]')`,
+        [json],
+      );
+      const byKey = new Map(
+        rows.map((r) => [compositeKey(r.path as DocumentPath, r.block_id), Number(r.id)]),
+      );
+      return refs.map((r) => {
+        const id = byKey.get(compositeKey(r.path, r.blockId));
+        if (id === undefined) throw new Error(`block id missing for ${r.path}#${r.blockId}`);
+        return id;
+      });
+    },
+    async select(tx, selectors) {
+      const ids = new Set<number>();
+      for (const sel of selectors) {
+        const where =
+          sel.blockId !== undefined
+            ? { sql: "b.path = ? AND b.block_id = ?", params: [sel.path, sel.blockId] }
+            : pathPrefixSql("b.path", [sel.path]);
+        const rows = await tx.query<{ id: number }>(
+          `SELECT b.id FROM ${table} b WHERE ${where.sql}`,
+          where.params,
+        );
+        for (const r of rows) ids.add(Number(r.id));
+      }
+      return [...ids];
+    },
+    async refs(tx, ids) {
+      const out = new Map<number, BlockReference>();
+      if (ids.length === 0) return out;
+      const rows = await tx.query<{ id: number; path: string; block_id: string }>(
+        `SELECT id, path, block_id FROM ${table} WHERE id IN (SELECT value FROM json_each(?))`,
+        [JSON.stringify(ids)],
+      );
+      for (const r of rows)
+        out.set(Number(r.id), { path: r.path as DocumentPath, blockId: r.block_id });
+      return out;
+    },
+  };
+}

package/src/create-sqlite-indexer.ts

@@ -0,0 +1,218 @@
+import type { Db } from "@statewalker/db-api";
+import type {
+  AnySubIndexBinding,
+  CreateIndexParams,
+  GetIndexOptions,
+  Index,
+  Indexer,
+  IndexInfo,
+} from "@statewalker/indexer-api";
+import { createCompositeIndex, createSerialiser } from "@statewalker/indexer-core";
+import { type BlockIds, openBlockIds } from "./block-ids.js";
+import type { SqliteModalityContext, SqliteModalityProvider } from "./types.js";
+
+export interface SqliteIndexerOptions {
+  /** The database. The indexer never closes it. */
+  db: Db;
+  /** One provider per modality type, e.g. FTS5, vector, n-gram. */
+  providers: SqliteModalityProvider[];
+}
+
+type SubSpec = { type: string } & Record<string, unknown>;
+interface IndexManifest {
+  subIndexes: Record<string, SubSpec>;
+}
+
+const MANIFEST_TABLE = "__indexer_manifest";
+
+/** Escapes everything but lower-case letters and digits: SQLite table names fold case, so "Docs" and "docs" must not collide. */
+const sanitizePrefix = (name: string) =>
+  name.replace(/[^a-z0-9]/g, (ch) => `_${ch.charCodeAt(0)}_`);
+
+const indexPrefix = (name: string) => `idx_${sanitizePrefix(name)}__`;
+
+/**
+ * `Indexer` over one SQLite `Db`. Keeps a manifest row per Index, one shared
+ * `{indexPrefix}blocks` id table per Index, and opens each sub-index through
+ * its provider. Search fuses sub-indexes by RRF (`createCompositeIndex`).
+ */
+export async function createSqliteIndexer(options: SqliteIndexerOptions): Promise<Indexer> {
+  const { db } = options;
+  const providers = new Map(options.providers.map((p) => [p.type, p]));
+  const indexes = new Map<string, Index>();
+  const manifest = new Map<string, IndexManifest>();
+  const runExclusive = createSerialiser();
+  let closed = false;
+
+  await db.exec(
+    `CREATE TABLE IF NOT EXISTS ${MANIFEST_TABLE} (name TEXT PRIMARY KEY, config TEXT NOT NULL)`,
+  );
+  for (const row of await db.query<{ name: string; config: string }>(
+    `SELECT name, config FROM ${MANIFEST_TABLE}`,
+  )) {
+    manifest.set(row.name, JSON.parse(row.config) as IndexManifest);
+  }
+
+  const ensureOpen = () => {
+    if (closed) throw new Error("Indexer is closed");
+  };
+
+  const contextFor = (name: string, sub: string, blockIds: BlockIds): SqliteModalityContext => ({
+    db,
+    prefix: `${indexPrefix(name)}${sanitizePrefix(sub)}_`,
+    blockIds,
+  });
+
+  async function writeManifest(name: string, entry: IndexManifest): Promise<void> {
+    await db.query(
+      `INSERT INTO ${MANIFEST_TABLE} (name, config) VALUES (?, ?) ON CONFLICT (name) DO UPDATE SET config = excluded.config`,
+      [name, JSON.stringify(entry)],
+    );
+    manifest.set(name, entry);
+  }
+
+  async function dropIndexTables(name: string, subIndexes: Record<string, SubSpec>): Promise<void> {
+    const blockIds = await openBlockIds(db, `${indexPrefix(name)}blocks`);
+    for (const [sub, spec] of Object.entries(subIndexes)) {
+      await providers.get(spec.type)?.drop(contextFor(name, sub, blockIds));
+    }
+    await db.exec(`DROP TABLE IF EXISTS ${blockIds.table}`);
+    await db.query(`DELETE FROM ${MANIFEST_TABLE} WHERE name = ?`, [name]);
+    manifest.delete(name);
+  }
+
+  async function openIndex(
+    name: string,
+    subIndexes: Record<string, SubSpec>,
+    options?: GetIndexOptions,
+  ): Promise<{ index: Index; effective: Record<string, SubSpec> }> {
+    const onMissing = options?.onMissingProvider ?? "throw";
+    const blockIds = await openBlockIds(db, `${indexPrefix(name)}blocks`);
+    const bindings: AnySubIndexBinding[] = [];
+    const effective: Record<string, SubSpec> = {};
+
+    for (const [sub, saved] of Object.entries(subIndexes)) {
+      const action = options?.subIndexes?.[sub];
+      if (action && "skip" in action && action.skip === true) {
+        effective[sub] = saved;
+        continue;
+      }
+      const ctx = contextFor(name, sub, blockIds);
+      const spec = action && !("skip" in action) ? (action as SubSpec) : saved;
+      const provider = providers.get(spec.type);
+      if (provider && spec !== saved) await providers.get(saved.type)?.drop(ctx);
+      if (!provider) {
+        if (onMissing === "throw") {
+          throw new Error(
+            `Cannot load index: sub-index "${sub}" requires modality "${spec.type}" but only [${[
+              ...providers.keys(),
+            ]
+              .map((t) => `"${t}"`)
+              .join(", ")}] are registered.`,
+          );
+        }
+        const g = globalThis as { console?: { warn(...args: unknown[]): void } };
+        g.console?.warn(`Sub-index "${sub}" (type "${spec.type}") has no provider; skipping.`);
+        effective[sub] = saved;
+        continue;
+      }
+      const { type, ...config } = spec;
+      bindings.push({ name: sub, type, config, index: await provider.open(ctx, config) });
+      effective[sub] = spec;
+    }
+
+    const index = createCompositeIndex({
+      name,
+      bindings,
+      onDeleteIndex: async () => {
+        // Bound sub-indexes dropped themselves; skipped ones still own tables.
+        for (const [sub, spec] of Object.entries(manifest.get(name)?.subIndexes ?? {})) {
+          await providers.get(spec.type)?.drop(contextFor(name, sub, blockIds));
+        }
+        await db.exec(`DROP TABLE IF EXISTS ${blockIds.table}`);
+        await db.query(`DELETE FROM ${MANIFEST_TABLE} WHERE name = ?`, [name]);
+        manifest.delete(name);
+        indexes.delete(name);
+      },
+    });
+    return { index, effective };
+  }
+
+  return {
+    async getIndexNames(): Promise<IndexInfo[]> {
+      ensureOpen();
+      return [...manifest.keys()].map((name) => ({ name }));
+    },
+
+    createIndex(params: CreateIndexParams): Promise<Index> {
+      return runExclusive(async () => {
+        ensureOpen();
+        const { name, subIndexes, overwrite, metadata } = params;
+        if (!subIndexes || Object.keys(subIndexes).length === 0) {
+          throw new Error("Cannot create index without any subIndexes");
+        }
+        const existing = manifest.get(name);
+        if (existing || indexes.has(name)) {
+          if (!overwrite) throw new Error(`Index "${name}" already exists`);
+          await indexes
+            .get(name)
+            ?.close()
+            .catch(() => undefined);
+          indexes.delete(name);
+          await dropIndexTables(name, existing?.subIndexes ?? {});
+        }
+        const { index, effective } = await openIndex(name, subIndexes);
+        await writeManifest(name, { subIndexes: effective });
+        if (metadata !== undefined) (index as { metadata?: unknown }).metadata = metadata;
+        indexes.set(name, index);
+        return index;
+      });
+    },
+
+    getIndex(name: string, options?: GetIndexOptions): Promise<Index | null> {
+      // Serialised with createIndex so concurrent first opens open once
+      // (a second reinit would otherwise drop tables the first just wrote).
+      return runExclusive(async () => {
+        ensureOpen();
+        const cached = indexes.get(name);
+        if (cached) return cached;
+        const entry = manifest.get(name);
+        if (!entry) return null;
+        const { index, effective } = await openIndex(name, entry.subIndexes, options);
+        if (JSON.stringify(effective) !== JSON.stringify(entry.subIndexes)) {
+          await writeManifest(name, { subIndexes: effective });
+        }
+        indexes.set(name, index);
+        return index;
+      });
+    },
+
+    async hasIndex(name: string): Promise<boolean> {
+      ensureOpen();
+      return manifest.has(name);
+    },
+
+    async deleteIndex(name: string): Promise<void> {
+      ensureOpen();
+      const live = indexes.get(name);
+      if (live) {
+        await live.deleteIndex();
+        return;
+      }
+      const entry = manifest.get(name);
+      if (entry) await dropIndexTables(name, entry.subIndexes);
+    },
+
+    async flush(): Promise<void> {
+      ensureOpen();
+      for (const index of indexes.values()) await index.flush();
+    },
+
+    async close(): Promise<void> {
+      if (closed) return;
+      closed = true;
+      for (const index of indexes.values()) await index.close().catch(() => undefined);
+      indexes.clear();
+    },
+  } satisfies Indexer;
+}

package/src/enumeration.ts

@@ -0,0 +1,54 @@
+import type { Db } from "@statewalker/db-api";
+import type { BlockReference, DocumentPath } from "@statewalker/indexer-api";
+import type { BlockIds } from "./block-ids.js";
+import { pathPrefixSql } from "./path-sql.js";
+
+export interface BlockEntry extends BlockReference {
+  id: number;
+}
+
+/** `SearchIndex` enumeration over a sub-index's member ids joined with the blocks table. */
+export interface Enumeration {
+  size(prefix?: DocumentPath): Promise<number>;
+  entries(prefix?: DocumentPath): Promise<BlockEntry[]>;
+  paths(prefix?: DocumentPath): AsyncGenerator<DocumentPath>;
+  refs(prefix?: DocumentPath): AsyncGenerator<BlockReference>;
+}
+
+/** `memberIdsSql` is a `SELECT … AS id` listing the sub-index's ids, e.g. `SELECT rowid AS id FROM t`. */
+export function newEnumeration(db: Db, blockIds: BlockIds, memberIdsSql: string): Enumeration {
+  const from = (prefix?: DocumentPath) => {
+    const scope = pathPrefixSql("b.path", prefix ? [prefix] : []);
+    return {
+      sql: `FROM (${memberIdsSql}) m JOIN ${blockIds.table} b ON b.id = m.id WHERE ${scope.sql}`,
+      params: scope.params,
+    };
+  };
+  return {
+    async size(prefix) {
+      const f = from(prefix);
+      const rows = await db.query<{ n: number }>(`SELECT COUNT(*) AS n ${f.sql}`, f.params);
+      return Number(rows[0]?.n ?? 0);
+    },
+    async entries(prefix) {
+      const f = from(prefix);
+      const rows = await db.query<{ id: number; path: string; block_id: string }>(
+        `SELECT b.id, b.path, b.block_id ${f.sql} ORDER BY b.id`,
+        f.params,
+      );
+      return rows.map((r) => ({
+        id: Number(r.id),
+        path: r.path as DocumentPath,
+        blockId: r.block_id,
+      }));
+    },
+    async *paths(prefix) {
+      const f = from(prefix);
+      const rows = await db.query<{ path: string }>(`SELECT DISTINCT b.path ${f.sql}`, f.params);
+      for (const r of rows) yield r.path as DocumentPath;
+    },
+    async *refs(prefix) {
+      for (const e of await this.entries(prefix)) yield { path: e.path, blockId: e.blockId };
+    },
+  };
+}

package/src/fts-provider.ts

@@ -0,0 +1,170 @@
+import { inTransaction } from "@statewalker/db-sqlite";
+import type { DocumentPath, Metadata, PathSelector } from "@statewalker/indexer-api";
+import { toAsyncIterable } from "@statewalker/indexer-core";
+import {
+  FULL_TEXT_TYPE,
+  type FullTextBlock,
+  type FullTextConfig,
+  type FullTextIndex,
+  type FulltextQuery,
+  type FulltextResult,
+} from "@statewalker/indexer-fulltext";
+import { newEnumeration } from "./enumeration.js";
+import { pathPrefixSql } from "./path-sql.js";
+import type { SqliteModalityProvider } from "./types.js";
+
+/** `en` gets the Porter stemmer; any other language (known or not) gets plain `unicode61`. */
+function tokenizerFor(language: string): string {
+  return language === "en"
+    ? "porter unicode61 remove_diacritics 2"
+    : "unicode61 remove_diacritics 2";
+}
+
+/**
+ * One FTS5 MATCH expression per query string: every word with a letter or a
+ * digit, double-quoted (so `AND`, `*`, `NEAR(` are plain words), OR-joined so
+ * partial matches are returned. `null` when nothing is searchable.
+ */
+export function toMatchExpression(query: string): string | null {
+  const words = query
+    .split(/\s+/)
+    .filter((w) => /[\p{L}\p{N}]/u.test(w))
+    .map((w) => `"${w.replaceAll('"', '""')}"`);
+  return words.length > 0 ? words.join(" OR ") : null;
+}
+
+export function newSqliteFullTextProvider(): SqliteModalityProvider<FullTextConfig, FullTextIndex> {
+  return {
+    type: FULL_TEXT_TYPE,
+
+    async drop({ db, prefix }) {
+      await db.exec(`DROP TABLE IF EXISTS ${prefix}fts`);
+    },
+
+    async open({ db, prefix, blockIds }, config) {
+      const table = `${prefix}fts`;
+      const blocks = blockIds.table;
+      await db.exec(
+        `CREATE VIRTUAL TABLE IF NOT EXISTS ${table} USING fts5(content, metadata UNINDEXED, tokenize='${tokenizerFor(config.language)}')`,
+      );
+      const list = newEnumeration(db, blockIds, `SELECT rowid AS id FROM ${table}`);
+      let closed = false;
+      const ensureOpen = () => {
+        if (closed) throw new Error("FullTextIndex is closed");
+      };
+      const collectSelectors = async (selectors: PathSelector[] | AsyncIterable<PathSelector>) => {
+        const all: PathSelector[] = [];
+        for await (const s of toAsyncIterable(selectors)) all.push(s);
+        return all;
+      };
+
+      const index: FullTextIndex = {
+        async getIndexInfo() {
+          return { language: config.language, metadata: config.metadata };
+        },
+
+        async *search(params: FulltextQuery): AsyncGenerator<FulltextResult> {
+          ensureOpen();
+          const topK = params.topK ?? 100;
+          const scope = pathPrefixSql("b.path", params.paths ?? []);
+          // Several queries accumulate (SUM): a block matching more of them ranks higher.
+          const merged = new Map<number, { score: number; best: number; snippet: string }>();
+          for (const query of params.queries ?? []) {
+            const match = toMatchExpression(query);
+            if (!match) continue;
+            const rows = await db.query<{ id: number; score: number; snippet: string }>(
+              `SELECT ${table}.rowid AS id, -bm25(${table}) AS score, snippet(${table}, 0, '', '', '…', 16) AS snippet FROM ${table} JOIN ${blocks} b ON b.id = ${table}.rowid WHERE ${table} MATCH ? AND ${scope.sql} ORDER BY score DESC LIMIT ?`,
+              [match, ...scope.params, topK],
+            );
+            for (const r of rows) {
+              const id = Number(r.id);
+              const prev = merged.get(id);
+              if (!prev) merged.set(id, { score: r.score, best: r.score, snippet: r.snippet });
+              else {
+                prev.score += r.score;
+                if (r.score > prev.best) Object.assign(prev, { best: r.score, snippet: r.snippet });
+              }
+            }
+          }
+          const top = [...merged.entries()].sort((a, b) => b[1].score - a[1].score).slice(0, topK);
+          const refs = await blockIds.refs(
+            db,
+            top.map(([id]) => id),
+          );
+          for (const [id, hit] of top) {
+            const ref = refs.get(id);
+            if (ref) yield { ...ref, score: hit.score, snippet: hit.snippet };
+          }
+        },
+
+        async addDocument(blocksIn: FullTextBlock[]) {
+          ensureOpen();
+          if (blocksIn.length === 0) return;
+          await inTransaction(db, async (tx) => {
+            const ids = await blockIds.ensure(tx, blocksIn);
+            for (const [i, id] of ids.entries()) {
+              const block = blocksIn[i] as FullTextBlock;
+              // FTS5 has no UPSERT: delete then insert, atomically inside the transaction.
+              await tx.query(`DELETE FROM ${table} WHERE rowid = ?`, [id]);
+              await tx.query(`INSERT INTO ${table} (rowid, content, metadata) VALUES (?, ?, ?)`, [
+                id,
+                block.content,
+                block.metadata ? JSON.stringify(block.metadata) : null,
+              ]);
+            }
+          });
+        },
+
+        async addDocuments(batches) {
+          for await (const batch of batches) await this.addDocument(batch);
+        },
+
+        async deleteDocuments(selectors) {
+          ensureOpen();
+          const sels = await collectSelectors(selectors);
+          await inTransaction(db, async (tx) => {
+            const ids = await blockIds.select(tx, sels);
+            await tx.query(`DELETE FROM ${table} WHERE rowid IN (SELECT value FROM json_each(?))`, [
+              JSON.stringify(ids),
+            ]);
+          });
+        },
+
+        getSize: (p?: DocumentPath) => list.size(p),
+        getDocumentPaths: (p?: DocumentPath) => list.paths(p),
+        getDocumentBlocksRefs: (p?: DocumentPath) => list.refs(p),
+
+        async *getDocumentsBlocks(p?: DocumentPath): AsyncGenerator<FullTextBlock> {
+          const scope = pathPrefixSql("b.path", p ? [p] : []);
+          const rows = await db.query<{
+            path: string;
+            block_id: string;
+            content: string;
+            metadata: string | null;
+          }>(
+            `SELECT b.path, b.block_id, f.content, f.metadata FROM ${table} f JOIN ${blocks} b ON b.id = f.rowid WHERE ${scope.sql} ORDER BY b.id`,
+            scope.params,
+          );
+          for (const r of rows) {
+            yield {
+              path: r.path as DocumentPath,
+              blockId: r.block_id,
+              content: r.content,
+              ...(r.metadata ? { metadata: JSON.parse(r.metadata) as Metadata } : {}),
+            };
+          }
+        },
+
+        async close() {
+          closed = true;
+        },
+        async flush() {},
+        async deleteIndex() {
+          closed = true;
+          await db.exec(`DROP TABLE IF EXISTS ${table}`);
+        },
+      };
+      return index;
+    },
+  };
+}

package/src/index.ts

@@ -0,0 +1,9 @@
+export type { BlockIds } from "./block-ids.js";
+export { openBlockIds } from "./block-ids.js";
+export { createSqliteIndexer, type SqliteIndexerOptions } from "./create-sqlite-indexer.js";
+export { type BlockEntry, type Enumeration, newEnumeration } from "./enumeration.js";
+export { newSqliteFullTextProvider } from "./fts-provider.js";
+export { newSqliteNgramProvider } from "./ngram-provider.js";
+export { pathPrefixSql } from "./path-sql.js";
+export type { SqliteModalityContext, SqliteModalityProvider } from "./types.js";
+export { newSqliteVectorProvider } from "./vector-provider.js";