sensemaking 0.17.0 → 0.18.0

package/dist/cjs/store/transaction.js

@@ -0,0 +1,297 @@
+// Store-agnostic joining transaction helper: node:sqlite and DuckDB both support only
+// BEGIN/COMMIT/ROLLBACK, no SAVEPOINT -- nesting joins the outer transaction instead of
+// stacking, so both stores share one semantics through the one thing they have in common,
+// exec(sql).
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "withTransaction", {
+    enumerable: true,
+    get: function() {
+        return withTransaction;
+    }
+});
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) resolve(value);
+    else Promise.resolve(value).then(_next, _throw);
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype), d = Object.defineProperty;
+    return d(g, "next", {
+        value: verb(0)
+    }), d(g, "throw", {
+        value: verb(1)
+    }), d(g, "return", {
+        value: verb(2)
+    }), typeof Symbol === "function" && d(g, Symbol.iterator, {
+        value: function() {
+            return this;
+        }
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+// Keyed by connection, not a module singleton: two connections can coexist in one process
+// (e.g. watch.ts alongside a CLI query) and must not share depth.
+var states = new WeakMap();
+function stateFor(conn) {
+    var state = states.get(conn);
+    if (!state) {
+        state = {
+            depth: 0,
+            rollbackOnly: false
+        };
+        states.set(conn, state);
+    }
+    return state;
+}
+function enter(conn, state) {
+    return _async_to_generator(function() {
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    if (!(state.depth === 0)) return [
+                        3,
+                        2
+                    ];
+                    return [
+                        4,
+                        conn.exec('BEGIN')
+                    ];
+                case 1:
+                    _state.sent();
+                    state.rollbackOnly = false;
+                    _state.label = 2;
+                case 2:
+                    state.depth++;
+                    return [
+                        2
+                    ];
+            }
+        });
+    })();
+}
+// Reaching depth 0 still rollback-only means an inner scope failed and an enclosing catch
+// swallowed it; commit here would persist a partial write, so this rolls back and throws instead.
+function leaveOk(conn, state) {
+    return _async_to_generator(function() {
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    state.depth--;
+                    if (state.depth > 0) return [
+                        2
+                    ];
+                    if (!state.rollbackOnly) return [
+                        3,
+                        2
+                    ];
+                    return [
+                        4,
+                        conn.exec('ROLLBACK')
+                    ];
+                case 1:
+                    _state.sent();
+                    throw new Error('transaction rolled back: a nested scope failed');
+                case 2:
+                    return [
+                        4,
+                        conn.exec('COMMIT')
+                    ];
+                case 3:
+                    _state.sent();
+                    return [
+                        2
+                    ];
+            }
+        });
+    })();
+}
+function leaveErr(conn, state) {
+    return _async_to_generator(function() {
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    state.rollbackOnly = true;
+                    state.depth--;
+                    if (!(state.depth === 0)) return [
+                        3,
+                        2
+                    ];
+                    return [
+                        4,
+                        conn.exec('ROLLBACK')
+                    ];
+                case 1:
+                    _state.sent();
+                    _state.label = 2;
+                case 2:
+                    return [
+                        2
+                    ];
+            }
+        });
+    })();
+}
+function withTransaction(conn, fn) {
+    return _async_to_generator(function() {
+        var state, result, err;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    state = stateFor(conn);
+                    return [
+                        4,
+                        enter(conn, state)
+                    ];
+                case 1:
+                    _state.sent();
+                    _state.label = 2;
+                case 2:
+                    _state.trys.push([
+                        2,
+                        4,
+                        ,
+                        6
+                    ]);
+                    return [
+                        4,
+                        fn()
+                    ];
+                case 3:
+                    result = _state.sent();
+                    return [
+                        3,
+                        6
+                    ];
+                case 4:
+                    err = _state.sent();
+                    return [
+                        4,
+                        leaveErr(conn, state)
+                    ];
+                case 5:
+                    _state.sent();
+                    throw err;
+                case 6:
+                    return [
+                        4,
+                        leaveOk(conn, state)
+                    ];
+                case 7:
+                    _state.sent();
+                    return [
+                        2,
+                        result
+                    ];
+            }
+        });
+    })();
+}
+/* CJS INTEROP */ if (exports.__esModule && exports.default) { try { Object.defineProperty(exports.default, '__esModule', { value: true }); for (var key in exports) { exports.default[key] = exports[key]; } } catch (_) {}; module.exports = exports.default; }

