sensemaking 0.25.1 → 0.26.0

package/dist/cjs/store/turso/connection.js

@@ -9,6 +9,9 @@ function _export(target, all) {
     });
 }
 _export(exports, {
+    get INSERT_BIND_BUDGET () {
+        return INSERT_BIND_BUDGET;
+    },
     get cacheFilePath () {
         return cacheFilePath;
     },
@@ -26,6 +29,7 @@ _export(exports, {
     }
 });
 var _promises = require("node:fs/promises");
+var _promises1 = require("node:timers/promises");
 var _batchts = require("../batch.js");
 var _sharedts = require("../shared.js");
 var _transactionts = require("../transaction.js");
@@ -222,6 +226,9 @@ function _async_to_generator(fn) {
         });
     };
 }
+function _await_async_generator(value) {
+    return new _overload_yield(value, 0);
+}
 function _class_call_check(instance, Constructor) {
     if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
 }
@@ -421,25 +428,191 @@ function _wrap_async_generator(fn) {
         return new _async_generator(fn.apply(this, arguments));
     };
 }
-// @tursodatabase/database/compat offers a synchronous escape hatch, but it measured only 4-12%
-// faster than this promise client, so this wraps the async client in the same Connection/Statement shape 1:1.
+var INSERT_BIND_BUDGET = 8192;
+function closeStatement(stmt, failed, failure) {
+    return _async_to_generator(function() {
+        var cleanup;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    _state.trys.push([
+                        0,
+                        2,
+                        3,
+                        5
+                    ]);
+                    return [
+                        4,
+                        stmt.close()
+                    ];
+                case 1:
+                    _state.sent();
+                    return [
+                        3,
+                        5
+                    ];
+                case 2:
+                    cleanup = _state.sent();
+                    if (failed) throw new AggregateError([
+                        failure,
+                        cleanup
+                    ], 'Turso statement execution and cleanup failed');
+                    throw cleanup;
+                case 3:
+                    // Native result cleanup can wait on the event loop even after the statement is finalized.
+                    return [
+                        4,
+                        (0, _promises1.setImmediate)()
+                    ];
+                case 4:
+                    _state.sent();
+                    return [
+                        7
+                    ];
+                case 5:
+                    return [
+                        2
+                    ];
+            }
+        });
+    })();
+}
+// Native statements are finalized after execution. Reusing the portable statement prepares
+// it again; column metadata remains available after execution without retaining native state.
 var TursoStatementWrapper = /*#__PURE__*/ function() {
     "use strict";
-    function TursoStatementWrapper(stmt) {
+    function TursoStatementWrapper(db, sql, stmt) {
         _class_call_check(this, TursoStatementWrapper);
+        this.readBigInts = false;
+        this.db = db;
+        this.sql = sql;
         this.stmt = stmt;
+        this.metadata = stmt.columns();
     }
     var _proto = TursoStatementWrapper.prototype;
+    _proto.acquire = function acquire() {
+        return _async_to_generator(function() {
+            var retained, stmt, _tmp, error;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        retained = this.stmt;
+                        this.stmt = null;
+                        if (!(retained !== null && retained !== void 0)) return [
+                            3,
+                            1
+                        ];
+                        _tmp = retained;
+                        return [
+                            3,
+                            3
+                        ];
+                    case 1:
+                        return [
+                            4,
+                            this.db.prepare(this.sql)
+                        ];
+                    case 2:
+                        _tmp = _state.sent();
+                        _state.label = 3;
+                    case 3:
+                        stmt = _tmp;
+                        _state.label = 4;
+                    case 4:
+                        _state.trys.push([
+                            4,
+                            5,
+                            ,
+                            7
+                        ]);
+                        stmt.safeIntegers(this.readBigInts);
+                        return [
+                            3,
+                            7
+                        ];
+                    case 5:
+                        error = _state.sent();
+                        return [
+                            4,
+                            closeStatement(stmt, true, error)
+                        ];
+                    case 6:
+                        _state.sent();
+                        throw error;
+                    case 7:
+                        return [
+                            2,
+                            stmt
+                        ];
+                }
+            });
+        }).call(this);
+    };
+    _proto.execute = function execute(operation) {
+        return _async_to_generator(function() {
+            var stmt, failed, failure, error;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        return [
+                            4,
+                            this.acquire()
+                        ];
+                    case 1:
+                        stmt = _state.sent();
+                        failed = false;
+                        _state.label = 2;
+                    case 2:
+                        _state.trys.push([
+                            2,
+                            4,
+                            5,
+                            7
+                        ]);
+                        return [
+                            4,
+                            operation(stmt)
+                        ];
+                    case 3:
+                        return [
+                            2,
+                            _state.sent()
+                        ];
+                    case 4:
+                        error = _state.sent();
+                        failed = true;
+                        failure = error;
+                        throw error;
+                    case 5:
+                        return [
+                            4,
+                            closeStatement(stmt, failed, failure)
+                        ];
+                    case 6:
+                        _state.sent();
+                        return [
+                            7
+                        ];
+                    case 7:
+                        return [
+                            2
+                        ];
+                }
+            });
+        }).call(this);
+    };
     _proto.run = function run() {
         for(var _len = arguments.length, params = new Array(_len), _key = 0; _key < _len; _key++){
             params[_key] = arguments[_key];
         }
         return _async_to_generator(function() {
-            var _this_stmt;
+            var _stmt;
             return _ts_generator(this, function(_state) {
                 return [
                     2,
-                    (_this_stmt = this.stmt).run.apply(_this_stmt, _to_consumable_array(params))
+                    this.execute(function(stmt) {
+                        return (_stmt = stmt).run.apply(_stmt, _to_consumable_array(params));
+                    })
                 ];
             });
         }).call(this);
@@ -449,11 +622,13 @@ var TursoStatementWrapper = /*#__PURE__*/ function() {
             params[_key] = arguments[_key];
         }
         return _async_to_generator(function() {
-            var _this_stmt;
+            var _stmt;
             return _ts_generator(this, function(_state) {
                 return [
                     2,
-                    (_this_stmt = this.stmt).get.apply(_this_stmt, _to_consumable_array(params))
+                    this.execute(function(stmt) {
+                        return (_stmt = stmt).get.apply(_stmt, _to_consumable_array(params));
+                    })
                 ];
             });
         }).call(this);
@@ -463,11 +638,13 @@ var TursoStatementWrapper = /*#__PURE__*/ function() {
             params[_key] = arguments[_key];
         }
         return _async_to_generator(function() {
-            var _this_stmt;
+            var _stmt;
             return _ts_generator(this, function(_state) {
                 return [
                     2,
-                    (_this_stmt = this.stmt).all.apply(_this_stmt, _to_consumable_array(params))
+                    this.execute(function(stmt) {
+                        return (_stmt = stmt).all.apply(_stmt, _to_consumable_array(params));
+                    })
                 ];
             });
         }).call(this);
@@ -477,16 +654,51 @@ var TursoStatementWrapper = /*#__PURE__*/ function() {
             params[_key] = arguments[_key];
         }
         return _wrap_async_generator(function() {
-            var _this_stmt;
+            var stmt, failed, failure, _stmt, error;
             return _ts_generator(this, function(_state) {
                 switch(_state.label){
                     case 0:
                         return [
-                            5,
-                            _ts_values(_async_generator_delegate(_async_iterator((_this_stmt = this.stmt).iterate.apply(_this_stmt, _to_consumable_array(params)))))
+                            4,
+                            _await_async_generator(this.acquire())
                         ];
                     case 1:
+                        stmt = _state.sent();
+                        failed = false;
+                        _state.label = 2;
+                    case 2:
+                        _state.trys.push([
+                            2,
+                            4,
+                            5,
+                            7
+                        ]);
+                        return [
+                            5,
+                            _ts_values(_async_generator_delegate(_async_iterator((_stmt = stmt).iterate.apply(_stmt, _to_consumable_array(params)))))
+                        ];
+                    case 3:
                         _state.sent();
+                        return [
+                            3,
+                            7
+                        ];
+                    case 4:
+                        error = _state.sent();
+                        failed = true;
+                        failure = error;
+                        throw error;
+                    case 5:
+                        return [
+                            4,
+                            _await_async_generator(closeStatement(stmt, failed, failure))
+                        ];
+                    case 6:
+                        _state.sent();
+                        return [
+                            7
+                        ];
+                    case 7:
                         return [
                             2
                         ];
@@ -495,10 +707,10 @@ var TursoStatementWrapper = /*#__PURE__*/ function() {
         }).call(this);
     };
     _proto.columns = function columns() {
-        return this.stmt.columns();
+        return this.metadata;
     };
     _proto.setReadBigInts = function setReadBigInts(enabled) {
-        this.stmt.safeIntegers(enabled);
+        this.readBigInts = enabled;
     };
     return TursoStatementWrapper;
 }();
@@ -723,29 +935,48 @@ function createConnection(db) {
         },
         prepare: function prepare(sql) {
             return _async_to_generator(function() {
-                var _;
+                var rewritten, stmt, error;
                 return _ts_generator(this, function(_state) {
                     switch(_state.label){
                         case 0:
-                            _ = TursoStatementWrapper.bind;
+                            rewritten = (0, _sqlfunctionsts.rewriteFunctions)(sql);
                             return [
                                 4,
-                                db.prepare((0, _sqlfunctionsts.rewriteFunctions)(sql))
+                                db.prepare(rewritten)
                             ];
                         case 1:
+                            stmt = _state.sent();
+                            _state.label = 2;
+                        case 2:
+                            _state.trys.push([
+                                2,
+                                3,
+                                ,
+                                5
+                            ]);
                             return [
                                 2,
-                                new (_.apply(TursoStatementWrapper, [
-                                    void 0,
-                                    _state.sent()
-                                ]))
+                                new TursoStatementWrapper(db, rewritten, stmt)
+                            ];
+                        case 3:
+                            error = _state.sent();
+                            return [
+                                4,
+                                closeStatement(stmt, true, error)
+                            ];
+                        case 4:
+                            _state.sent();
+                            throw error;
+                        case 5:
+                            return [
+                                2
                             ];
                     }
                 });
             })();
         },
-        runBatch: // Folds a plain INSERT into one multi-row VALUES statement (shared rewriteInsert, ../batch.ts):
-        // no bind-variable ceiling to chunk against, measured empirically. UPDATE/DELETE keep the per-row loop.
+        runBatch: // Fold INSERTs into bounded multi-row statements in one transaction. UPDATE/DELETE keep
+        // the per-row loop; each native statement owns its finalization and cleanup turn.
         function runBatch(sql, paramRows) {
             return _async_to_generator(function() {
                 return _ts_generator(this, function(_state) {
@@ -758,114 +989,97 @@ function createConnection(db) {
                                 4,
                                 (0, _transactionts.withTransaction)(conn, function() {
                                     return _async_to_generator(function() {
-                                        var rewritten, stmt, stmt1, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, row, err;
+                                        var shape, batchRows, offset, _ref, rows, rewritten, stmt, failed, failure, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, row, err, error;
                                         return _ts_generator(this, function(_state) {
                                             switch(_state.label){
                                                 case 0:
-                                                    rewritten = (0, _batchts.rewriteInsert)(sql, paramRows.length);
-                                                    if (!rewritten) return [
+                                                    shape = (0, _batchts.rewriteInsert)(sql, 1);
+                                                    batchRows = shape ? Math.max(1, Math.floor(INSERT_BIND_BUDGET / shape.width)) : paramRows.length;
+                                                    offset = 0;
+                                                    _state.label = 1;
+                                                case 1:
+                                                    if (!(offset < paramRows.length)) return [
                                                         3,
-                                                        7
+                                                        18
                                                     ];
+                                                    rows = shape ? paramRows.slice(offset, offset + batchRows) : paramRows;
+                                                    rewritten = shape ? (0, _batchts.rewriteInsert)(sql, rows.length) : null;
                                                     return [
                                                         4,
-                                                        db.prepare(rewritten.sql)
+                                                        db.prepare((_ref = rewritten === null || rewritten === void 0 ? void 0 : rewritten.sql) !== null && _ref !== void 0 ? _ref : sql)
                                                     ];
-                                                case 1:
-                                                    stmt = _state.sent();
-                                                    _state.label = 2;
                                                 case 2:
+                                                    stmt = _state.sent();
+                                                    failed = false;
+                                                    failure = void 0;
+                                                    _state.label = 3;
+                                                case 3:
                                                     _state.trys.push([
-                                                        2,
-                                                        ,
-                                                        4,
-                                                        6
+                                                        3,
+                                                        14,
+                                                        15,
+                                                        17
                                                     ]);
-                                                    // One flat array, not spread: spreading tens of thousands of args hits a JS call-stack
-                                                    // limit well before turso enforces any variable-count ceiling (measured; see PLAN.md).
-                                                    return [
-                                                        4,
-                                                        stmt.run(paramRows.flat())
-                                                    ];
-                                                case 3:
-                                                    _state.sent();
-                                                    return [
+                                                    if (!rewritten) return [
                                                         3,
-                                                        6
+                                                        5
                                                     ];
-                                                case 4:
+                                                    // Pass one array: spreading a wide tuple can exceed the JS argument limit.
                                                     return [
                                                         4,
-                                                        stmt.close()
+                                                        stmt.run(rows.flat())
                                                     ];
-                                                case 5:
+                                                case 4:
                                                     _state.sent();
                                                     return [
-                                                        7
-                                                    ];
-                                                case 6:
-                                                    return [
-                                                        2
-                                                    ];
-                                                case 7:
-                                                    return [
-                                                        4,
-                                                        db.prepare(sql)
+                                                        3,
+                                                        13
                                                     ];
-                                                case 8:
-                                                    stmt1 = _state.sent();
-                                                    _state.label = 9;
-                                                case 9:
-                                                    _state.trys.push([
-                                                        9,
-                                                        ,
-                                                        18,
-                                                        20
-                                                    ]);
+                                                case 5:
                                                     _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
-                                                    _state.label = 10;
-                                                case 10:
+                                                    _state.label = 6;
+                                                case 6:
                                                     _state.trys.push([
-                                                        10,
-                                                        15,
-                                                        16,
-                                                        17
+                                                        6,
+                                                        11,
+                                                        12,
+                                                        13
                                                     ]);
-                                                    _iterator = paramRows[Symbol.iterator]();
-                                                    _state.label = 11;
-                                                case 11:
+                                                    _iterator = rows[Symbol.iterator]();
+                                                    _state.label = 7;
+                                                case 7:
                                                     if (!!(_iteratorNormalCompletion = (_step = _iterator.next()).done)) return [
                                                         3,
-                                                        14
+                                                        10
                                                     ];
                                                     row = _step.value;
                                                     return [
                                                         4,
-                                                        stmt1.run(row)
+                                                        stmt.run(row)
                                                     ];
-                                                case 12:
+                                                case 8:
                                                     _state.sent();
-                                                    _state.label = 13;
-                                                case 13:
+                                                    _state.label = 9;
+                                                case 9:
                                                     _iteratorNormalCompletion = true;
                                                     return [
                                                         3,
-                                                        11
+                                                        7
                                                     ];
-                                                case 14:
+                                                case 10:
                                                     return [
                                                         3,
-                                                        17
+                                                        13
                                                     ];
-                                                case 15:
+                                                case 11:
                                                     err = _state.sent();
                                                     _didIteratorError = true;
                                                     _iteratorError = err;
                                                     return [
                                                         3,
-                                                        17
+                                                        13
                                                     ];
-                                                case 16:
+                                                case 12:
                                                     try {
                                                         if (!_iteratorNormalCompletion && _iterator.return != null) {
                                                             _iterator.return();
@@ -878,22 +1092,33 @@ function createConnection(db) {
                                                     return [
                                                         7
                                                     ];
-                                                case 17:
+                                                case 13:
                                                     return [
                                                         3,
-                                                        20
+                                                        17
                                                     ];
-                                                case 18:
+                                                case 14:
+                                                    error = _state.sent();
+                                                    failed = true;
+                                                    failure = error;
+                                                    throw error;
+                                                case 15:
                                                     return [
                                                         4,
-                                                        stmt1.close()
+                                                        closeStatement(stmt, failed, failure)
                                                     ];
-                                                case 19:
+                                                case 16:
                                                     _state.sent();
                                                     return [
                                                         7
                                                     ];
-                                                case 20:
+                                                case 17:
+                                                    offset += batchRows;
+                                                    return [
+                                                        3,
+                                                        1
+                                                    ];
+                                                case 18:
                                                     return [
                                                         2
                                                     ];

package/dist/cjs/store/turso/connection.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/store/turso/connection.ts"],"sourcesContent":["import { stat } from 'node:fs/promises';\nimport type { Database } from '@tursodatabase/database';\nimport { rewriteInsert } from '../batch.ts';\nimport { setMeta } from '../shared.ts';\nimport { BEGIN_WRITE, withTransaction } from '../transaction.ts';\nimport type { Connection, RunResult, Statement } from '../types.ts';\nimport { CONNECT_OPTS, tursoApi } from './native.ts';\nimport { rewriteFunctions } from './sql-functions.ts';\n\n// The client's own Statement class isn't re-exported by name from '@tursodatabase/database',\n// so its type is derived structurally from Database.prepare()'s return type instead.\ntype TursoStatement = Awaited<ReturnType<Database['prepare']>>;\n\n// @tursodatabase/database/compat offers a synchronous escape hatch, but it measured only 4-12%\n// faster than this promise client, so this wraps the async client in the same Connection/Statement shape 1:1.\nclass TursoStatementWrapper implements Statement {\n  private stmt: TursoStatement;\n\n  constructor(stmt: TursoStatement) {\n    this.stmt = stmt;\n  }\n\n  async run(...params: unknown[]): Promise<RunResult> {\n    return this.stmt.run(...params);\n  }\n\n  async get(...params: unknown[]): Promise<unknown> {\n    return this.stmt.get(...params);\n  }\n\n  async all(...params: unknown[]): Promise<unknown[]> {\n    return this.stmt.all(...params);\n  }\n\n  async *iterate(...params: unknown[]): AsyncIterable<unknown> {\n    yield* this.stmt.iterate(...params);\n  }\n\n  columns(): Array<{ name: string }> {\n    return this.stmt.columns();\n  }\n\n  setReadBigInts(enabled: boolean): void {\n    this.stmt.safeIntegers(enabled);\n  }\n}\n\n// This client leaves the WAL behind for the next opener, where node:sqlite checkpoints on the last\n// close, so a tree reconciled over and over grows one without bound. Best-effort: close must not throw.\nexport async function checkpointWal(db: Database): Promise<void> {\n  try {\n    await db.exec('PRAGMA wal_checkpoint(TRUNCATE)');\n  } catch (err) {\n    console.error(`sense: turso WAL checkpoint failed, the -wal file will keep growing until one succeeds: ${(err as Error).message}`);\n  }\n}\n\n// The main cache file's path, or null when unresolvable. The store holds a Database and\n// Connection, not a path (PLAN 3.52), so the path is read from the database itself.\nexport async function cacheFilePath(conn: Connection): Promise<string | null> {\n  const rows = (await (await conn.prepare('PRAGMA database_list')).all()) as Array<{ name: string; file: string }>;\n  return rows.find((r) => r.name === 'main')?.file || null;\n}\n\nexport async function fileSize(path: string): Promise<number | null> {\n  try {\n    return (await stat(path)).size;\n  } catch {\n    return null;\n  }\n}\n\n// Reclaims turso#8170's FTS space amplification (PLAN 3.41), on a throwaway connection after the\n// store's own has closed: `vacuum` doubles incremental reconcile cost merely by being enabled (3.54).\nexport async function reclaimSpace(path: string): Promise<void> {\n  try {\n    const turso = await tursoApi();\n    const db = await turso.connect(path, { ...CONNECT_OPTS, experimental: [...CONNECT_OPTS.experimental, 'vacuum'] });\n    try {\n      await db.exec('VACUUM');\n      const size = await fileSize(path);\n      // Recorded here, not by the caller: this connection is the only one still open on the file.\n      if (size !== null) await setMeta(createConnection(db), 'compact_size', String(size));\n      await checkpointWal(db);\n    } finally {\n      await db.close();\n    }\n  } catch (err) {\n    console.error(`sense: turso VACUUM failed, the cache will keep the space until one succeeds: ${(err as Error).message}`);\n  }\n}\n\nexport function createConnection(db: Database): Connection {\n  const conn: Connection = {\n    async exec(sql: string): Promise<void> {\n      await db.exec(sql);\n    },\n    async prepare(sql: string): Promise<Statement> {\n      return new TursoStatementWrapper(await db.prepare(rewriteFunctions(sql)));\n    },\n    // Folds a plain INSERT into one multi-row VALUES statement (shared rewriteInsert, ../batch.ts):\n    // no bind-variable ceiling to chunk against, measured empirically. UPDATE/DELETE keep the per-row loop.\n    async runBatch(sql: string, paramRows: unknown[][]): Promise<void> {\n      if (paramRows.length === 0) return;\n      await withTransaction(\n        conn,\n        async () => {\n          const rewritten = rewriteInsert(sql, paramRows.length);\n          if (rewritten) {\n            const stmt = await db.prepare(rewritten.sql);\n            try {\n              // One flat array, not spread: spreading tens of thousands of args hits a JS call-stack\n              // limit well before turso enforces any variable-count ceiling (measured; see PLAN.md).\n              await stmt.run(paramRows.flat());\n            } finally {\n              await stmt.close();\n            }\n            return;\n          }\n          // Finalized here because nothing else will: open() hands back a connection the caller\n          // can hold across many batches, and nothing else owns this statement's lifetime.\n          const stmt = await db.prepare(sql);\n          try {\n            for (const row of paramRows) await stmt.run(row);\n          } finally {\n            await stmt.close();\n          }\n        },\n        BEGIN_WRITE\n      );\n    },\n  };\n  return conn;\n}\n"],"names":["cacheFilePath","checkpointWal","createConnection","fileSize","reclaimSpace","TursoStatementWrapper","stmt","run","params","get","all","iterate","columns","setReadBigInts","enabled","safeIntegers","db","err","exec","console","error","message","conn","rows","prepare","find","r","name","file","path","stat","size","turso","tursoApi","connect","CONNECT_OPTS","experimental","setMeta","String","close","sql","rewriteFunctions","runBatch","paramRows","length","withTransaction","rewritten","row","rewriteInsert","flat","BEGIN_WRITE"],"mappings":"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"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/ai/sensemaking/src/store/turso/connection.ts"],"sourcesContent":["import { stat } from 'node:fs/promises';\nimport { setImmediate } from 'node:timers/promises';\nimport type { Database } from '@tursodatabase/database';\nimport { rewriteInsert } from '../batch.ts';\nimport { setMeta } from '../shared.ts';\nimport { BEGIN_WRITE, withTransaction } from '../transaction.ts';\nimport type { Connection, RunResult, Statement } from '../types.ts';\nimport { CONNECT_OPTS, tursoApi } from './native.ts';\nimport { rewriteFunctions } from './sql-functions.ts';\n\n// The client's own Statement class isn't re-exported by name from '@tursodatabase/database',\n// so its type is derived structurally from Database.prepare()'s return type instead.\ntype TursoStatement = Awaited<ReturnType<Database['prepare']>>;\n\n// Bound native multi-row compilation work; this is not Turso's variable-count limit.\nexport const INSERT_BIND_BUDGET = 8192;\n\nasync function closeStatement(stmt: TursoStatement, failed: boolean, failure: unknown): Promise<void> {\n  try {\n    await stmt.close();\n  } catch (cleanup) {\n    if (failed) throw new AggregateError([failure, cleanup], 'Turso statement execution and cleanup failed');\n    throw cleanup;\n  } finally {\n    // Native result cleanup can wait on the event loop even after the statement is finalized.\n    await setImmediate();\n  }\n}\n\n// Native statements are finalized after execution. Reusing the portable statement prepares\n// it again; column metadata remains available after execution without retaining native state.\nclass TursoStatementWrapper implements Statement {\n  private stmt: TursoStatement | null;\n  private readonly metadata: Array<{ name: string }>;\n  private readBigInts = false;\n  private readonly db: Database;\n  private readonly sql: string;\n\n  constructor(db: Database, sql: string, stmt: TursoStatement) {\n    this.db = db;\n    this.sql = sql;\n    this.stmt = stmt;\n    this.metadata = stmt.columns();\n  }\n\n  private async acquire(): Promise<TursoStatement> {\n    const retained = this.stmt;\n    this.stmt = null;\n    const stmt = retained ?? (await this.db.prepare(this.sql));\n    try {\n      stmt.safeIntegers(this.readBigInts);\n    } catch (error) {\n      await closeStatement(stmt, true, error);\n      throw error;\n    }\n    return stmt;\n  }\n\n  private async execute<T>(operation: (stmt: TursoStatement) => Promise<T>): Promise<T> {\n    const stmt = await this.acquire();\n    let failed = false;\n    let failure: unknown;\n    try {\n      return await operation(stmt);\n    } catch (error) {\n      failed = true;\n      failure = error;\n      throw error;\n    } finally {\n      await closeStatement(stmt, failed, failure);\n    }\n  }\n\n  async run(...params: unknown[]): Promise<RunResult> {\n    return this.execute((stmt) => stmt.run(...params));\n  }\n\n  async get(...params: unknown[]): Promise<unknown> {\n    return this.execute((stmt) => stmt.get(...params));\n  }\n\n  async all(...params: unknown[]): Promise<unknown[]> {\n    return this.execute((stmt) => stmt.all(...params));\n  }\n\n  async *iterate(...params: unknown[]): AsyncIterable<unknown> {\n    const stmt = await this.acquire();\n    let failed = false;\n    let failure: unknown;\n    try {\n      yield* stmt.iterate(...params);\n    } catch (error) {\n      failed = true;\n      failure = error;\n      throw error;\n    } finally {\n      await closeStatement(stmt, failed, failure);\n    }\n  }\n\n  columns(): Array<{ name: string }> {\n    return this.metadata;\n  }\n\n  setReadBigInts(enabled: boolean): void {\n    this.readBigInts = enabled;\n  }\n}\n\n// This client leaves the WAL behind for the next opener, where node:sqlite checkpoints on the last\n// close, so a tree reconciled over and over grows one without bound. Best-effort: close must not throw.\nexport async function checkpointWal(db: Database): Promise<void> {\n  try {\n    await db.exec('PRAGMA wal_checkpoint(TRUNCATE)');\n  } catch (err) {\n    console.error(`sense: turso WAL checkpoint failed, the -wal file will keep growing until one succeeds: ${(err as Error).message}`);\n  }\n}\n\n// The main cache file's path, or null when unresolvable. The store holds a Database and\n// Connection, not a path (PLAN 3.52), so the path is read from the database itself.\nexport async function cacheFilePath(conn: Connection): Promise<string | null> {\n  const rows = (await (await conn.prepare('PRAGMA database_list')).all()) as Array<{ name: string; file: string }>;\n  return rows.find((r) => r.name === 'main')?.file || null;\n}\n\nexport async function fileSize(path: string): Promise<number | null> {\n  try {\n    return (await stat(path)).size;\n  } catch {\n    return null;\n  }\n}\n\n// Reclaims turso#8170's FTS space amplification (PLAN 3.41), on a throwaway connection after the\n// store's own has closed: `vacuum` doubles incremental reconcile cost merely by being enabled (3.54).\nexport async function reclaimSpace(path: string): Promise<void> {\n  try {\n    const turso = await tursoApi();\n    const db = await turso.connect(path, { ...CONNECT_OPTS, experimental: [...CONNECT_OPTS.experimental, 'vacuum'] });\n    try {\n      await db.exec('VACUUM');\n      const size = await fileSize(path);\n      // Recorded here, not by the caller: this connection is the only one still open on the file.\n      if (size !== null) await setMeta(createConnection(db), 'compact_size', String(size));\n      await checkpointWal(db);\n    } finally {\n      await db.close();\n    }\n  } catch (err) {\n    console.error(`sense: turso VACUUM failed, the cache will keep the space until one succeeds: ${(err as Error).message}`);\n  }\n}\n\nexport function createConnection(db: Database): Connection {\n  const conn: Connection = {\n    async exec(sql: string): Promise<void> {\n      await db.exec(sql);\n    },\n    async prepare(sql: string): Promise<Statement> {\n      const rewritten = rewriteFunctions(sql);\n      const stmt = await db.prepare(rewritten);\n      try {\n        return new TursoStatementWrapper(db, rewritten, stmt);\n      } catch (error) {\n        await closeStatement(stmt, true, error);\n        throw error;\n      }\n    },\n    // Fold INSERTs into bounded multi-row statements in one transaction. UPDATE/DELETE keep\n    // the per-row loop; each native statement owns its finalization and cleanup turn.\n    async runBatch(sql: string, paramRows: unknown[][]): Promise<void> {\n      if (paramRows.length === 0) return;\n      await withTransaction(\n        conn,\n        async () => {\n          const shape = rewriteInsert(sql, 1);\n          const batchRows = shape ? Math.max(1, Math.floor(INSERT_BIND_BUDGET / shape.width)) : paramRows.length;\n          for (let offset = 0; offset < paramRows.length; offset += batchRows) {\n            const rows = shape ? paramRows.slice(offset, offset + batchRows) : paramRows;\n            const rewritten = shape ? rewriteInsert(sql, rows.length) : null;\n            const stmt = await db.prepare(rewritten?.sql ?? sql);\n            let failed = false;\n            let failure: unknown;\n            try {\n              if (rewritten) {\n                // Pass one array: spreading a wide tuple can exceed the JS argument limit.\n                await stmt.run(rows.flat());\n              } else {\n                for (const row of rows) await stmt.run(row);\n              }\n            } catch (error) {\n              failed = true;\n              failure = error;\n              throw error;\n            } finally {\n              await closeStatement(stmt, failed, failure);\n            }\n          }\n        },\n        BEGIN_WRITE\n      );\n    },\n  };\n  return conn;\n}\n"],"names":["INSERT_BIND_BUDGET","cacheFilePath","checkpointWal","createConnection","fileSize","reclaimSpace","closeStatement","stmt","failed","failure","cleanup","close","AggregateError","setImmediate","TursoStatementWrapper","db","sql","readBigInts","metadata","columns","acquire","retained","error","prepare","safeIntegers","execute","operation","run","params","get","all","iterate","setReadBigInts","enabled","err","exec","console","message","conn","rows","find","r","name","file","path","stat","size","turso","tursoApi","connect","CONNECT_OPTS","experimental","setMeta","String","rewritten","rewriteFunctions","runBatch","paramRows","length","withTransaction","shape","batchRows","offset","row","rewriteInsert","Math","max","floor","width","slice","flat","BEGIN_WRITE"],"mappings":"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"}

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

@@ -3,7 +3,7 @@ import type { ResolvedConfig } from '../../config/index.js';
 import type { InternalOpenOptions, OpenResult } from '../open.js';
 import type { OpenDialect } from '../types.js';
 export declare const DB_FILENAME = "cache.turso.db";
-export declare const SCHEMA_VERSION = "9";
+export declare const SCHEMA_VERSION = "10";
 export type { OpenResult };
 export declare const tursoOpenDialect: OpenDialect<Database>;
 export declare function openTurso(cfg: ResolvedConfig, options?: InternalOpenOptions): Promise<OpenResult>;