@mirk/store 0.4.2 → 0.6.1

package/README.md

@@ -24,11 +24,13 @@ npm install sqlite-vec
 | `@mirk/store` | the ports + their in-memory references + `toAsync` + cosine helpers | none |
 | `@mirk/store/kv` | `SyncStore` port (key-value + collections), `InMemoryKv`, `toAsync` | none |
 | `@mirk/store/vector` | `VectorStore` port, `InMemoryVectorStore`, cosine helpers | none |
-| `@mirk/store/sqlite` | the SQLite **source adapter** — one connection, `.kv` + `.vector` facets | `better-sqlite3` (peer), `sqlite-vec` (optional peer) |
+| `@mirk/store/search` | `SearchStore` port, `InMemorySearchStore`, BM25-style keyword search | none |
+| `@mirk/store/graph` | graph helpers over the collection port (`neighbors`, `traverse`, `traverseFrontierBatched`) | none |
+| `@mirk/store/sqlite` | the SQLite **source adapter** — one connection, `.kv` + `.vector` + `.search` facets | `better-sqlite3` (peer), `sqlite-vec` (optional peer) |
 
 Source adapters are reached **only** through their own subpath (e.g. `/sqlite`) — the root and the
-port subpaths never re-export them, so importing `@mirk/store`, `/kv`, or `/vector` never drags a
-native binding into a consumer bundle.
+port subpaths never re-export them, so importing `@mirk/store`, `/kv`, `/vector`, `/search`, or
+`/graph` never drags a native binding into a consumer bundle.
 
 ## Quickstart — zero native deps
 
@@ -60,19 +62,51 @@ kv.count("posts");                               // 1
 kv.remove("posts", "p1");
 ```
 
+## Full-text search
+
+`SearchStore` indexes documents by id and returns BM25-ranked keyword matches. Use `text` for the
+single-field shorthand or `fields` for named columns with query-time weighting:
+
+```ts
+import { InMemorySearchStore } from "@mirk/store/search";
+
+const search = new InMemorySearchStore();
+search.index("pages", { id: "a", fields: { title: "Opal guide", body: "plain body" } });
+search.index("pages", { id: "b", fields: { title: "plain title", body: "Opal guide" } });
+search.search("pages", "opal", { fieldWeights: { title: 4, body: 1 } }); // [a, b]
+```
+
+The first indexed document fixes a collection's field schema; later documents must use the same
+field names. `text` and `fields: { text }` are the same single-field schema for backwards
+compatibility.
+
+## Graph helpers
+
+`@mirk/store/graph` stores edges as ordinary collection records and traverses them through the
+existing collection port. Policy stays caller-owned through `StoreFilter`.
+
+```ts
+import { traverse } from "@mirk/store/graph";
+
+const hits = traverse(kv, { start: "node:a", depth: 2, direction: "out" });
+```
+
 ## SQLite adapter — one connection, many capabilities
 
-`SqliteAdapter` opens a single `better-sqlite3` database and exposes a `.kv` facet (a `SyncStore`)
-and a `.vector` facet (a `VectorStore`) over it:
+`SqliteAdapter` opens a single `better-sqlite3` database and exposes `.kv` (`SyncStore`), `.vector`
+(`VectorStore`), and `.search` (`SearchStore`) facets over it:
 
 ```ts
 import { SqliteAdapter } from "@mirk/store/sqlite";
 
-// `dimensions` is required to use the .vector facet; .kv works without it.
-const db = new SqliteAdapter({ path: "data.db", dimensions: 768 });
+// .kv and .search work immediately; vector dimensions infer on first write.
+const db = new SqliteAdapter({ path: "data.db" });
 
 db.kv.set("user:1", { name: "Ada" });
 
+db.search.index("pages", { id: "intro", fields: { title: "Intro", body: "hello world" } });
+db.search.search("pages", "hello", { fieldWeights: { title: 4, body: 1 } });
+
 const embedding = new Float32Array(768); // your real embedding here
 const query = new Float32Array(768);
 db.vector.upsert("docs", { id: "a", vector: embedding });