package/dist/cjs/store/transaction.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/store/transaction.ts"],"sourcesContent":["// Store-agnostic joining transaction helper: node:sqlite and DuckDB both support only\n// BEGIN/COMMIT/ROLLBACK, no SAVEPOINT -- nesting joins the outer transaction instead of\n// stacking, so both stores share one semantics through the one thing they have in common,\n// exec(sql).\ninterface ExecConnection {\n  exec(sql: string): Promise<void>;\n}\n\ninterface TxState {\n  depth: number;\n  rollbackOnly: boolean;\n}\n\n// Keyed by connection, not a module singleton: two connections can coexist in one process\n// (e.g. watch.ts alongside a CLI query) and must not share depth.\nconst states = new WeakMap<ExecConnection, TxState>();\n\nfunction stateFor(conn: ExecConnection): TxState {\n  let state = states.get(conn);\n  if (!state) {\n    state = { depth: 0, rollbackOnly: false };\n    states.set(conn, state);\n  }\n  return state;\n}\n\nasync function enter(conn: ExecConnection, state: TxState): Promise<void> {\n  if (state.depth === 0) {\n    await conn.exec('BEGIN');\n    state.rollbackOnly = false;\n  }\n  state.depth++;\n}\n\n// Reaching depth 0 still rollback-only means an inner scope failed and an enclosing catch\n// swallowed it; commit here would persist a partial write, so this rolls back and throws instead.\nasync function leaveOk(conn: ExecConnection, state: TxState): Promise<void> {\n  state.depth--;\n  if (state.depth > 0) return;\n  if (state.rollbackOnly) {\n    await conn.exec('ROLLBACK');\n    throw new Error('transaction rolled back: a nested scope failed');\n  }\n  await conn.exec('COMMIT');\n}\n\nasync function leaveErr(conn: ExecConnection, state: TxState): Promise<void> {\n  state.rollbackOnly = true;\n  state.depth--;\n  if (state.depth === 0) await conn.exec('ROLLBACK');\n}\n\n// Depth-0 opens BEGIN; a nested call joins it and issues no SQL of its own. The outermost call\n// owns COMMIT/ROLLBACK. Every store, and every internal write loop (reconcile, runBatch), goes\n// through this one helper, so join semantics never differ by call site.\nexport async function withTransaction<T>(conn: ExecConnection, fn: () => Promise<T>): Promise<T> {\n  const state = stateFor(conn);\n  await enter(conn, state);\n  let result: T;\n  try {\n    result = await fn();\n  } catch (err) {\n    await leaveErr(conn, state);\n    throw err;\n  }\n  await leaveOk(conn, state);\n  return result;\n}\n"],"names":["withTransaction","states","WeakMap","stateFor","conn","state","get","depth","rollbackOnly","set","enter","exec","leaveOk","Error","leaveErr","fn","result","err"],"mappings":"AAAA,sFAAsF;AACtF,wFAAwF;AACxF,0FAA0F;AAC1F,aAAa;;;;;+BAoDSA;;;eAAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA1CtB,0FAA0F;AAC1F,kEAAkE;AAClE,IAAMC,SAAS,IAAIC;AAEnB,SAASC,SAASC,IAAoB;IACpC,IAAIC,QAAQJ,OAAOK,GAAG,CAACF;IACvB,IAAI,CAACC,OAAO;QACVA,QAAQ;YAAEE,OAAO;YAAGC,cAAc;QAAM;QACxCP,OAAOQ,GAAG,CAACL,MAAMC;IACnB;IACA,OAAOA;AACT;AAEA,SAAeK,MAAMN,IAAoB,EAAEC,KAAc;;;;;yBACnDA,CAAAA,MAAME,KAAK,KAAK,CAAA,GAAhBF;;;;oBACF;;wBAAMD,KAAKO,IAAI,CAAC;;;oBAAhB;oBACAN,MAAMG,YAAY,GAAG;;;oBAEvBH,MAAME,KAAK;;;;;;IACb;;AAEA,0FAA0F;AAC1F,kGAAkG;AAClG,SAAeK,QAAQR,IAAoB,EAAEC,KAAc;;;;;oBACzDA,MAAME,KAAK;oBACX,IAAIF,MAAME,KAAK,GAAG,GAAG;;;yBACjBF,MAAMG,YAAY,EAAlBH;;;;oBACF;;wBAAMD,KAAKO,IAAI,CAAC;;;oBAAhB;oBACA,MAAM,IAAIE,MAAM;;oBAElB;;wBAAMT,KAAKO,IAAI,CAAC;;;oBAAhB;;;;;;IACF;;AAEA,SAAeG,SAASV,IAAoB,EAAEC,KAAc;;;;;oBAC1DA,MAAMG,YAAY,GAAG;oBACrBH,MAAME,KAAK;yBACPF,CAAAA,MAAME,KAAK,KAAK,CAAA,GAAhBF;;;;oBAAmB;;wBAAMD,KAAKO,IAAI,CAAC;;;oBAAhB;;;;;;;;IACzB;;AAKO,SAAeX,gBAAmBI,IAAoB,EAAEW,EAAoB;;YAC3EV,OAEFW,QAGKC;;;;oBALHZ,QAAQF,SAASC;oBACvB;;wBAAMM,MAAMN,MAAMC;;;oBAAlB;;;;;;;;;oBAGW;;wBAAMU;;;oBAAfC,SAAS;;;;;;oBACFC;oBACP;;wBAAMH,SAASV,MAAMC;;;oBAArB;oBACA,MAAMY;;oBAER;;wBAAML,QAAQR,MAAMC;;;oBAApB;oBACA;;wBAAOW;;;;IACT"}

