sensemaking 0.18.2 → 0.18.4

package/dist/cjs/store/sqlite/vectors.d.cts

@@ -1,8 +1,4 @@
 import type { Connection, VectorCandidate, VectorSimilar, VectorWriteRow } from '../types.js';
-export declare function pendingRows(conn: Connection): Promise<Array<{
-    path: string;
-    chunk: number;
-}>>;
 export declare function writeVectorBatch(conn: Connection, rows: VectorWriteRow[]): Promise<void>;
 export declare function scanCandidates(conn: Connection, qv: Float32Array, storeDims: number, fetch: number, allowed?: Set<string>): Promise<VectorCandidate[]>;
 export declare function scanSimilar(conn: Connection, path: string, opts: {
@@ -10,4 +6,3 @@ export declare function scanSimilar(conn: Connection, path: string, opts: {
     allowed?: Set<string>;
     k: number;
 }): Promise<VectorSimilar[]>;
-export declare function hasVectorRow(conn: Connection, path: string): Promise<boolean>;

package/dist/cjs/store/sqlite/vectors.d.ts

@@ -1,8 +1,4 @@
 import type { Connection, VectorCandidate, VectorSimilar, VectorWriteRow } from '../types.js';
-export declare function pendingRows(conn: Connection): Promise<Array<{
-    path: string;
-    chunk: number;
-}>>;
 export declare function writeVectorBatch(conn: Connection, rows: VectorWriteRow[]): Promise<void>;
 export declare function scanCandidates(conn: Connection, qv: Float32Array, storeDims: number, fetch: number, allowed?: Set<string>): Promise<VectorCandidate[]>;
 export declare function scanSimilar(conn: Connection, path: string, opts: {
@@ -10,4 +6,3 @@ export declare function scanSimilar(conn: Connection, path: string, opts: {
     allowed?: Set<string>;
     k: number;
 }): Promise<VectorSimilar[]>;
-export declare function hasVectorRow(conn: Connection, path: string): Promise<boolean>;

package/dist/cjs/store/sqlite/vectors.js

@@ -9,12 +9,6 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-    get hasVectorRow () {
-        return hasVectorRow;
-    },
-    get pendingRows () {
-        return pendingRows;
-    },
     get scanCandidates () {
         return scanCandidates;
     },
@@ -25,6 +19,7 @@ _export(exports, {
         return writeVectorBatch;
     }
 });
+var _vectorsts = require("../vectors.js");
 function _array_like_to_array(arr, len) {
     if (len == null || len > arr.length) len = arr.length;
     for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
@@ -210,38 +205,6 @@ function _unsupported_iterable_to_array(o, minLen) {
     if (n === "Map" || n === "Set") return Array.from(n);
     if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
 }
-// Seed chunks that participate in a `related` scan; see similar() for the measurement.
-var TARGET_CHUNK_CAP = 16;
-// Dequantised int8 dot products land a little either side of a true cosine, so an identical
-// pair prints 1.001 and undermines a column whose whole job is being a bounded number.
-function asCosine(score) {
-    return Math.round(Math.min(1, Math.max(-1, score)) * 1000) / 1000;
-}
-function pendingRows(conn) {
-    return _async_to_generator(function() {
-        var stmt;
-        return _ts_generator(this, function(_state) {
-            switch(_state.label){
-                case 0:
-                    return [
-                        4,
-                        conn.prepare('SELECT "path", chunk FROM embeddings WHERE vector IS NULL ORDER BY "path", chunk')
-                    ];
-                case 1:
-                    stmt = _state.sent();
-                    return [
-                        4,
-                        stmt.all()
-                    ];
-                case 2:
-                    return [
-                        2,
-                        _state.sent()
-                    ];
-            }
-        });
-    })();
-}
 function writeVectorBatch(conn, rows) {
     return _async_to_generator(function() {
         return _ts_generator(this, function(_state) {
@@ -327,7 +290,7 @@ function scanCandidates(conn, qv, storeDims, fetch, allowed) {
                             return {
                                 path: path,
                                 lines: b.lines,
-                                similarity: asCosine(b.score)
+                                similarity: (0, _vectorsts.asCosine)(b.score)
                             };
                         })
                     ];
@@ -337,7 +300,7 @@ function scanCandidates(conn, qv, storeDims, fetch, allowed) {
 }
 function scanSimilar(conn, path, opts) {
     return _async_to_generator(function() {
-        var targetStmt, targetRows, step, target, stmt, rows, best, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, row, other, _iteratorNormalCompletion1, _didIteratorError1, _iteratorError1, _iterator1, _step1, t, dot, len, d, score, existing;
+        var targetStmt, targetRows, target, stmt, rows, best, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, row, other, _iteratorNormalCompletion1, _didIteratorError1, _iteratorError1, _iterator1, _step1, t, dot, len, d, score, existing;
         return _ts_generator(this, function(_state) {
             switch(_state.label){
                 case 0:
@@ -357,10 +320,7 @@ function scanSimilar(conn, path, opts) {
                         2,
                         []
                     ];
-                    step = Math.max(1, Math.ceil(targetRows.length / TARGET_CHUNK_CAP));
-                    target = targetRows.filter(function(_, i) {
-                        return i % step === 0;
-                    }).map(function(row) {
+                    target = (0, _vectorsts.sampleEvenly)(targetRows).map(function(row) {
                         return {
                             v: new Int8Array(row.vector.buffer, row.vector.byteOffset, row.vector.byteLength),
                             scale: row.scale
@@ -433,7 +393,7 @@ function scanSimilar(conn, path, opts) {
                             var _param = _sliced_to_array(param, 2), p = _param[0], score = _param[1];
                             return {
                                 path: p,
-                                similarity: asCosine(score)
+                                similarity: (0, _vectorsts.asCosine)(score)
                             };
                         })
                     ];
@@ -441,30 +401,4 @@ function scanSimilar(conn, path, opts) {
         });
     })();
 }
-function hasVectorRow(conn, path) {
-    return _async_to_generator(function() {
-        var stmt, row;
-        return _ts_generator(this, function(_state) {
-            switch(_state.label){
-                case 0:
-                    return [
-                        4,
-                        conn.prepare('SELECT 1 AS ok FROM embeddings WHERE "path" = ? AND vector IS NOT NULL LIMIT 1')
-                    ];
-                case 1:
-                    stmt = _state.sent();
-                    return [
-                        4,
-                        stmt.get(path)
-                    ];
-                case 2:
-                    row = _state.sent();
-                    return [
-                        2,
-                        row !== undefined
-                    ];
-            }
-        });
-    })();
-}
 /* 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/sqlite/vectors.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/store/sqlite/vectors.ts"],"sourcesContent":["import type { Connection, VectorCandidate, VectorSimilar, VectorWriteRow } from '../types.ts';\n\n// Seed chunks that participate in a `related` scan; see similar() for the measurement.\nconst TARGET_CHUNK_CAP = 16;\n\n// Dequantised int8 dot products land a little either side of a true cosine, so an identical\n// pair prints 1.001 and undermines a column whose whole job is being a bounded number.\nfunction asCosine(score: number): number {\n  return Math.round(Math.min(1, Math.max(-1, score)) * 1000) / 1000;\n}\n\nexport async function pendingRows(conn: Connection): Promise<Array<{ path: string; chunk: number }>> {\n  const stmt = await conn.prepare('SELECT \"path\", chunk FROM embeddings WHERE vector IS NULL ORDER BY \"path\", chunk');\n  return (await stmt.all()) as Array<{ path: string; chunk: number }>;\n}\n\n// One runBatch call per provider batch: the caller (embed/query.ts) already batches by the\n// provider's batchCap, so this is one crossing per batch, never per row.\nexport async function writeVectorBatch(conn: Connection, rows: VectorWriteRow[]): Promise<void> {\n  if (rows.length === 0) return;\n  await conn.runBatch(\n    'UPDATE embeddings SET scale = ?, vector = ? WHERE \"path\" = ? AND chunk = ?',\n    rows.map((row) => [row.scale, row.vector, row.path, row.chunk])\n  );\n}\n\n// Best chunk per file by cosine, its line range riding along: the JS loop over stored int8\n// BLOBs this store's scan strategy is (a native store scans differently, same contract).\nexport async function scanCandidates(conn: Connection, qv: Float32Array, storeDims: number, fetch: number, allowed?: Set<string>): Promise<VectorCandidate[]> {\n  const stmt = await conn.prepare('SELECT \"path\", start_line, end_line, scale, vector FROM embeddings WHERE vector IS NOT NULL');\n  const rows = (await stmt.all()) as Array<{\n    path: string;\n    start_line: number;\n    end_line: number;\n    scale: number;\n    vector: Uint8Array;\n  }>;\n\n  const best = new Map<string, { score: number; lines: string }>();\n  for (const row of rows) {\n    if (allowed && !allowed.has(row.path)) continue;\n    const q = new Int8Array(row.vector.buffer, row.vector.byteOffset, Math.min(storeDims, row.vector.byteLength));\n    let dot = 0;\n    for (let d = 0; d < q.length; d++) dot += q[d] * qv[d];\n    const score = dot * row.scale;\n    const existing = best.get(row.path);\n    if (!existing || score > existing.score) best.set(row.path, { score, lines: `L${row.start_line}-${row.end_line}` });\n  }\n  return [...best.entries()]\n    .sort((a, b) => b[1].score - a[1].score)\n    .slice(0, fetch)\n    .map(([path, b]) => ({ path, lines: b.lines, similarity: asCosine(b.score) }));\n}\n\n// Note-to-note similarity is the max cosine over (target chunk, other chunk) pairs, one linear\n// scan of stored vectors.\nexport async function scanSimilar(conn: Connection, path: string, opts: { exclude: Set<string>; allowed?: Set<string>; k: number }): Promise<VectorSimilar[]> {\n  // Cost is target_chunks x stored_chunks, so a heading-dense seed multiplies a full-corpus\n  // scan (12.7s at 201 chunks/note). Sample evenly, so late sections still get a vote.\n  const targetStmt = await conn.prepare('SELECT scale, vector FROM embeddings WHERE \"path\" = ? AND vector IS NOT NULL ORDER BY chunk');\n  const targetRows = (await targetStmt.all(path)) as Array<{ scale: number; vector: Uint8Array }>;\n  if (targetRows.length === 0) return [];\n  const step = Math.max(1, Math.ceil(targetRows.length / TARGET_CHUNK_CAP));\n  const target = targetRows.filter((_, i) => i % step === 0).map((row) => ({ v: new Int8Array(row.vector.buffer, row.vector.byteOffset, row.vector.byteLength), scale: row.scale }));\n\n  const stmt = await conn.prepare('SELECT \"path\", scale, vector FROM embeddings WHERE vector IS NOT NULL');\n  const rows = (await stmt.all()) as Array<{ path: string; scale: number; vector: Uint8Array }>;\n  const best = new Map<string, number>();\n  for (const row of rows) {\n    if (row.path === path || opts.exclude.has(row.path) || (opts.allowed && !opts.allowed.has(row.path))) continue;\n    const other = new Int8Array(row.vector.buffer, row.vector.byteOffset, row.vector.byteLength);\n    for (const t of target) {\n      let dot = 0;\n      const len = Math.min(t.v.length, other.length);\n      for (let d = 0; d < len; d++) dot += t.v[d] * other[d];\n      const score = dot * t.scale * row.scale;\n      const existing = best.get(row.path);\n      if (existing === undefined || score > existing) best.set(row.path, score);\n    }\n  }\n\n  return [...best.entries()]\n    .sort((a, b) => b[1] - a[1])\n    .slice(0, opts.k)\n    .map(([p, score]) => ({ path: p, similarity: asCosine(score) }));\n}\n\n// Whether a note has any chunk with a vector. Distinguishes \"nothing is near this note\" from\n// \"this note has no text\", which look the same in an empty result.\nexport async function hasVectorRow(conn: Connection, path: string): Promise<boolean> {\n  const stmt = await conn.prepare('SELECT 1 AS ok FROM embeddings WHERE \"path\" = ? AND vector IS NOT NULL LIMIT 1');\n  const row = (await stmt.get(path)) as { ok: number } | undefined;\n  return row !== undefined;\n}\n"],"names":["hasVectorRow","pendingRows","scanCandidates","scanSimilar","writeVectorBatch","TARGET_CHUNK_CAP","asCosine","score","Math","round","min","max","conn","stmt","prepare","all","rows","length","runBatch","map","row","scale","vector","path","chunk","qv","storeDims","fetch","allowed","best","q","dot","d","existing","Map","has","Int8Array","buffer","byteOffset","byteLength","get","set","lines","start_line","end_line","entries","sort","a","b","slice","similarity","opts","targetStmt","targetRows","step","target","other","t","len","ceil","filter","_","i","v","exclude","undefined","k","p"],"mappings":"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"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/store/sqlite/vectors.ts"],"sourcesContent":["import type { Connection, VectorCandidate, VectorSimilar, VectorWriteRow } from '../types.ts';\nimport { asCosine, sampleEvenly } from '../vectors.ts';\n\n// One runBatch call per provider batch: the caller (embed/query.ts) already batches by the\n// provider's batchCap, so this is one crossing per batch, never per row.\nexport async function writeVectorBatch(conn: Connection, rows: VectorWriteRow[]): Promise<void> {\n  if (rows.length === 0) return;\n  await conn.runBatch(\n    'UPDATE embeddings SET scale = ?, vector = ? WHERE \"path\" = ? AND chunk = ?',\n    rows.map((row) => [row.scale, row.vector, row.path, row.chunk])\n  );\n}\n\n// Best chunk per file by cosine, its line range riding along: the JS loop over stored int8\n// BLOBs this store's scan strategy is (a native store scans differently, same contract).\nexport async function scanCandidates(conn: Connection, qv: Float32Array, storeDims: number, fetch: number, allowed?: Set<string>): Promise<VectorCandidate[]> {\n  const stmt = await conn.prepare('SELECT \"path\", start_line, end_line, scale, vector FROM embeddings WHERE vector IS NOT NULL');\n  const rows = (await stmt.all()) as Array<{\n    path: string;\n    start_line: number;\n    end_line: number;\n    scale: number;\n    vector: Uint8Array;\n  }>;\n\n  const best = new Map<string, { score: number; lines: string }>();\n  for (const row of rows) {\n    if (allowed && !allowed.has(row.path)) continue;\n    const q = new Int8Array(row.vector.buffer, row.vector.byteOffset, Math.min(storeDims, row.vector.byteLength));\n    let dot = 0;\n    for (let d = 0; d < q.length; d++) dot += q[d] * qv[d];\n    const score = dot * row.scale;\n    const existing = best.get(row.path);\n    if (!existing || score > existing.score) best.set(row.path, { score, lines: `L${row.start_line}-${row.end_line}` });\n  }\n  return [...best.entries()]\n    .sort((a, b) => b[1].score - a[1].score)\n    .slice(0, fetch)\n    .map(([path, b]) => ({ path, lines: b.lines, similarity: asCosine(b.score) }));\n}\n\n// Note-to-note similarity is the max cosine over (target chunk, other chunk) pairs, one linear\n// scan of stored vectors.\nexport async function scanSimilar(conn: Connection, path: string, opts: { exclude: Set<string>; allowed?: Set<string>; k: number }): Promise<VectorSimilar[]> {\n  const targetStmt = await conn.prepare('SELECT scale, vector FROM embeddings WHERE \"path\" = ? AND vector IS NOT NULL ORDER BY chunk');\n  const targetRows = (await targetStmt.all(path)) as Array<{ scale: number; vector: Uint8Array }>;\n  if (targetRows.length === 0) return [];\n  const target = sampleEvenly(targetRows).map((row) => ({ v: new Int8Array(row.vector.buffer, row.vector.byteOffset, row.vector.byteLength), scale: row.scale }));\n\n  const stmt = await conn.prepare('SELECT \"path\", scale, vector FROM embeddings WHERE vector IS NOT NULL');\n  const rows = (await stmt.all()) as Array<{ path: string; scale: number; vector: Uint8Array }>;\n  const best = new Map<string, number>();\n  for (const row of rows) {\n    if (row.path === path || opts.exclude.has(row.path) || (opts.allowed && !opts.allowed.has(row.path))) continue;\n    const other = new Int8Array(row.vector.buffer, row.vector.byteOffset, row.vector.byteLength);\n    for (const t of target) {\n      let dot = 0;\n      const len = Math.min(t.v.length, other.length);\n      for (let d = 0; d < len; d++) dot += t.v[d] * other[d];\n      const score = dot * t.scale * row.scale;\n      const existing = best.get(row.path);\n      if (existing === undefined || score > existing) best.set(row.path, score);\n    }\n  }\n\n  return [...best.entries()]\n    .sort((a, b) => b[1] - a[1])\n    .slice(0, opts.k)\n    .map(([p, score]) => ({ path: p, similarity: asCosine(score) }));\n}\n"],"names":["scanCandidates","scanSimilar","writeVectorBatch","conn","rows","length","runBatch","map","row","scale","vector","path","chunk","qv","storeDims","fetch","allowed","stmt","best","q","dot","d","score","existing","prepare","all","Map","has","Int8Array","buffer","byteOffset","Math","min","byteLength","get","set","lines","start_line","end_line","entries","sort","a","b","slice","similarity","asCosine","opts","targetStmt","targetRows","target","other","t","len","sampleEvenly","v","exclude","undefined","k","p"],"mappings":";;;;;;;;;;;QAesBA;eAAAA;;QA4BAC;eAAAA;;QAtCAC;eAAAA;;;yBAJiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAIhC,SAAeA,iBAAiBC,IAAgB,EAAEC,IAAsB;;;;;oBAC7E,IAAIA,KAAKC,MAAM,KAAK,GAAG;;;oBACvB;;wBAAMF,KAAKG,QAAQ,CACjB,8EACAF,KAAKG,GAAG,CAAC,SAACC;mCAAQ;gCAACA,IAAIC,KAAK;gCAAED,IAAIE,MAAM;gCAAEF,IAAIG,IAAI;gCAAEH,IAAII,KAAK;6BAAC;;;;oBAFhE;;;;;;IAIF;;AAIO,SAAeZ,eAAeG,IAAgB,EAAEU,EAAgB,EAAEC,SAAiB,EAAEC,KAAa,EAAEC,OAAqB;;YACxHC,MACAb,MAQAc,MACD,2BAAA,mBAAA,gBAAA,WAAA,OAAMV,KAEHW,GACFC,KACKC,GACHC,OACAC;;;;oBAhBK;;wBAAMpB,KAAKqB,OAAO,CAAC;;;oBAA1BP,OAAO;oBACC;;wBAAMA,KAAKQ,GAAG;;;oBAAtBrB,OAAQ;oBAQRc,OAAO,IAAIQ;oBACZ,kCAAA,2BAAA;;wBAAL,IAAK,YAAatB,2BAAb,6BAAA,QAAA,yBAAA,iCAAmB;4BAAbI,MAAN;4BACH,IAAIQ,WAAW,CAACA,QAAQW,GAAG,CAACnB,IAAIG,IAAI,GAAG;4BACjCQ,IAAI,IAAIS,UAAUpB,IAAIE,MAAM,CAACmB,MAAM,EAAErB,IAAIE,MAAM,CAACoB,UAAU,EAAEC,KAAKC,GAAG,CAAClB,WAAWN,IAAIE,MAAM,CAACuB,UAAU;4BACvGb,MAAM;4BACV,IAASC,IAAI,GAAGA,IAAIF,EAAEd,MAAM,EAAEgB,IAAKD,OAAOD,CAAC,CAACE,EAAE,GAAGR,EAAE,CAACQ,EAAE;4BAChDC,QAAQF,MAAMZ,IAAIC,KAAK;4BACvBc,WAAWL,KAAKgB,GAAG,CAAC1B,IAAIG,IAAI;4BAClC,IAAI,CAACY,YAAYD,QAAQC,SAASD,KAAK,EAAEJ,KAAKiB,GAAG,CAAC3B,IAAIG,IAAI,EAAE;gCAAEW,OAAAA;gCAAOc,OAAO,AAAC,IAAqB5B,OAAlBA,IAAI6B,UAAU,EAAC,KAAgB,OAAb7B,IAAI8B,QAAQ;4BAAG;wBACnH;;wBARK;wBAAA;;;iCAAA,6BAAA;gCAAA;;;gCAAA;sCAAA;;;;oBASL;;wBAAQ,qBAAGpB,KAAKqB,OAAO,IACpBC,IAAI,CAAC,SAACC,GAAGC;mCAAMA,CAAC,CAAC,EAAE,CAACpB,KAAK,GAAGmB,CAAC,CAAC,EAAE,CAACnB,KAAK;2BACtCqB,KAAK,CAAC,GAAG5B,OACTR,GAAG,CAAC;qEAAEI,kBAAM+B;mCAAQ;gCAAE/B,MAAAA;gCAAMyB,OAAOM,EAAEN,KAAK;gCAAEQ,YAAYC,IAAAA,mBAAQ,EAACH,EAAEpB,KAAK;4BAAE;;;;;IAC/E;;AAIO,SAAerB,YAAYE,IAAgB,EAAEQ,IAAY,EAAEmC,IAAgE;;YAC1HC,YACAC,YAEAC,QAEAhC,MACAb,MACAc,MACD,2BAAA,mBAAA,gBAAA,WAAA,OAAMV,KAEH0C,OACD,4BAAA,oBAAA,iBAAA,YAAA,QAAMC,GACL/B,KACEgC,KACG/B,GACHC,OACAC;;;;oBAhBS;;wBAAMpB,KAAKqB,OAAO,CAAC;;;oBAAhCuB,aAAa;oBACC;;wBAAMA,WAAWtB,GAAG,CAACd;;;oBAAnCqC,aAAc;oBACpB,IAAIA,WAAW3C,MAAM,KAAK,GAAG;;;;oBACvB4C,SAASI,IAAAA,uBAAY,EAACL,YAAYzC,GAAG,CAAC,SAACC;+BAAS;4BAAE8C,GAAG,IAAI1B,UAAUpB,IAAIE,MAAM,CAACmB,MAAM,EAAErB,IAAIE,MAAM,CAACoB,UAAU,EAAEtB,IAAIE,MAAM,CAACuB,UAAU;4BAAGxB,OAAOD,IAAIC,KAAK;wBAAC;;oBAE/I;;wBAAMN,KAAKqB,OAAO,CAAC;;;oBAA1BP,OAAO;oBACC;;wBAAMA,KAAKQ,GAAG;;;oBAAtBrB,OAAQ;oBACRc,OAAO,IAAIQ;oBACZ,kCAAA,2BAAA;;wBAAL,IAAK,YAAatB,2BAAb,6BAAA,QAAA,yBAAA,iCAAmB;4BAAbI,MAAN;4BACH,IAAIA,IAAIG,IAAI,KAAKA,QAAQmC,KAAKS,OAAO,CAAC5B,GAAG,CAACnB,IAAIG,IAAI,KAAMmC,KAAK9B,OAAO,IAAI,CAAC8B,KAAK9B,OAAO,CAACW,GAAG,CAACnB,IAAIG,IAAI,GAAI;4BAChGuC,QAAQ,IAAItB,UAAUpB,IAAIE,MAAM,CAACmB,MAAM,EAAErB,IAAIE,MAAM,CAACoB,UAAU,EAAEtB,IAAIE,MAAM,CAACuB,UAAU;4BACtF,mCAAA,4BAAA;;gCAAL,IAAK,aAAWgB,6BAAX,8BAAA,SAAA,0BAAA,kCAAmB;oCAAbE,IAAN;oCACC/B,MAAM;oCACJgC,MAAMrB,KAAKC,GAAG,CAACmB,EAAEG,CAAC,CAACjD,MAAM,EAAE6C,MAAM7C,MAAM;oCAC7C,IAASgB,IAAI,GAAGA,IAAI+B,KAAK/B,IAAKD,OAAO+B,EAAEG,CAAC,CAACjC,EAAE,GAAG6B,KAAK,CAAC7B,EAAE;oCAChDC,QAAQF,MAAM+B,EAAE1C,KAAK,GAAGD,IAAIC,KAAK;oCACjCc,WAAWL,KAAKgB,GAAG,CAAC1B,IAAIG,IAAI;oCAClC,IAAIY,aAAaiC,aAAalC,QAAQC,UAAUL,KAAKiB,GAAG,CAAC3B,IAAIG,IAAI,EAAEW;gCACrE;;gCAPK;gCAAA;;;yCAAA,8BAAA;wCAAA;;;wCAAA;8CAAA;;;;wBAQP;;wBAXK;wBAAA;;;iCAAA,6BAAA;gCAAA;;;gCAAA;sCAAA;;;;oBAaL;;wBAAQ,qBAAGJ,KAAKqB,OAAO,IACpBC,IAAI,CAAC,SAACC,GAAGC;mCAAMA,CAAC,CAAC,EAAE,GAAGD,CAAC,CAAC,EAAE;2BAC1BE,KAAK,CAAC,GAAGG,KAAKW,CAAC,EACflD,GAAG,CAAC;qEAAEmD,eAAGpC;mCAAY;gCAAEX,MAAM+C;gCAAGd,YAAYC,IAAAA,mBAAQ,EAACvB;4BAAO;;;;;IACjE"}

package/dist/cjs/store/turso/connection.d.cts

@@ -0,0 +1,3 @@
+import type { Database } from '@tursodatabase/database';
+import type { Connection } from '../types.js';
+export declare function createConnection(db: Database): Connection;

package/dist/cjs/store/turso/connection.d.ts

@@ -0,0 +1,3 @@
+import type { Database } from '@tursodatabase/database';
+import type { Connection } from '../types.js';
+export declare function createConnection(db: Database): Connection;