@@ -87,7 +121,7 @@ db.close();
 |---|---|---|
 | `path` | `string` | DB file path, or `":memory:"`. |
 | `db` | `Database` | Reuse an existing `better-sqlite3` connection instead of opening one. |
-| `dimensions` | `number` | Embedding dimensionality. Required before using `.vector`; persisted and enforced on reopen. |
+| `dimensions` | `number` | Optional embedding dimensionality. If omitted, inferred and persisted from the first vector `upsert` / `upsertMany`; `search` still requires known dimensions. |
 | `forceJsCosine` | `boolean` | Pin the exact JS-cosine path even when `sqlite-vec` is installed (mainly for tests). |
 
 Vectors (`Vector` is a `Float32Array`) are stored as little-endian float32 BLOBs and ranked by

package/dist/adapters/sqlite.d.ts

@@ -1,13 +1,15 @@
 import Database from 'better-sqlite3';
-import { b as SyncStore } from '../types-DyQLNtxa.js';
-import { d as VectorStore } from '../types-BqSZEMAB.js';
+import { c as SyncStore } from '../types-DHLdLZ_W.js';
+import { d as VectorStore } from '../types-B0XrD10b.js';
+import { c as SearchStore } from '../types-BLZTMsQO.js';
 
 interface SqliteAdapterOptions {
     /** Path to the SQLite database file. Use ":memory:" for in-memory. */
     path: string;
     /** Existing better-sqlite3 instance to reuse (shares one connection). */
     db?: Database.Database;
-    /** Embedding dimensions. Required to use the `.vector` facet; KV works without it. */
+    /** Embedding dimensions. Optional: when omitted, `.vector` persists the
+     *  dimensions from the first upsert/upsertMany call. KV/search work without it. */
     dimensions?: number;
     /** Force the exact JS-cosine search path even when sqlite-vec is installed.
      *  Mainly for parity testing; production should leave this off. */
@@ -19,6 +21,7 @@ declare class SqliteAdapter {
     private readonly db;
     readonly kv: SyncStore;
     readonly vector: VectorStore;
+    readonly search: SearchStore;
     constructor(opts: SqliteAdapterOptions);
     /** Close the underlying connection (shared by both facets). */
     close(): void;

package/dist/adapters/sqlite.js

@@ -1,3 +1,18 @@
+import {
+  DEFAULT_SEARCH_FIELD,
+  assertSameSearchFields,
+  assertValidFieldWeightValues,
+  fieldWeightsFor,
+  normalizeSearchDocument,
+  sanitizeFtsQuery
+} from "../chunk-N27Y55CA.js";
+import {
+  buildLimitOffset,
+  buildOrderBy,
+  buildWhereClause,
+  hashName,
+  jsonPath
+} from "../chunk-DP4D7CJY.js";
 import {
   assertDimensions,
   bufferToVector,
@@ -5,6 +20,9 @@ import {
   isUsableVector,
   vectorToBuffer
 } from "../chunk-BXM3YDOC.js";
+import {
+  matchesWhere
+} from "../chunk-KPMRRYTL.js";
 
 // src/adapters/sqlite.ts
 import Database from "better-sqlite3";
@@ -26,10 +44,43 @@ function tryLoadSqliteVec(db) {
     return false;
   }
 }
+function assertPositiveDimensions(dimensions) {
+  if (!Number.isInteger(dimensions) || dimensions <= 0) {
+    throw new Error(`Vector dimensions must be a positive integer; got ${dimensions}.`);
+  }
+}
+function sqlParam(value) {
+  if (value === null) return null;
+  if (typeof value === "boolean") return value ? 1 : 0;
+  if (typeof value === "string" || typeof value === "number" || typeof value === "bigint") {
+    return value;
+  }
+  throw new Error("Store IN queries only support JSON scalar values.");
+}
+function buildJsonInWhere(field, values, hasPriorWhere) {
+  const path = jsonPath(field);
+  const params = [];
+  const nonNull = values.filter((value) => value !== null).map(sqlParam);
+  const hasNull = values.some((value) => value === null);
+  const parts = [];
+  if (nonNull.length > 0) {
+    parts.push(`json_extract(data, ?) IN (${nonNull.map(() => "?").join(", ")})`);
+    params.push(path, ...nonNull);
+  }
+  if (hasNull) {
+    parts.push(`json_type(data, ?) = 'null'`);
+    params.push(path);
+  }
+  return {
+    clause: `${hasPriorWhere ? " AND" : " WHERE"} (${parts.join(" OR ")})`,
+    params
+  };
+}
 var SqliteAdapter = class {
   db;
   kv;
   vector;
+  search;
   constructor(opts) {
     const ownsDb = opts.db === void 0;
     this.db = opts.db ?? new Database(opts.path);
@@ -37,6 +88,7 @@ var SqliteAdapter = class {
       this.db.pragma("journal_mode = WAL");
       this.kv = new SqliteKvFacet(this.db);
       this.vector = new SqliteVectorFacet(this.db, opts.path, opts.dimensions, opts.forceJsCosine);
+      this.search = new SqliteSearchFacet(this.db);
     } catch (err) {
       if (ownsDb) {
         try {
@@ -122,6 +174,17 @@ var SqliteKvFacet = class {
     const rows = this.db.prepare(sql).all(...where.params, ...orderBy.params);
     return rows.map((r) => JSON.parse(r.data));
   }
+  listWhereIn(collection, field, values, filter) {
+    if (values.length === 0) return [];
+    const table = this.ensureTable(collection);
+    const where = buildWhereClause(filter);
+    const inWhere = buildJsonInWhere(field, values, where.clause.length > 0);
+    const orderBy = buildOrderBy(filter);
+    const limitOffset = buildLimitOffset(filter);
+    const sql = `SELECT data FROM ${table}${where.clause}${inWhere.clause}${orderBy.clause}${limitOffset}`;
+    const rows = this.db.prepare(sql).all(...where.params, ...inWhere.params, ...orderBy.params);
+    return rows.map((r) => JSON.parse(r.data));
+  }
   getById(collection, id) {
     const table = this.ensureTable(collection);
     const row = this.db.prepare(`SELECT data FROM ${table} WHERE id = ?`).get(id);
@@ -148,8 +211,10 @@ var SqliteKvFacet = class {
   }
 };
 var SqliteVectorFacet = class {
-  constructor(db, path, dimensions, forceJsCosine) {
+  constructor(db, path, dimensions, forceJsCosine = false) {
     this.db = db;
+    this.path = path;
+    this.forceJsCosine = forceJsCosine;
     this.db.exec(
       `CREATE TABLE IF NOT EXISTS vectors (
          collection TEXT NOT NULL,
@@ -169,31 +234,51 @@ var SqliteVectorFacet = class {
           `Vector store at ${path} was created with ${this.dimensions} dimensions, opened with ${dimensions}.`
         );
       }
+      this.refreshVectorMeta();
     } else if (dimensions !== void 0) {
-      this.dimensions = dimensions;
-      this.db.prepare(`INSERT INTO _vec_meta (key, value) VALUES ('dimensions', ?)`).run(String(dimensions));
-    } else {
-      this.dimensions = -1;
+      this.initializeDims(dimensions);
     }
-    this.accelerated = !forceJsCosine && this.dimensions >= 0 && tryLoadSqliteVec(this.db);
-    this.meta = {
-      backend: "sqlite",
-      dimensions: Math.max(this.dimensions, 0),
-      accelerated: this.accelerated
-    };
   }
   db;
-  meta;
-  dimensions;
+  path;
+  forceJsCosine;
+  meta = { backend: "sqlite", dimensions: 0, accelerated: false };
+  dimensions = -1;
   /** True when sqlite-vec loaded and the vec0 acceleration path is live. */
-  accelerated;
+  accelerated = false;
   vecTablesEnsured = /* @__PURE__ */ new Set();
-  requireDims(v) {
+  initializeDims(dimensions) {
+    assertPositiveDimensions(dimensions);
+    if (this.dimensions >= 0) {
+      if (dimensions !== this.dimensions) {
+        throw new Error(
+          `Vector store at ${this.path} was created with ${this.dimensions} dimensions, opened with ${dimensions}.`
+        );
+      }
+      return;
+    }
+    this.dimensions = dimensions;
+    this.db.prepare(
+      `INSERT INTO _vec_meta (key, value) VALUES ('dimensions', ?)
+         ON CONFLICT(key) DO UPDATE SET value = excluded.value`
+    ).run(String(dimensions));
+    this.refreshVectorMeta();
+  }
+  refreshVectorMeta() {
+    this.accelerated = !this.forceJsCosine && this.dimensions >= 0 && tryLoadSqliteVec(this.db);
+    this.meta.dimensions = Math.max(this.dimensions, 0);
+    this.meta.accelerated = this.accelerated;
+  }
+  requireKnownDims(v) {
     if (this.dimensions < 0) {
-      throw new Error("SqliteAdapter.vector requires `dimensions` \u2014 pass { dimensions } when opening.");
+      throw new Error("SqliteAdapter.vector has no dimensions yet \u2014 pass { dimensions } when opening or upsert a vector first.");
     }
     assertDimensions(v, this.dimensions);
   }
+  ensureDimsForWrite(v) {
+    if (this.dimensions < 0) this.initializeDims(v.length);
+    assertDimensions(v, this.dimensions);
+  }
   // ── vec0 acceleration helpers ───────────────────────────────────────────
   vecTableName(collection) {
     return `vectors_vec_${collection.replace(/[^a-zA-Z0-9_]/g, "_")}_${hashName(collection)}`;
@@ -233,7 +318,7 @@ var SqliteVectorFacet = class {
     }
   }
   upsert(collection, doc) {
-    this.requireDims(doc.vector);
+    this.ensureDimsForWrite(doc.vector);
     const write = this.db.transaction(() => {
       this.db.prepare(
         `INSERT INTO vectors(collection, id, vec, metadata) VALUES (?, ?, ?, ?)
@@ -249,6 +334,14 @@ var SqliteVectorFacet = class {
     write();
   }
   upsertMany(collection, docs) {
+    const first = docs[0];
+    if (!first) return;
+    const dimensions = this.dimensions >= 0 ? this.dimensions : first.vector.length;
+    assertPositiveDimensions(dimensions);
+    for (const doc of docs) {
+      assertDimensions(doc.vector, dimensions);
+    }
+    if (this.dimensions < 0) this.initializeDims(dimensions);
     const tx = this.db.transaction((items) => {
       for (const doc of items) this.upsert(collection, doc);
     });
@@ -263,6 +356,9 @@ var SqliteVectorFacet = class {
       metadata: row.metadata === null ? void 0 : JSON.parse(row.metadata)
     };
   }
+  has(collection, id) {
+    return this.db.prepare(`SELECT 1 FROM vectors WHERE collection = ? AND id = ?`).get(collection, id) !== void 0;
+  }
   remove(collection, id) {
     if (this.accelerated) {
       const row = this.db.prepare(`SELECT rowid FROM vectors WHERE collection = ? AND id = ?`).get(collection, id);
@@ -277,16 +373,17 @@ var SqliteVectorFacet = class {
     return row.n;
   }
   search(collection, query, opts) {
-    this.requireDims(query);
+    this.requireKnownDims(query);
     const topK = opts?.topK ?? 10;
     const minScore = opts?.minScore;
-    if (this.accelerated && isUsableVector(query)) {
+    const hasFilters = !!(opts?.where || opts?.whereNot);
+    if (this.accelerated && isUsableVector(query) && !hasFilters) {
       try {
         return this.searchVec(collection, query, topK, minScore);
       } catch {
       }
     }
-    return this.searchJs(collection, query, topK, minScore);
+    return this.searchJs(collection, query, topK, minScore, opts?.where, opts?.whereNot);
   }
   searchVec(collection, query, topK, minScore) {
     const table = this.ensureVecTable(collection);
@@ -310,75 +407,174 @@ var SqliteVectorFacet = class {
     out.sort((a, b) => b.score - a.score || a.id.localeCompare(b.id));
     return out;
   }
-  searchJs(collection, query, topK, minScore) {
+  searchJs(collection, query, topK, minScore, where, whereNot) {
     const rows = this.db.prepare(`SELECT id, vec, metadata FROM vectors WHERE collection = ?`).all(collection);
     const scored = [];
     for (const row of rows) {
+      const meta = row.metadata === null ? void 0 : JSON.parse(row.metadata);
+      if (where && !matchesWhere(meta, where)) continue;
+      if (whereNot && matchesWhere(meta, whereNot)) continue;
       const vec = bufferToVector(row.vec);
       if (!isUsableVector(vec)) continue;
       const score = cosineSimilarity(query, vec);
       if (!Number.isFinite(score)) continue;
       if (minScore !== void 0 && score < minScore) continue;
-      scored.push({
-        id: row.id,
-        score,
-        metadata: row.metadata === null ? void 0 : JSON.parse(row.metadata)
-      });
+      scored.push({ id: row.id, score, metadata: meta });
     }
     scored.sort((a, b) => b.score - a.score || a.id.localeCompare(b.id));
     return scored.slice(0, topK);
   }
 };
-function jsonPath(field) {
-  return `$."${field.replace(/"/g, '""')}"`;
+function searchColumnName(field, index) {
+  if (field === DEFAULT_SEARCH_FIELD) return DEFAULT_SEARCH_FIELD;
+  return `f${index}_${hashName(field)}`;
+}
+function searchSchema(fields) {
+  return { fields: [...fields], columns: fields.map(searchColumnName) };
 }
-function buildWhereClause(filter) {
-  if (!filter?.where || Object.keys(filter.where).length === 0) {
-    return { clause: "", params: [] };
+function quoteSqlIdent(identifier) {
+  return `"${identifier.replace(/"/g, '""')}"`;
+}
+function searchFieldDefs(schema) {
+  return schema.columns.map((column) => `${quoteSqlIdent(column)} TEXT NOT NULL`).join(",\n        ");
+}
+function rowColumnRefs(prefix, schema) {
+  return schema.columns.map((column) => `${prefix}.${quoteSqlIdent(column)}`).join(", ");
+}
+var SqliteSearchFacet = class {
+  constructor(db) {
+    this.db = db;
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS ${this.schemaTable} (
+        collection TEXT PRIMARY KEY,
+        fields_json TEXT NOT NULL
+      );
+    `);
   }
-  const conditions = [];
-  const params = [];
-  for (const [key, value] of Object.entries(filter.where)) {
-    const path = jsonPath(key);
-    if (value === null) {
-      conditions.push(`json_type(data, ?) = 'null'`);
-      params.push(path);
-    } else {
-      const bound = typeof value === "boolean" ? value ? 1 : 0 : value;
-      conditions.push(`json_extract(data, ?) = ?`);
-      params.push(path, bound);
+  db;
+  ensured = /* @__PURE__ */ new Set();
+  schemaTable = "_mirk_search_schema";
+  baseTable(collection) {
+    return `search_docs_${collection.replace(/[^a-zA-Z0-9_]/g, "_")}_${hashName(collection)}`;
+  }
+  ftsTable(collection) {
+    return `search_fts_${collection.replace(/[^a-zA-Z0-9_]/g, "_")}_${hashName(collection)}`;
+  }
+  tableExists(table) {
+    return this.db.prepare("SELECT 1 AS ok FROM sqlite_master WHERE type IN ('table', 'view') AND name = ?").get(table) !== void 0;
+  }
+  loadSchema(collection) {
+    const row = this.db.prepare(`SELECT fields_json FROM ${this.schemaTable} WHERE collection = ?`).get(collection);
+    if (row) {
+      const fields2 = JSON.parse(row.fields_json);
+      return searchSchema(fields2);
+    }
+    const docs = this.baseTable(collection);
+    if (!this.tableExists(docs)) return void 0;
+    const pragma = this.db.prepare(`PRAGMA table_info(${quoteSqlIdent(docs)})`).all();
+    if (!pragma.some((col) => col.name === DEFAULT_SEARCH_FIELD)) return void 0;
+    const fields = [DEFAULT_SEARCH_FIELD];
+    this.db.prepare(`INSERT OR IGNORE INTO ${this.schemaTable}(collection, fields_json) VALUES (?, ?)`).run(collection, JSON.stringify(fields));
+    return searchSchema(fields);
+  }
+  schemaForIndex(collection, normalized) {
+    const existing = this.loadSchema(collection);
+    if (existing) {
+      assertSameSearchFields(existing.fields, normalized.names, collection);
+      return existing;
     }
+    const fields = [...normalized.names];
+    this.db.prepare(`INSERT INTO ${this.schemaTable}(collection, fields_json) VALUES (?, ?)`).run(collection, JSON.stringify(fields));
+    return searchSchema(fields);
+  }
+  ensure(collection, schema) {
+    const docs = this.baseTable(collection);
+    const fts = this.ftsTable(collection);
+    const key = `${docs}:${schema.fields.join("\0")}`;
+    if (this.ensured.has(key)) return { docs, fts };
+    const qDocs = quoteSqlIdent(docs);
+    const qFts = quoteSqlIdent(fts);
+    const qColumns = schema.columns.map(quoteSqlIdent).join(", ");
+    const newColumns = rowColumnRefs("new", schema);
+    const oldColumns = rowColumnRefs("old", schema);
+    const fieldDefs = searchFieldDefs(schema);
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS ${qDocs} (
+        id TEXT PRIMARY KEY,
+        ${fieldDefs},
+        meta_json TEXT
+      );
+      CREATE VIRTUAL TABLE IF NOT EXISTS ${qFts} USING fts5(
+        ${qColumns}, content='${docs}', content_rowid='rowid', tokenize='unicode61'
+      );
+      CREATE TRIGGER IF NOT EXISTS ${quoteSqlIdent(`${docs}_ai`)} AFTER INSERT ON ${qDocs} BEGIN
+        INSERT INTO ${qFts}(rowid, ${qColumns}) VALUES (new.rowid, ${newColumns});
+      END;
+      CREATE TRIGGER IF NOT EXISTS ${quoteSqlIdent(`${docs}_ad`)} AFTER DELETE ON ${qDocs} BEGIN
+        INSERT INTO ${qFts}(${quoteSqlIdent(fts)}, rowid, ${qColumns}) VALUES('delete', old.rowid, ${oldColumns});
+      END;
+      CREATE TRIGGER IF NOT EXISTS ${quoteSqlIdent(`${docs}_au`)} AFTER UPDATE ON ${qDocs} BEGIN
+        INSERT INTO ${qFts}(${quoteSqlIdent(fts)}, rowid, ${qColumns}) VALUES('delete', old.rowid, ${oldColumns});
+        INSERT INTO ${qFts}(rowid, ${qColumns}) VALUES (new.rowid, ${newColumns});
+      END;
+    `);
+    this.ensured.add(key);
+    return { docs, fts };
+  }
+  index(collection, doc) {
+    const normalized = normalizeSearchDocument(doc);
+    const schema = this.schemaForIndex(collection, normalized);
+    const { docs } = this.ensure(collection, schema);
+    const qDocs = quoteSqlIdent(docs);
+    const qColumns = schema.columns.map(quoteSqlIdent);
+    const insertColumns = ["id", ...schema.columns, "meta_json"].map(quoteSqlIdent).join(", ");
+    const placeholders = Array.from({ length: schema.columns.length + 2 }, () => "?").join(", ");
+    const updateSet = [...qColumns.map((col) => `${col} = excluded.${col}`), "meta_json = excluded.meta_json"].join(", ");
+    const metaJson = doc.meta === void 0 ? null : JSON.stringify(doc.meta);
+    this.db.prepare(
+      `INSERT INTO ${qDocs}(${insertColumns}) VALUES (${placeholders})
+         ON CONFLICT(id) DO UPDATE SET ${updateSet}`
+    ).run(doc.id, ...schema.fields.map((field) => normalized.values[field] ?? ""), metaJson);
   }
-  return { clause: ` WHERE ${conditions.join(" AND ")}`, params };
-}
-function buildOrderBy(filter) {
-  if (!filter?.sortBy) return { clause: "", params: [] };
-  const dir = filter.sortDir === "desc" ? "DESC" : "ASC";
-  const path = jsonPath(filter.sortBy);
-  return {
-    clause: ` ORDER BY json_extract(data, ?) IS NULL, json_extract(data, ?) ${dir}`,
-    params: [path, path]
-  };
-}
-function hashName(s) {
-  let h = 2166136261;
-  for (let i = 0; i < s.length; i++) {
-    h ^= s.charCodeAt(i);
-    h = Math.imul(h, 16777619);
+  indexMany(collection, docs) {
+    const tx = this.db.transaction((items) => {
+      for (const doc of items) this.index(collection, doc);
+    });
+    tx(docs);
   }
-  return (h >>> 0).toString(36);
-}
-function buildLimitOffset(filter) {
-  let sql = "";
-  if (filter?.limit !== void 0) {
-    sql += ` LIMIT ${Math.max(0, Math.floor(filter.limit))}`;
+  remove(collection, id) {
+    const schema = this.loadSchema(collection);
+    if (!schema) return false;
+    const { docs } = this.ensure(collection, schema);
+    return this.db.prepare(`DELETE FROM ${quoteSqlIdent(docs)} WHERE id = ?`).run(id).changes > 0;
   }
-  if (filter?.offset !== void 0 && filter.offset > 0) {
-    if (!sql.includes("LIMIT")) sql += " LIMIT -1";
-    sql += ` OFFSET ${Math.max(0, Math.floor(filter.offset))}`;
+  search(collection, query, opts) {
+    const sanitized = sanitizeFtsQuery(query);
+    assertValidFieldWeightValues(opts?.fieldWeights);
+    if (sanitized.length === 0) return [];
+    const schema = this.loadSchema(collection);
+    if (!schema) return [];
+    const { docs, fts } = this.ensure(collection, schema);
+    const weights = fieldWeightsFor(schema.fields, opts?.fieldWeights);
+    const weightArgs = weights.length > 0 ? `, ${weights.map((weight) => String(weight)).join(", ")}` : "";
+    const rows = this.db.prepare(
+      `SELECT d.id AS id, d.meta_json AS meta_json, bm25(${fts}${weightArgs}) AS bm
+         FROM ${quoteSqlIdent(fts)}
+         JOIN ${quoteSqlIdent(docs)} d ON d.rowid = ${fts}.rowid
+         WHERE ${fts} MATCH ?
+         ORDER BY bm, d.id`
+    ).all(sanitized);
+    const limit = opts?.limit ?? 10;
+    const where = opts?.filter?.where;
+    const out = [];
+    for (const r of rows) {
+      const meta = r.meta_json === null ? {} : JSON.parse(r.meta_json);
+      if (where && !matchesWhere(meta, where)) continue;
+      out.push({ id: r.id, score: -r.bm, meta });
+    }
+    return out.slice(0, limit);
   }
-  return sql;
-}
+};
 export {
   SqliteAdapter
 };

package/dist/chunk-77IIKHQW.js

@@ -0,0 +1,120 @@
+import {
+  assertSameSearchFields,
+  assertValidFieldWeightValues,
+  fieldWeightsFor,
+  normalizeSearchDocument,
+  tokenize
+} from "./chunk-N27Y55CA.js";
+import {
+  matchesWhere
+} from "./chunk-KPMRRYTL.js";
+
+// src/search/memory.ts
+var K1 = 1.2;
+var B = 0.75;
+var InMemorySearchStore = class {
+  collections = /* @__PURE__ */ new Map();
+  index(collection, doc) {
+    const normalized = normalizeSearchDocument(doc);
+    const coll = this.collectionFor(collection, normalized.names);
+    assertSameSearchFields(coll.fields, normalized.names, collection);
+    this.removeFromColl(coll, doc.id);
+    const tfByField = /* @__PURE__ */ new Map();
+    const terms = /* @__PURE__ */ new Set();
+    let dl = 0;
+    for (const field of coll.fields) {
+      const tokens = tokenize(normalized.values[field] ?? "");
+      dl += tokens.length;
+      const tf = /* @__PURE__ */ new Map();
+      for (const token of tokens) {
+        tf.set(token, (tf.get(token) ?? 0) + 1);
+        terms.add(token);
+      }
+      tfByField.set(field, tf);
+    }
+    coll.totalLen += dl;
+    const indexed = {
+      id: doc.id,
+      meta: doc.meta ?? {},
+      tfByField,
+      dl,
+      terms
+    };
+    coll.docs.set(doc.id, indexed);
+    for (const term of terms) coll.df.set(term, (coll.df.get(term) ?? 0) + 1);
+  }
+  indexMany(collection, docs) {
+    for (const doc of docs) this.index(collection, doc);
+  }
+  remove(collection, id) {
+    const coll = this.collections.get(collection);
+    if (!coll) return false;
+    return this.removeFromColl(coll, id);
+  }
+  search(collection, query, opts) {
+    const coll = this.collections.get(collection);
+    const qTokens = tokenize(query);
+    assertValidFieldWeightValues(opts?.fieldWeights);
+    if (!coll || qTokens.length === 0) return [];
+    const limit = opts?.limit ?? 10;
+    const where = opts?.filter?.where;
+    const fieldWeights = fieldWeightsFor(coll.fields, opts?.fieldWeights);
+    const n = coll.docs.size;
+    const scored = [];
+    for (const doc of coll.docs.values()) {
+      if (where && !matchesWhere(doc.meta, where)) continue;
+      let matched = false;
+      let score = 0;
+      const avgdl = n > 0 ? coll.totalLen / n : 0;
+      for (const qt of qTokens) {
+        const df = coll.df.get(qt) ?? 0;
+        if (df === 0) continue;
+        let weightedTf = 0;
+        for (let i = 0; i < coll.fields.length; i++) {
+          const field = coll.fields[i];
+          const tf = doc.tfByField.get(field)?.get(qt) ?? 0;
+          weightedTf += fieldWeights[i] * tf;
+        }
+        if (weightedTf === 0) continue;
+        matched = true;
+        const idf = Math.log((n - df + 0.5) / (df + 0.5));
+        if (idf <= 0) continue;
+        const denom = weightedTf + K1 * (1 - B + B * (avgdl > 0 ? doc.dl / avgdl : 0));
+        score += idf * (weightedTf * (K1 + 1)) / denom;
+      }
+      if (!matched) continue;
+      scored.push({ id: doc.id, score, meta: doc.meta });
+    }
+    scored.sort((a, b) => b.score - a.score || a.id.localeCompare(b.id));
+    return scored.slice(0, limit);
+  }
+  removeFromColl(coll, id) {
+    const doc = coll.docs.get(id);
+    if (!doc) return false;
+    coll.docs.delete(id);
+    coll.totalLen -= doc.dl;
+    for (const term of doc.terms) {
+      const next = (coll.df.get(term) ?? 0) - 1;
+      if (next <= 0) coll.df.delete(term);
+      else coll.df.set(term, next);
+    }
+    return true;
+  }
+  collectionFor(name, fields) {
+    let coll = this.collections.get(name);
+    if (!coll) {
+      coll = {
+        fields: [...fields],
+        docs: /* @__PURE__ */ new Map(),
+        df: /* @__PURE__ */ new Map(),
+        totalLen: 0
+      };
+      this.collections.set(name, coll);
+    }
+    return coll;
+  }
+};
+
+export {
+  InMemorySearchStore
+};