package/dist/cjs/store/types.d.cts

@@ -0,0 +1,91 @@
+export type Capability = 'phrases' | 'snippets' | 'watch-concurrency' | 'lexical' | 'vectors';
+export interface RunResult {
+    changes: number | bigint;
+    lastInsertRowid: number | bigint;
+}
+export interface Statement {
+    run(...params: unknown[]): Promise<RunResult>;
+    get(...params: unknown[]): Promise<unknown>;
+    all(...params: unknown[]): Promise<unknown[]>;
+    iterate(...params: unknown[]): AsyncIterable<unknown>;
+    columns(): Array<{
+        name: string;
+    }>;
+    setReadBigInts(enabled: boolean): void;
+}
+export interface Connection {
+    exec(sql: string): Promise<void>;
+    prepare(sql: string): Promise<Statement>;
+    runBatch(sql: string, paramRows: unknown[][]): Promise<void>;
+}
+export interface DocumentStore {
+    columns(): Promise<string[]>;
+}
+export interface LexicalHit {
+    path: string;
+    hit: string | null;
+}
+export interface LexicalQueryOptions {
+    whereJoin: string;
+    whereCond: string;
+    scopeCond: string;
+    limit: number;
+}
+export interface LexicalIndex {
+    query(terms: string, opts: LexicalQueryOptions): Promise<LexicalHit[]>;
+}
+export interface VectorCandidate {
+    path: string;
+    lines: string;
+    similarity: number;
+}
+export interface VectorSimilar {
+    path: string;
+    similarity: number;
+}
+export interface VectorWriteRow {
+    path: string;
+    chunk: number;
+    scale: number;
+    vector: Buffer;
+}
+export interface VectorStore {
+    pending(): Promise<Array<{
+        path: string;
+        chunk: number;
+    }>>;
+    writeVectors(rows: VectorWriteRow[]): Promise<void>;
+    candidates(queryVector: Float32Array, storeDims: number, fetch: number, allowed?: Set<string>): Promise<VectorCandidate[]>;
+    similar(path: string, opts: {
+        exclude: Set<string>;
+        allowed?: Set<string>;
+        k: number;
+    }): Promise<VectorSimilar[]>;
+    hasVector(path: string): Promise<boolean>;
+}
+export interface RawStatement {
+    columns(): Array<{
+        name: string;
+    }>;
+    iterate(...params: unknown[]): AsyncIterable<unknown>;
+}
+export interface SqlSession {
+    prepare(sql: string): Promise<RawStatement>;
+}
+export interface Store {
+    readonly name: 'sqlite' | 'duckdb';
+    readonly capabilities: ReadonlySet<Capability>;
+    exec(sql: string): Promise<void>;
+    prepare(sql: string): Promise<Statement>;
+    runBatch(sql: string, paramRows: unknown[][]): Promise<void>;
+    transaction<T>(fn: () => Promise<T>): Promise<T>;
+    reconcile(): Promise<{
+        parsed: number;
+        warnings: string[];
+    }>;
+    docs: DocumentStore;
+    lexical: LexicalIndex;
+    vectors: VectorStore;
+    raw: SqlSession;
+    close(): Promise<void>;
+}

