@mirk/store 0.4.2 → 0.6.1

package/dist/{chunk-ZI4JA6IU.js → chunk-DKCPULXT.js}

@@ -1,9 +1,16 @@
 // src/to-async.ts
+function hasListWhereIn(store) {
+  return typeof store.listWhereIn === "function";
+}
 var AsyncStoreAdapter = class {
   constructor(sync) {
     this.sync = sync;
+    if (hasListWhereIn(sync)) {
+      this.listWhereIn = async (collection, field, values, filter) => sync.listWhereIn(collection, field, values, filter);
+    }
   }
   sync;
+  listWhereIn;
   get meta() {
     return this.sync.meta;
   }
@@ -85,6 +92,16 @@ var InMemoryStore = class {
     items = applyFilter(items, filter);
     return items;
   }
+  listWhereIn(collection, field, values, filter) {
+    if (values.length === 0) return [];
+    const set = new Set(values);
+    const col = this.ensureCollection(collection);
+    const items = [...col.values()].filter((item) => {
+      if (typeof item !== "object" || item === null) return false;
+      return set.has(item[field]);
+    });
+    return applyFilter(items, filter);
+  }
   getById(collection, id) {
     const col = this.ensureCollection(collection);
     const item = col.get(id);

package/dist/chunk-DP4D7CJY.js

@@ -0,0 +1,59 @@
+// src/sql.ts
+function jsonPath(field) {
+  return `$."${field.replace(/"/g, '""')}"`;
+}
+function buildWhereClause(filter) {
+  if (!filter?.where || Object.keys(filter.where).length === 0) {
+    return { clause: "", params: [] };
+  }
+  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);
+    }
+  }
+  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 buildLimitOffset(filter) {
+  let sql = "";
+  if (filter?.limit !== void 0) {
+    sql += ` LIMIT ${Math.max(0, Math.floor(filter.limit))}`;
+  }
+  if (filter?.offset !== void 0 && filter.offset > 0) {
+    if (!sql.includes("LIMIT")) sql += " LIMIT -1";
+    sql += ` OFFSET ${Math.max(0, Math.floor(filter.offset))}`;
+  }
+  return sql;
+}
+function hashName(s) {
+  let h = 2166136261;
+  for (let i = 0; i < s.length; i++) {
+    h ^= s.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return (h >>> 0).toString(36);
+}
+
+export {
+  jsonPath,
+  buildWhereClause,
+  buildOrderBy,
+  buildLimitOffset,
+  hashName
+};

package/dist/chunk-KPMRRYTL.js

@@ -0,0 +1,14 @@
+// src/vector/filter.ts
+function matchesWhere(metadata, filter) {
+  if (!metadata) return false;
+  for (const [key, expected] of Object.entries(filter)) {
+    const actual = metadata[key];
+    if (actual === expected) continue;
+    if (JSON.stringify(actual) !== JSON.stringify(expected)) return false;
+  }
+  return true;
+}
+
+export {
+  matchesWhere
+};

package/dist/chunk-N27Y55CA.js

@@ -0,0 +1,67 @@
+// src/search/tokenize.ts
+function tokenize(text) {
+  if (!text) return [];
+  return text.toLowerCase().match(/[\p{L}\p{N}]+/gu) ?? [];
+}
+function sanitizeFtsQuery(q) {
+  const tokens = tokenize(q);
+  if (tokens.length === 0) return "";
+  return tokens.map((tok) => `"${tok.replace(/"/g, '""')}"`).join(" OR ");
+}
+
+// src/search/fields.ts
+var DEFAULT_SEARCH_FIELD = "text";
+function normalizeSearchDocument(doc) {
+  if (doc.text !== void 0 && doc.fields !== void 0) {
+    throw new Error("SearchDocument must provide either `text` or `fields`, not both.");
+  }
+  if (doc.text !== void 0) {
+    return { names: [DEFAULT_SEARCH_FIELD], values: { [DEFAULT_SEARCH_FIELD]: doc.text } };
+  }
+  if (doc.fields === void 0) {
+    throw new Error("SearchDocument must provide `text` or `fields`.");
+  }
+  const names = Object.keys(doc.fields).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+  if (names.length === 0) throw new Error("SearchDocument.fields must contain at least one field.");
+  const values = {};
+  for (const name of names) {
+    const value = doc.fields[name];
+    if (typeof value !== "string") {
+      throw new Error(`SearchDocument field "${name}" must be a string.`);
+    }
+    values[name] = value;
+  }
+  return { names, values };
+}
+function assertSameSearchFields(existing, incoming, collection) {
+  if (existing.length !== incoming.length || existing.some((name, index) => name !== incoming[index])) {
+    throw new Error(
+      `Search collection "${collection}" was initialized with fields [${existing.join(", ")}], got [${incoming.join(", ")}].`
+    );
+  }
+}
+function assertValidFieldWeightValues(weights) {
+  for (const [field, weight] of Object.entries(weights ?? {})) {
+    if (!Number.isFinite(weight) || weight < 0) {
+      throw new Error(`Search field weight for "${field}" must be a non-negative finite number.`);
+    }
+  }
+}
+function fieldWeightsFor(fields, weights) {
+  assertValidFieldWeightValues(weights);
+  const fieldSet = new Set(fields);
+  for (const field of Object.keys(weights ?? {})) {
+    if (!fieldSet.has(field)) throw new Error(`Unknown search field weight "${field}".`);
+  }
+  return fields.map((field) => weights?.[field] ?? 1);
+}
+
+export {
+  tokenize,
+  sanitizeFtsQuery,
+  DEFAULT_SEARCH_FIELD,
+  normalizeSearchDocument,
+  assertSameSearchFields,
+  assertValidFieldWeightValues,
+  fieldWeightsFor
+};

package/dist/{chunk-EDVHBRXG.js → chunk-OUY3D4RT.js}

@@ -3,6 +3,9 @@ import {
   cosineSimilarity,
   isUsableVector
 } from "./chunk-BXM3YDOC.js";
+import {
+  matchesWhere
+} from "./chunk-KPMRRYTL.js";
 
 // src/vector/memory.ts
 var InMemoryVectorStore = class {
@@ -26,6 +29,9 @@ var InMemoryVectorStore = class {
     const doc = this.collections.get(collection)?.get(id);
     return doc ?? null;
   }
+  has(collection, id) {
+    return this.collections.get(collection)?.has(id) ?? false;
+  }
   remove(collection, id) {
     return this.collections.get(collection)?.delete(id) ?? false;
   }
@@ -40,6 +46,8 @@ var InMemoryVectorStore = class {
     if (!coll) return [];
     const scored = [];
     for (const doc of coll.values()) {
+      if (opts?.where && !matchesWhere(doc.metadata, opts.where)) continue;
+      if (opts?.whereNot && matchesWhere(doc.metadata, opts.whereNot)) continue;
       if (!isUsableVector(doc.vector)) continue;
       const score = cosineSimilarity(query, doc.vector);
       if (!Number.isFinite(score)) continue;
@@ -59,6 +67,42 @@ var InMemoryVectorStore = class {
   }
 };
 
+// src/vector/to-async-vector.ts
+var AsyncVectorStoreAdapter = class {
+  constructor(sync) {
+    this.sync = sync;
+  }
+  sync;
+  get meta() {
+    return this.sync.meta;
+  }
+  async upsert(collection, doc) {
+    this.sync.upsert(collection, doc);
+  }
+  async upsertMany(collection, docs) {
+    this.sync.upsertMany(collection, docs);
+  }
+  async get(collection, id) {
+    return this.sync.get(collection, id);
+  }
+  async has(collection, id) {
+    return this.sync.has(collection, id);
+  }
+  async remove(collection, id) {
+    return this.sync.remove(collection, id);
+  }
+  async count(collection) {
+    return this.sync.count(collection);
+  }
+  async search(collection, query, opts) {
+    return this.sync.search(collection, query, opts);
+  }
+};
+function toAsyncVector(store) {
+  return new AsyncVectorStoreAdapter(store);
+}
+
 export {
-  InMemoryVectorStore
+  InMemoryVectorStore,
+  toAsyncVector
 };

package/dist/filter-B9hP-TKF.d.ts

@@ -0,0 +1,8 @@
+/** Returns true when `metadata` satisfies ALL exact-match conditions in `filter`.
+ *  A missing metadata object never satisfies a non-empty filter (no field can match).
+ *  Comparison is deep-equal via JSON round-trip — the same fidelity as metadata
+ *  persisted and re-parsed from disk; avoids reference-equality surprises for
+ *  objects/arrays in the filter. */
+declare function matchesWhere(metadata: Record<string, unknown> | undefined, filter: Record<string, unknown>): boolean;
+
+export { matchesWhere as m };

package/dist/graph.d.ts

@@ -0,0 +1,98 @@
+import { A as AsyncStore, S as StoreFilter } from './types-DHLdLZ_W.js';
+
+/**
+ * A directed edge stored as a flat collection record. `from`/`to` are node ids,
+ * `type` is the relation kind. Arbitrary metadata fields (e.g. `published`,
+ * `weight`) live alongside and are matchable via StoreFilter.where / edgeFilter.
+ */
+interface Edge {
+    id: string;
+    from: string;
+    to: string;
+    type: string;
+    [field: string]: unknown;
+}
+/** Which way to walk an edge. "both" treats every edge as bidirectional. */
+type Direction = "out" | "in" | "both";
+/**
+ * Single-hop adjacent edges of `opts.from`.
+ *
+ * - "out": edges where `from === opts.from`.
+ * - "in":  edges where `to === opts.from`.
+ * - "both": the union of the two (deduped by edge id).
+ *
+ * `opts.edgeFilter` (a StoreFilter on edge fields) is applied at the store level;
+ * `opts.edgeTypes`, if given, is applied in-memory afterward (the port's `where`
+ * is exact-match only and cannot express "type IN [...]").
+ *
+ * Returns the full stored edge record untouched — no projection. All extra fields
+ * (e.g. `from_type`, `to_type`, `weight`) are present on every returned edge.
+ */
+declare function neighbors(store: AsyncStore, collection: string, opts: {
+    from: string;
+    direction?: Direction;
+    edgeTypes?: string[];
+    edgeFilter?: StoreFilter;
+}): Promise<Edge[]>;
+/**
+ * Batched, fanout-free BFS to `depth` hops from `start`.
+ *
+ * Load-once strategy (the fanout avoidance): the candidate edge set is loaded
+ * with ONE store call — `store.list(collection, edgeFilter)` — applying the
+ * caller's policy `edgeFilter` at load. Everything after is in-memory: filter by
+ * `edgeTypes`, build an adjacency index, then BFS level-by-level. No per-node
+ * query fan-out, regardless of graph size.
+ *
+ * Return shape:
+ * - `nodes`: reached node ids, EXCLUDING `start`. `start` is the origin, not a
+ *   discovered neighbor — depth 0 therefore yields `[]`, depth 1 yields the
+ *   direct neighbors, etc. Cycles terminate: a node is expanded at most once.
+ * - `edges`: every edge actually traversed, deduped by id.
+ *
+ * Both arrays are sorted by id so results are deterministic across backings
+ * (the parity test relies on this). depth ≤ 0 → `{ nodes: [], edges: [] }`.
+ *
+ * "both" adjacency: an edge {from:a,to:b} makes a→b AND b→a reachable.
+ *
+ * Returns the full stored edge record untouched — no projection. All extra fields
+ * (e.g. `from_type`, `to_type`, `weight`) are present on every returned edge.
+ */
+declare function traverse(store: AsyncStore, collection: string, opts: {
+    start: string;
+    depth: number;
+    direction?: Direction;
+    edgeTypes?: string[];
+    edgeFilter?: StoreFilter;
+}): Promise<{
+    nodes: string[];
+    edges: Edge[];
+}>;
+/**
+ * Frontier-IN batched BFS to `depth` hops from `start`.
+ *
+ * When the store exposes the optional `listWhereIn` capability, traversal fetches
+ * only edges adjacent to the current BFS frontier at each depth level:
+ *
+ * - "out": `from IN (frontier)`
+ * - "in": `to IN (frontier)`
+ * - "both": both queries, deduped by edge id
+ *
+ * `edgeFilter.where` is still pushed down into the same store query; the
+ * structural frontier field (`from`/`to`) overrides any same-named caller filter,
+ * matching `neighbors()`. `edgeTypes` remains in-memory because the base port has
+ * exact-match filters, not `type IN (...)`.
+ *
+ * Stores without `listWhereIn` fall back to `traverse()`'s load-once strategy.
+ */
+declare function traverseFrontierBatched(store: AsyncStore, collection: string, opts: {
+    start: string;
+    depth: number;
+    direction?: Direction;
+    edgeTypes?: string[];
+    edgeFilter?: StoreFilter;
+}): Promise<{
+    nodes: string[];
+    edges: Edge[];
+}>;
+
+export { type Direction, type Edge, neighbors, traverse, traverseFrontierBatched };

package/dist/graph.js

@@ -0,0 +1,161 @@
+// src/graph.ts
+function filterByTypes(edges, edgeTypes) {
+  if (!edgeTypes || edgeTypes.length === 0) return edges;
+  const set = new Set(edgeTypes);
+  return edges.filter((e) => set.has(e.type));
+}
+function dedupById(edges) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const e of edges) {
+    if (seen.has(e.id)) continue;
+    seen.add(e.id);
+    out.push(e);
+  }
+  return out;
+}
+function withWhere(filter, override) {
+  return { ...filter, where: { ...filter?.where, ...override } };
+}
+function withoutWhereField(filter, field) {
+  if (!filter?.where || !(field in filter.where)) return filter;
+  const where = { ...filter.where };
+  delete where[field];
+  return { ...filter, where };
+}
+function hasListWhereIn(store) {
+  return typeof store.listWhereIn === "function";
+}
+async function frontierEdges(store, collection, frontier, direction, edgeFilter) {
+  if (direction === "out") {
+    return store.listWhereIn(collection, "from", frontier, withoutWhereField(edgeFilter, "from"));
+  }
+  if (direction === "in") {
+    return store.listWhereIn(collection, "to", frontier, withoutWhereField(edgeFilter, "to"));
+  }
+  const [out, inc] = await Promise.all([
+    store.listWhereIn(collection, "from", frontier, withoutWhereField(edgeFilter, "from")),
+    store.listWhereIn(collection, "to", frontier, withoutWhereField(edgeFilter, "to"))
+  ]);
+  return dedupById([...out, ...inc]);
+}
+async function neighbors(store, collection, opts) {
+  const direction = opts.direction ?? "out";
+  let edges;
+  if (direction === "out") {
+    edges = await store.list(
+      collection,
+      withWhere(opts.edgeFilter, { from: opts.from })
+    );
+  } else if (direction === "in") {
+    edges = await store.list(
+      collection,
+      withWhere(opts.edgeFilter, { to: opts.from })
+    );
+  } else {
+    const [out, inc] = await Promise.all([
+      store.list(collection, withWhere(opts.edgeFilter, { from: opts.from })),
+      store.list(collection, withWhere(opts.edgeFilter, { to: opts.from }))
+    ]);
+    edges = dedupById([...out, ...inc]);
+  }
+  return filterByTypes(edges, opts.edgeTypes);
+}
+async function traverse(store, collection, opts) {
+  const direction = opts.direction ?? "out";
+  if (!Number.isFinite(opts.depth) || opts.depth <= 0) {
+    return { nodes: [], edges: [] };
+  }
+  const loaded = await store.list(collection, opts.edgeFilter);
+  const all = filterByTypes(loaded, opts.edgeTypes);
+  const adjacency = /* @__PURE__ */ new Map();
+  const addAdj = (node, edge) => {
+    const list = adjacency.get(node);
+    if (list) list.push(edge);
+    else adjacency.set(node, [edge]);
+  };
+  for (const e of all) {
+    if (direction === "out") {
+      addAdj(e.from, e);
+    } else if (direction === "in") {
+      addAdj(e.to, e);
+    } else {
+      addAdj(e.from, e);
+      addAdj(e.to, e);
+    }
+  }
+  const visited = /* @__PURE__ */ new Set([opts.start]);
+  const reached = [];
+  const traversedEdges = [];
+  const seenEdgeIds = /* @__PURE__ */ new Set();
+  let frontier = [opts.start];
+  for (let hop = 0; hop < opts.depth && frontier.length > 0; hop++) {
+    const next = [];
+    for (const node of frontier) {
+      const out = adjacency.get(node);
+      if (!out) continue;
+      for (const edge of out) {
+        if (!seenEdgeIds.has(edge.id)) {
+          seenEdgeIds.add(edge.id);
+          traversedEdges.push(edge);
+        }
+        const neighbor = edge.from === node ? edge.to : edge.from;
+        if (!visited.has(neighbor)) {
+          visited.add(neighbor);
+          reached.push(neighbor);
+          next.push(neighbor);
+        }
+      }
+    }
+    frontier = next;
+  }
+  reached.sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+  traversedEdges.sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+  return { nodes: reached, edges: traversedEdges };
+}
+async function traverseFrontierBatched(store, collection, opts) {
+  if (!hasListWhereIn(store)) {
+    return traverse(store, collection, opts);
+  }
+  const direction = opts.direction ?? "out";
+  if (!Number.isFinite(opts.depth) || opts.depth <= 0) {
+    return { nodes: [], edges: [] };
+  }
+  const visited = /* @__PURE__ */ new Set([opts.start]);
+  const reached = [];
+  const traversedEdges = [];
+  const seenEdgeIds = /* @__PURE__ */ new Set();
+  let frontier = [opts.start];
+  for (let hop = 0; hop < opts.depth && frontier.length > 0; hop++) {
+    const edges = filterByTypes(
+      await frontierEdges(store, collection, frontier, direction, opts.edgeFilter),
+      opts.edgeTypes
+    );
+    const next = [];
+    for (const node of frontier) {
+      for (const edge of edges) {
+        const adjacent = direction === "out" ? edge.from === node : direction === "in" ? edge.to === node : edge.from === node || edge.to === node;
+        if (!adjacent) continue;
+        if (!seenEdgeIds.has(edge.id)) {
+          seenEdgeIds.add(edge.id);
+          traversedEdges.push(edge);
+        }
+        const neighbor = edge.from === node ? edge.to : edge.from;
+        if (!visited.has(neighbor)) {
+          visited.add(neighbor);
+          reached.push(neighbor);
+          next.push(neighbor);
+        }
+      }
+    }
+    frontier = next;
+  }
+  reached.sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+  traversedEdges.sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
+  return { nodes: reached, edges: traversedEdges };
+}
+export {
+  neighbors,
+  traverse,
+  traverseFrontierBatched
+};

package/dist/index.d.ts

@@ -1,4 +1,7 @@
-export { A as AsyncStore, S as StoreFilter, a as StoreMeta, b as SyncStore } from './types-DyQLNtxa.js';
+export { A as AsyncStore, a as AsyncStoreInQuery, S as StoreFilter, b as StoreMeta, c as SyncStore, d as SyncStoreInQuery } from './types-DHLdLZ_W.js';
 export { InMemoryKv, toAsync } from './kv.js';
-export { V as Vector, a as VectorDocument, b as VectorSearchOptions, c as VectorSearchResult, d as VectorStore, e as VectorStoreMeta } from './types-BqSZEMAB.js';
-export { InMemoryVectorStore, assertDimensions, bufferToVector, cosineSimilarity, isUsableVector, vectorToBuffer } from './vector.js';
+export { A as AsyncVectorStore, V as Vector, a as VectorDocument, b as VectorSearchOptions, c as VectorSearchResult, d as VectorStore, e as VectorStoreMeta } from './types-B0XrD10b.js';
+export { InMemoryVectorStore, assertDimensions, bufferToVector, cosineSimilarity, isUsableVector, toAsyncVector, vectorToBuffer } from './vector.js';
+export { m as matchesWhere } from './filter-B9hP-TKF.js';
+export { S as SearchDocument, a as SearchOptions, b as SearchResult, c as SearchStore } from './types-BLZTMsQO.js';
+export { InMemorySearchStore, sanitizeFtsQuery, tokenize } from './search.js';

package/dist/index.js

@@ -1,10 +1,18 @@
 import {
   InMemoryStore,
   toAsync
-} from "./chunk-ZI4JA6IU.js";
+} from "./chunk-DKCPULXT.js";
 import {
-  InMemoryVectorStore
-} from "./chunk-EDVHBRXG.js";
+  InMemorySearchStore
+} from "./chunk-77IIKHQW.js";
+import {
+  InMemoryVectorStore,
+  toAsyncVector
+} from "./chunk-OUY3D4RT.js";
+import {
+  sanitizeFtsQuery,
+  tokenize
+} from "./chunk-N27Y55CA.js";
 import {
   assertDimensions,
   bufferToVector,
@@ -12,13 +20,21 @@ import {
   isUsableVector,
   vectorToBuffer
 } from "./chunk-BXM3YDOC.js";
+import {
+  matchesWhere
+} from "./chunk-KPMRRYTL.js";
 export {
   InMemoryStore as InMemoryKv,
+  InMemorySearchStore,
   InMemoryVectorStore,
   assertDimensions,
   bufferToVector,
   cosineSimilarity,
   isUsableVector,
+  matchesWhere,
+  sanitizeFtsQuery,
   toAsync,
+  toAsyncVector,
+  tokenize,
   vectorToBuffer
 };

package/dist/kv.d.ts

@@ -1,10 +1,11 @@
-import { b as SyncStore, A as AsyncStore, a as StoreMeta, S as StoreFilter } from './types-DyQLNtxa.js';
+import { c as SyncStore, d as SyncStoreInQuery, A as AsyncStore, a as AsyncStoreInQuery, b as StoreMeta, S as StoreFilter } from './types-DHLdLZ_W.js';
 
 /** Lift a synchronous store to the {@link AsyncStore} interface. The bridge only
- *  goes this direction — sync ⊂ async. */
+ *  goes this direction — sync ⊂ async. Optional sync capabilities are lifted too. */
+declare function toAsync(store: SyncStore & SyncStoreInQuery): AsyncStore & AsyncStoreInQuery;
 declare function toAsync(store: SyncStore): AsyncStore;
 
-declare class InMemoryStore implements SyncStore {
+declare class InMemoryStore implements SyncStore, SyncStoreInQuery {
     readonly meta: StoreMeta;
     /** Key-value storage. */
     private kv;
@@ -17,6 +18,7 @@ declare class InMemoryStore implements SyncStore {
     keys(prefix?: string): string[];
     private ensureCollection;
     list<T>(collection: string, filter?: StoreFilter): T[];
+    listWhereIn<T>(collection: string, field: string, values: readonly unknown[], filter?: StoreFilter): T[];
     getById<T>(collection: string, id: string): T | null;
     put<T extends {
         id: string;
@@ -25,4 +27,4 @@ declare class InMemoryStore implements SyncStore {
     count(collection: string, filter?: StoreFilter): number;
 }
 
-export { AsyncStore, InMemoryStore as InMemoryKv, StoreFilter, StoreMeta, SyncStore, toAsync };
+export { AsyncStore, AsyncStoreInQuery, InMemoryStore as InMemoryKv, StoreFilter, StoreMeta, SyncStore, SyncStoreInQuery, toAsync };

package/dist/kv.js

@@ -1,7 +1,7 @@
 import {
   InMemoryStore,
   toAsync
-} from "./chunk-ZI4JA6IU.js";
+} from "./chunk-DKCPULXT.js";
 export {
   InMemoryStore as InMemoryKv,
   toAsync

package/dist/search.d.ts

@@ -0,0 +1,26 @@
+import { c as SearchStore, S as SearchDocument, a as SearchOptions, b as SearchResult } from './types-BLZTMsQO.js';
+export { d as SearchFieldDocument, e as SearchTextDocument } from './types-BLZTMsQO.js';
+export { m as matchesWhere } from './filter-B9hP-TKF.js';
+import './types-DHLdLZ_W.js';
+
+declare class InMemorySearchStore implements SearchStore {
+    private readonly collections;
+    index<M extends Record<string, unknown> = Record<string, unknown>>(collection: string, doc: SearchDocument<M>): void;
+    indexMany<M extends Record<string, unknown> = Record<string, unknown>>(collection: string, docs: ReadonlyArray<SearchDocument<M>>): void;
+    remove(collection: string, id: string): boolean;
+    search<M extends Record<string, unknown> = Record<string, unknown>>(collection: string, query: string, opts?: SearchOptions): SearchResult<M>[];
+    private removeFromColl;
+    private collectionFor;
+}
+
+/** Tokenize `text` into lowercase unicode word tokens. A reasonable FTS5
+ *  `unicode61`-ish split: letters and digits are token characters, everything
+ *  else is a separator. */
+declare function tokenize(text: string): string[];
+/** Sanitize a raw query into an FTS5 MATCH expression: tokenize, double-quote
+ *  each token (doubling embedded quotes), OR them. Mirrors the knowledge/session
+ *  index sanitizers so user punctuation / operators never throw. Returns "" for
+ *  an empty/whitespace query — callers treat that as "no results". */
+declare function sanitizeFtsQuery(q: string): string;
+
+export { InMemorySearchStore, SearchDocument, SearchOptions, SearchResult, SearchStore, sanitizeFtsQuery, tokenize };

package/dist/search.js

@@ -0,0 +1,16 @@
+import {
+  InMemorySearchStore
+} from "./chunk-77IIKHQW.js";
+import {
+  sanitizeFtsQuery,
+  tokenize
+} from "./chunk-N27Y55CA.js";
+import {
+  matchesWhere
+} from "./chunk-KPMRRYTL.js";
+export {
+  InMemorySearchStore,
+  matchesWhere,
+  sanitizeFtsQuery,
+  tokenize
+};

package/dist/sql.d.ts

@@ -0,0 +1,27 @@
+import { S as StoreFilter } from './types-DHLdLZ_W.js';
+
+/** A bound SQL parameter — the common subset both better-sqlite3 and @libsql/client
+ *  accept. Booleans are pre-converted to 0/1 by the builders (better-sqlite3 rejects
+ *  a raw boolean), so they never appear here. */
+type SqlParam = string | number | bigint | null;
+/** A field name is ONE top-level JSON key, never a nested path. Build the JSON path
+ *  `$."field"` (with `"` in the field doubled per SQLite JSON-path quoting) so a
+ *  dotted name (`"a.b"`) resolves to the single top-level key `a.b`, matching the
+ *  in-memory reference's `record[key]` lookup — not the nested path `$.a.b`. Returned
+ *  as a value to BIND, never interpolated into SQL: field names are caller-supplied,
+ *  so inlining them would be a SQL-injection vector. */
+declare function jsonPath(field: string): string;
+declare function buildWhereClause(filter?: StoreFilter): {
+    clause: string;
+    params: SqlParam[];
+};
+declare function buildOrderBy(filter?: StoreFilter): {
+    clause: string;
+    params: SqlParam[];
+};
+declare function buildLimitOffset(filter?: StoreFilter): string;
+/** Deterministic 32-bit FNV-1a hash → base36. Used to make collection table names
+ *  injective (distinct collection names never alias to one physical table). */
+declare function hashName(s: string): string;
+
+export { type SqlParam, buildLimitOffset, buildOrderBy, buildWhereClause, hashName, jsonPath };