package/dist/cjs/store/types.d.ts

@@ -0,0 +1,91 @@
+export type Capability = 'phrases' | 'snippets' | 'watch-concurrency' | 'lexical' | 'vectors';
+export interface RunResult {
+    changes: number | bigint;
+    lastInsertRowid: number | bigint;
+}
+export interface Statement {
+    run(...params: unknown[]): Promise<RunResult>;
+    get(...params: unknown[]): Promise<unknown>;
+    all(...params: unknown[]): Promise<unknown[]>;
+    iterate(...params: unknown[]): AsyncIterable<unknown>;
+    columns(): Array<{
+        name: string;
+    }>;
+    setReadBigInts(enabled: boolean): void;
+}
+export interface Connection {
+    exec(sql: string): Promise<void>;
+    prepare(sql: string): Promise<Statement>;
+    runBatch(sql: string, paramRows: unknown[][]): Promise<void>;
+}
+export interface DocumentStore {
+    columns(): Promise<string[]>;
+}
+export interface LexicalHit {
+    path: string;
+    hit: string | null;
+}
+export interface LexicalQueryOptions {
+    whereJoin: string;
+    whereCond: string;
+    scopeCond: string;
+    limit: number;
+}
+export interface LexicalIndex {
+    query(terms: string, opts: LexicalQueryOptions): Promise<LexicalHit[]>;
+}
+export interface VectorCandidate {
+    path: string;
+    lines: string;
+    similarity: number;
+}
+export interface VectorSimilar {
+    path: string;
+    similarity: number;
+}
+export interface VectorWriteRow {
+    path: string;
+    chunk: number;
+    scale: number;
+    vector: Buffer;
+}
+export interface VectorStore {
+    pending(): Promise<Array<{
+        path: string;
+        chunk: number;
+    }>>;
+    writeVectors(rows: VectorWriteRow[]): Promise<void>;
+    candidates(queryVector: Float32Array, storeDims: number, fetch: number, allowed?: Set<string>): Promise<VectorCandidate[]>;
+    similar(path: string, opts: {
+        exclude: Set<string>;
+        allowed?: Set<string>;
+        k: number;
+    }): Promise<VectorSimilar[]>;
+    hasVector(path: string): Promise<boolean>;
+}
+export interface RawStatement {
+    columns(): Array<{
+        name: string;
+    }>;
+    iterate(...params: unknown[]): AsyncIterable<unknown>;
+}
+export interface SqlSession {
+    prepare(sql: string): Promise<RawStatement>;
+}
+export interface Store {
+    readonly name: 'sqlite' | 'duckdb';
+    readonly capabilities: ReadonlySet<Capability>;
+    exec(sql: string): Promise<void>;
+    prepare(sql: string): Promise<Statement>;
+    runBatch(sql: string, paramRows: unknown[][]): Promise<void>;
+    transaction<T>(fn: () => Promise<T>): Promise<T>;
+    reconcile(): Promise<{
+        parsed: number;
+        warnings: string[];
+    }>;
+    docs: DocumentStore;
+    lexical: LexicalIndex;
+    vectors: VectorStore;
+    raw: SqlSession;
+    close(): Promise<void>;
+}

package/dist/cjs/store/types.js

@@ -0,0 +1,15 @@
+// The backing-store interface: a minimal portable statement surface (exec/prepare, used as-is
+// by feature-owned tables and ad hoc queries) plus dedicated interfaces exactly where engines
+// diverge (lexical index, vector scan, raw sql passthrough).
+// 'lexical'/'vectors' mean the store's LexicalIndex/VectorStore are functionally implemented
+// (rather than present-but-inert); 'phrases'/'snippets'/'watch-concurrency' are the finer
+// behaviors sqlite's FTS5 path carries. A tree whose config needs a capability the chosen
+// store lacks fails at open (or at first use for a lazily-detected need), named.
+// 'phrases' means quoted-phrase (`"..."`) matching only -- not FTS5's wider query grammar
+// (prefix `*`, boolean AND/OR/NOT, NEAR, `^`, column filters), which duckdb's lexical path
+// rejects loudly rather than interpret (see store/duckdb/lexical.ts).
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+/* CJS INTEROP */ if (exports.__esModule && exports.default) { try { Object.defineProperty(exports.default, '__esModule', { value: true }); for (var key in exports) { exports.default[key] = exports[key]; } } catch (_) {}; module.exports = exports.default; }

package/dist/cjs/store/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/store/types.ts"],"sourcesContent":["// The backing-store interface: a minimal portable statement surface (exec/prepare, used as-is\n// by feature-owned tables and ad hoc queries) plus dedicated interfaces exactly where engines\n// diverge (lexical index, vector scan, raw sql passthrough).\n\n// 'lexical'/'vectors' mean the store's LexicalIndex/VectorStore are functionally implemented\n// (rather than present-but-inert); 'phrases'/'snippets'/'watch-concurrency' are the finer\n// behaviors sqlite's FTS5 path carries. A tree whose config needs a capability the chosen\n// store lacks fails at open (or at first use for a lazily-detected need), named.\n// 'phrases' means quoted-phrase (`\"...\"`) matching only -- not FTS5's wider query grammar\n// (prefix `*`, boolean AND/OR/NOT, NEAR, `^`, column filters), which duckdb's lexical path\n// rejects loudly rather than interpret (see store/duckdb/lexical.ts).\nexport type Capability = 'phrases' | 'snippets' | 'watch-concurrency' | 'lexical' | 'vectors';\n\nexport interface RunResult {\n  changes: number | bigint;\n  lastInsertRowid: number | bigint;\n}\n\n// A prepared statement's async surface: every engine this store supports has to cross a real\n// async boundary for a query (DuckDB has no synchronous client at all), so run/get/all return\n// Promises. iterate() stays an async iterable for the same reason `sense sql` streams.\nexport interface Statement {\n  run(...params: unknown[]): Promise<RunResult>;\n  get(...params: unknown[]): Promise<unknown>;\n  all(...params: unknown[]): Promise<unknown[]>;\n  iterate(...params: unknown[]): AsyncIterable<unknown>;\n  columns(): Array<{ name: string }>;\n  setReadBigInts(enabled: boolean): void;\n}\n\n// Connection surface feature-owned SQL runs against inside a store's own hot loops (schema,\n// reconcile). Portable so a feature never imports an engine-specific client type. `runBatch`\n// is the one call a write loop goes through instead of preparing once and calling `run()` per\n// row itself: one crossing per loop, the engine's own bulk idiom underneath (see each store's\n// implementation for what that idiom is).\nexport interface Connection {\n  exec(sql: string): Promise<void>;\n  prepare(sql: string): Promise<Statement>;\n  runBatch(sql: string, paramRows: unknown[][]): Promise<void>;\n}\n\nexport interface DocumentStore {\n  // Frontmatter column names (including internal ones; callers filter).\n  columns(): Promise<string[]>;\n}\n\nexport interface LexicalHit {\n  path: string;\n  hit: string | null;\n}\n\nexport interface LexicalQueryOptions {\n  whereJoin: string;\n  whereCond: string;\n  scopeCond: string;\n  limit: number;\n}\n\nexport interface LexicalIndex {\n  // Ranked word-match query with excerpt, scoped by the caller-built SQL fragments (the same\n  // fragments narrowByWhere/materializeScope produce elsewhere).\n  query(terms: string, opts: LexicalQueryOptions): Promise<LexicalHit[]>;\n}\n\nexport interface VectorCandidate {\n  path: string;\n  lines: string;\n  similarity: number;\n}\n\nexport interface VectorSimilar {\n  path: string;\n  similarity: number;\n}\n\nexport interface VectorWriteRow {\n  path: string;\n  chunk: number;\n  scale: number;\n  vector: Buffer;\n}\n\nexport interface VectorStore {\n  // Rows whose vector is still NULL (never embedded, or added since).\n  pending(): Promise<Array<{ path: string; chunk: number }>>;\n  // One batch write per call (never per row) so a provider's embedding batch stays inside a\n  // single store method.\n  writeVectors(rows: VectorWriteRow[]): Promise<void>;\n  candidates(queryVector: Float32Array, storeDims: number, fetch: number, allowed?: Set<string>): Promise<VectorCandidate[]>;\n  similar(path: string, opts: { exclude: Set<string>; allowed?: Set<string>; k: number }): Promise<VectorSimilar[]>;\n  hasVector(path: string): Promise<boolean>;\n}\n\n// The `sense sql` passthrough: string in, streamed rows out. Each store registers the same\n// sense-supplied functions and applies its own read-bigints/error-translation behavior.\nexport interface RawStatement {\n  columns(): Array<{ name: string }>;\n  iterate(...params: unknown[]): AsyncIterable<unknown>;\n}\n\nexport interface SqlSession {\n  prepare(sql: string): Promise<RawStatement>;\n}\n\nexport interface Store {\n  readonly name: 'sqlite' | 'duckdb';\n  readonly capabilities: ReadonlySet<Capability>;\n  exec(sql: string): Promise<void>;\n  prepare(sql: string): Promise<Statement>;\n  // One crossing, N rows: every external write loop (search's candidate insert, the graph\n  // ring's temp-table writes, etc.) goes through this instead of looping over `run()` itself.\n  // See Connection.runBatch -- same contract, same per-store implementation.\n  runBatch(sql: string, paramRows: unknown[][]): Promise<void>;\n  // Pins one snapshot across multi-statement reads; `map` and `peek` use it. A command whose\n  // scope holds a network-bound write (search's embedding top-up) must stay outside it.\n  // Nesting joins the enclosing transaction rather than opening a second one.\n  transaction<T>(fn: () => Promise<T>): Promise<T>;\n  // The whole file-sync pass (parse changed files, run every feature hook, resolve links,\n  // recompute rank) behind one method: per-file iteration never crosses the async boundary.\n  reconcile(): Promise<{ parsed: number; warnings: string[] }>;\n  docs: DocumentStore;\n  lexical: LexicalIndex;\n  vectors: VectorStore;\n  raw: SqlSession;\n  close(): Promise<void>;\n}\n"],"names":[],"mappings":"AAAA,8FAA8F;AAC9F,8FAA8F;AAC9F,6DAA6D;AAE7D,6FAA6F;AAC7F,0FAA0F;AAC1F,0FAA0F;AAC1F,iFAAiF;AACjF,0FAA0F;AAC1F,2FAA2F;AAC3F,sEAAsE"}

package/dist/cjs/watch.d.cts

@@ -15,5 +15,8 @@ export type WatchEvent = {
 export interface WatchOptions {
     force?: boolean;
     onEvent?: (event: WatchEvent) => void;
+    signal?: AbortSignal;
+    debounceMs?: number;
+    heartbeatIntervalMs?: number;
 }
 export declare function runWatch(cfg: ResolvedConfig, opts?: WatchOptions): Promise<void>;

package/dist/cjs/watch.d.ts

@@ -15,5 +15,8 @@ export type WatchEvent = {
 export interface WatchOptions {
     force?: boolean;
     onEvent?: (event: WatchEvent) => void;
+    signal?: AbortSignal;
+    debounceMs?: number;
+    heartbeatIntervalMs?: number;
 }
 export declare function runWatch(cfg: ResolvedConfig, opts?: WatchOptions): Promise<void>;