@mndrk/agx 2.0.34 → 2.0.38

package/cloud-runtime/standalone/worker/index.js

@@ -8,9 +8,6 @@ var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
-var __commonJS = (cb, mod) => function __require() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -33,775 +30,46 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// ../agx-cloud/node_modules/better-sqlite3/lib/util.js
-var require_util = __commonJS({
-  "../agx-cloud/node_modules/better-sqlite3/lib/util.js"(exports2) {
-    "use strict";
-    exports2.getBooleanOption = (options, key) => {
-      let value = false;
-      if (key in options && typeof (value = options[key]) !== "boolean") {
-        throw new TypeError(`Expected the "${key}" option to be a boolean`);
-      }
-      return value;
-    };
-    exports2.cppdb = Symbol();
-    exports2.inspect = Symbol.for("nodejs.util.inspect.custom");
-  }
-});
-
-// ../agx-cloud/node_modules/better-sqlite3/lib/sqlite-error.js
-var require_sqlite_error = __commonJS({
-  "../agx-cloud/node_modules/better-sqlite3/lib/sqlite-error.js"(exports2, module2) {
-    "use strict";
-    var descriptor = { value: "SqliteError", writable: true, enumerable: false, configurable: true };
-    function SqliteError(message, code) {
-      if (new.target !== SqliteError) {
-        return new SqliteError(message, code);
-      }
-      if (typeof code !== "string") {
-        throw new TypeError("Expected second argument to be a string");
-      }
-      Error.call(this, message);
-      descriptor.value = "" + message;
-      Object.defineProperty(this, "message", descriptor);
-      Error.captureStackTrace(this, SqliteError);
-      this.code = code;
-    }
-    Object.setPrototypeOf(SqliteError, Error);
-    Object.setPrototypeOf(SqliteError.prototype, Error.prototype);
-    Object.defineProperty(SqliteError.prototype, "name", descriptor);
-    module2.exports = SqliteError;
-  }
-});
-
-// ../agx-cloud/node_modules/file-uri-to-path/index.js
-var require_file_uri_to_path = __commonJS({
-  "../agx-cloud/node_modules/file-uri-to-path/index.js"(exports2, module2) {
-    var sep = require("path").sep || "/";
-    module2.exports = fileUriToPath;
-    function fileUriToPath(uri) {
-      if ("string" != typeof uri || uri.length <= 7 || "file://" != uri.substring(0, 7)) {
-        throw new TypeError("must pass in a file:// URI to convert to a file path");
-      }
-      var rest = decodeURI(uri.substring(7));
-      var firstSlash = rest.indexOf("/");
-      var host = rest.substring(0, firstSlash);
-      var path11 = rest.substring(firstSlash + 1);
-      if ("localhost" == host) host = "";
-      if (host) {
-        host = sep + sep + host;
-      }
-      path11 = path11.replace(/^(.+)\|/, "$1:");
-      if (sep == "\\") {
-        path11 = path11.replace(/\//g, "\\");
-      }
-      if (/^.+\:/.test(path11)) {
-      } else {
-        path11 = sep + path11;
-      }
-      return host + path11;
-    }
+// ../agx-cloud/lib/sqlite-compat.ts
+function pragmaGet(db2, key) {
+  const row = db2.prepare(`PRAGMA ${key}`).get();
+  if (!row) return void 0;
+  const values = Object.values(row);
+  return values.length > 0 ? values[0] : void 0;
+}
+function pragmaAll(db2, key) {
+  return db2.prepare(`PRAGMA ${key}`).all();
+}
+function pragmaSet(db2, pragma) {
+  db2.exec(`PRAGMA ${pragma}`);
+}
+function transaction(db2, fn) {
+  db2.exec("BEGIN");
+  try {
+    const result = fn();
+    db2.exec("COMMIT");
+    return result;
+  } catch (err) {
+    db2.exec("ROLLBACK");
+    throw err;
   }
-});
-
-// ../agx-cloud/node_modules/bindings/bindings.js
-var require_bindings = __commonJS({
-  "../agx-cloud/node_modules/bindings/bindings.js"(exports2, module2) {
-    var fs8 = require("fs");
-    var path11 = require("path");
-    var fileURLToPath = require_file_uri_to_path();
-    var join6 = path11.join;
-    var dirname = path11.dirname;
-    var exists = fs8.accessSync && function(path12) {
-      try {
-        fs8.accessSync(path12);
-      } catch (e) {
-        return false;
-      }
-      return true;
-    } || fs8.existsSync || path11.existsSync;
-    var defaults = {
-      arrow: process.env.NODE_BINDINGS_ARROW || " \u2192 ",
-      compiled: process.env.NODE_BINDINGS_COMPILED_DIR || "compiled",
-      platform: process.platform,
-      arch: process.arch,
-      nodePreGyp: "node-v" + process.versions.modules + "-" + process.platform + "-" + process.arch,
-      version: process.versions.node,
-      bindings: "bindings.node",
-      try: [
-        // node-gyp's linked version in the "build" dir
-        ["module_root", "build", "bindings"],
-        // node-waf and gyp_addon (a.k.a node-gyp)
-        ["module_root", "build", "Debug", "bindings"],
-        ["module_root", "build", "Release", "bindings"],
-        // Debug files, for development (legacy behavior, remove for node v0.9)
-        ["module_root", "out", "Debug", "bindings"],
-        ["module_root", "Debug", "bindings"],
-        // Release files, but manually compiled (legacy behavior, remove for node v0.9)
-        ["module_root", "out", "Release", "bindings"],
-        ["module_root", "Release", "bindings"],
-        // Legacy from node-waf, node <= 0.4.x
-        ["module_root", "build", "default", "bindings"],
-        // Production "Release" buildtype binary (meh...)
-        ["module_root", "compiled", "version", "platform", "arch", "bindings"],
-        // node-qbs builds
-        ["module_root", "addon-build", "release", "install-root", "bindings"],
-        ["module_root", "addon-build", "debug", "install-root", "bindings"],
-        ["module_root", "addon-build", "default", "install-root", "bindings"],
-        // node-pre-gyp path ./lib/binding/{node_abi}-{platform}-{arch}
-        ["module_root", "lib", "binding", "nodePreGyp", "bindings"]
-      ]
-    };
-    function bindings(opts) {
-      if (typeof opts == "string") {
-        opts = { bindings: opts };
-      } else if (!opts) {
-        opts = {};
-      }
-      Object.keys(defaults).map(function(i2) {
-        if (!(i2 in opts)) opts[i2] = defaults[i2];
-      });
-      if (!opts.module_root) {
-        opts.module_root = exports2.getRoot(exports2.getFileName());
-      }
-      if (path11.extname(opts.bindings) != ".node") {
-        opts.bindings += ".node";
-      }
-      var requireFunc = typeof __webpack_require__ === "function" ? __non_webpack_require__ : require;
-      var tries = [], i = 0, l = opts.try.length, n, b, err;
-      for (; i < l; i++) {
-        n = join6.apply(
-          null,
-          opts.try[i].map(function(p) {
-            return opts[p] || p;
-          })
-        );
-        tries.push(n);
-        try {
-          b = opts.path ? requireFunc.resolve(n) : requireFunc(n);
-          if (!opts.path) {
-            b.path = n;
-          }
-          return b;
-        } catch (e) {
-          if (e.code !== "MODULE_NOT_FOUND" && e.code !== "QUALIFIED_PATH_RESOLUTION_FAILED" && !/not find/i.test(e.message)) {
-            throw e;
-          }
-        }
-      }
-      err = new Error(
-        "Could not locate the bindings file. Tried:\n" + tries.map(function(a) {
-          return opts.arrow + a;
-        }).join("\n")
-      );
-      err.tries = tries;
+}
+function transactionFn(db2, fn) {
+  return (...args) => {
+    db2.exec("BEGIN");
+    try {
+      const result = fn(...args);
+      db2.exec("COMMIT");
+      return result;
+    } catch (err) {
+      db2.exec("ROLLBACK");
       throw err;
     }
-    module2.exports = exports2 = bindings;
-    exports2.getFileName = function getFileName(calling_file) {
-      var origPST = Error.prepareStackTrace, origSTL = Error.stackTraceLimit, dummy = {}, fileName;
-      Error.stackTraceLimit = 10;
-      Error.prepareStackTrace = function(e, st) {
-        for (var i = 0, l = st.length; i < l; i++) {
-          fileName = st[i].getFileName();
-          if (fileName !== __filename) {
-            if (calling_file) {
-              if (fileName !== calling_file) {
-                return;
-              }
-            } else {
-              return;
-            }
-          }
-        }
-      };
-      Error.captureStackTrace(dummy);
-      dummy.stack;
-      Error.prepareStackTrace = origPST;
-      Error.stackTraceLimit = origSTL;
-      var fileSchema = "file://";
-      if (fileName.indexOf(fileSchema) === 0) {
-        fileName = fileURLToPath(fileName);
-      }
-      return fileName;
-    };
-    exports2.getRoot = function getRoot(file) {
-      var dir = dirname(file), prev;
-      while (true) {
-        if (dir === ".") {
-          dir = process.cwd();
-        }
-        if (exists(join6(dir, "package.json")) || exists(join6(dir, "node_modules"))) {
-          return dir;
-        }
-        if (prev === dir) {
-          throw new Error(
-            'Could not find module root given file: "' + file + '". Do you have a `package.json` file? '
-          );
-        }
-        prev = dir;
-        dir = join6(dir, "..");
-      }
-    };
-  }
-});
-
-// ../agx-cloud/node_modules/better-sqlite3/lib/methods/wrappers.js
-var require_wrappers = __commonJS({
-  "../agx-cloud/node_modules/better-sqlite3/lib/methods/wrappers.js"(exports2) {
-    "use strict";
-    var { cppdb } = require_util();
-    exports2.prepare = function prepare(sql) {
-      return this[cppdb].prepare(sql, this, false);
-    };
-    exports2.exec = function exec(sql) {
-      this[cppdb].exec(sql);
-      return this;
-    };
-    exports2.close = function close() {
-      this[cppdb].close();
-      return this;
-    };
-    exports2.loadExtension = function loadExtension(...args) {
-      this[cppdb].loadExtension(...args);
-      return this;
-    };
-    exports2.defaultSafeIntegers = function defaultSafeIntegers(...args) {
-      this[cppdb].defaultSafeIntegers(...args);
-      return this;
-    };
-    exports2.unsafeMode = function unsafeMode(...args) {
-      this[cppdb].unsafeMode(...args);
-      return this;
-    };
-    exports2.getters = {
-      name: {
-        get: function name() {
-          return this[cppdb].name;
-        },
-        enumerable: true
-      },
-      open: {
-        get: function open() {
-          return this[cppdb].open;
-        },
-        enumerable: true
-      },
-      inTransaction: {
-        get: function inTransaction() {
-          return this[cppdb].inTransaction;
-        },
-        enumerable: true
-      },
-      readonly: {
-        get: function readonly() {
-          return this[cppdb].readonly;
-        },
-        enumerable: true
-      },
-      memory: {
-        get: function memory() {
-          return this[cppdb].memory;
-        },
-        enumerable: true
-      }
-    };
-  }
-});
-
-// ../agx-cloud/node_modules/better-sqlite3/lib/methods/transaction.js
-var require_transaction = __commonJS({
-  "../agx-cloud/node_modules/better-sqlite3/lib/methods/transaction.js"(exports2, module2) {
-    "use strict";
-    var { cppdb } = require_util();
-    var controllers = /* @__PURE__ */ new WeakMap();
-    module2.exports = function transaction(fn) {
-      if (typeof fn !== "function") throw new TypeError("Expected first argument to be a function");
-      const db2 = this[cppdb];
-      const controller = getController(db2, this);
-      const { apply } = Function.prototype;
-      const properties = {
-        default: { value: wrapTransaction(apply, fn, db2, controller.default) },
-        deferred: { value: wrapTransaction(apply, fn, db2, controller.deferred) },
-        immediate: { value: wrapTransaction(apply, fn, db2, controller.immediate) },
-        exclusive: { value: wrapTransaction(apply, fn, db2, controller.exclusive) },
-        database: { value: this, enumerable: true }
-      };
-      Object.defineProperties(properties.default.value, properties);
-      Object.defineProperties(properties.deferred.value, properties);
-      Object.defineProperties(properties.immediate.value, properties);
-      Object.defineProperties(properties.exclusive.value, properties);
-      return properties.default.value;
-    };
-    var getController = (db2, self) => {
-      let controller = controllers.get(db2);
-      if (!controller) {
-        const shared = {
-          commit: db2.prepare("COMMIT", self, false),
-          rollback: db2.prepare("ROLLBACK", self, false),
-          savepoint: db2.prepare("SAVEPOINT `	_bs3.	`", self, false),
-          release: db2.prepare("RELEASE `	_bs3.	`", self, false),
-          rollbackTo: db2.prepare("ROLLBACK TO `	_bs3.	`", self, false)
-        };
-        controllers.set(db2, controller = {
-          default: Object.assign({ begin: db2.prepare("BEGIN", self, false) }, shared),
-          deferred: Object.assign({ begin: db2.prepare("BEGIN DEFERRED", self, false) }, shared),
-          immediate: Object.assign({ begin: db2.prepare("BEGIN IMMEDIATE", self, false) }, shared),
-          exclusive: Object.assign({ begin: db2.prepare("BEGIN EXCLUSIVE", self, false) }, shared)
-        });
-      }
-      return controller;
-    };
-    var wrapTransaction = (apply, fn, db2, { begin, commit, rollback, savepoint, release, rollbackTo }) => function sqliteTransaction() {
-      let before, after, undo;
-      if (db2.inTransaction) {
-        before = savepoint;
-        after = release;
-        undo = rollbackTo;
-      } else {
-        before = begin;
-        after = commit;
-        undo = rollback;
-      }
-      before.run();
-      try {
-        const result = apply.call(fn, this, arguments);
-        if (result && typeof result.then === "function") {
-          throw new TypeError("Transaction function cannot return a promise");
-        }
-        after.run();
-        return result;
-      } catch (ex) {
-        if (db2.inTransaction) {
-          undo.run();
-          if (undo !== rollback) after.run();
-        }
-        throw ex;
-      }
-    };
-  }
-});
-
-// ../agx-cloud/node_modules/better-sqlite3/lib/methods/pragma.js
-var require_pragma = __commonJS({
-  "../agx-cloud/node_modules/better-sqlite3/lib/methods/pragma.js"(exports2, module2) {
-    "use strict";
-    var { getBooleanOption, cppdb } = require_util();
-    module2.exports = function pragma(source, options) {
-      if (options == null) options = {};
-      if (typeof source !== "string") throw new TypeError("Expected first argument to be a string");
-      if (typeof options !== "object") throw new TypeError("Expected second argument to be an options object");
-      const simple = getBooleanOption(options, "simple");
-      const stmt = this[cppdb].prepare(`PRAGMA ${source}`, this, true);
-      return simple ? stmt.pluck().get() : stmt.all();
-    };
-  }
-});
-
-// ../agx-cloud/node_modules/better-sqlite3/lib/methods/backup.js
-var require_backup = __commonJS({
-  "../agx-cloud/node_modules/better-sqlite3/lib/methods/backup.js"(exports2, module2) {
-    "use strict";
-    var fs8 = require("fs");
-    var path11 = require("path");
-    var { promisify } = require("util");
-    var { cppdb } = require_util();
-    var fsAccess = promisify(fs8.access);
-    module2.exports = async function backup(filename, options) {
-      if (options == null) options = {};
-      if (typeof filename !== "string") throw new TypeError("Expected first argument to be a string");
-      if (typeof options !== "object") throw new TypeError("Expected second argument to be an options object");
-      filename = filename.trim();
-      const attachedName = "attached" in options ? options.attached : "main";
-      const handler = "progress" in options ? options.progress : null;
-      if (!filename) throw new TypeError("Backup filename cannot be an empty string");
-      if (filename === ":memory:") throw new TypeError('Invalid backup filename ":memory:"');
-      if (typeof attachedName !== "string") throw new TypeError('Expected the "attached" option to be a string');
-      if (!attachedName) throw new TypeError('The "attached" option cannot be an empty string');
-      if (handler != null && typeof handler !== "function") throw new TypeError('Expected the "progress" option to be a function');
-      await fsAccess(path11.dirname(filename)).catch(() => {
-        throw new TypeError("Cannot save backup because the directory does not exist");
-      });
-      const isNewFile = await fsAccess(filename).then(() => false, () => true);
-      return runBackup(this[cppdb].backup(this, attachedName, filename, isNewFile), handler || null);
-    };
-    var runBackup = (backup, handler) => {
-      let rate = 0;
-      let useDefault = true;
-      return new Promise((resolve, reject) => {
-        setImmediate(function step() {
-          try {
-            const progress = backup.transfer(rate);
-            if (!progress.remainingPages) {
-              backup.close();
-              resolve(progress);
-              return;
-            }
-            if (useDefault) {
-              useDefault = false;
-              rate = 100;
-            }
-            if (handler) {
-              const ret = handler(progress);
-              if (ret !== void 0) {
-                if (typeof ret === "number" && ret === ret) rate = Math.max(0, Math.min(2147483647, Math.round(ret)));
-                else throw new TypeError("Expected progress callback to return a number or undefined");
-              }
-            }
-            setImmediate(step);
-          } catch (err) {
-            backup.close();
-            reject(err);
-          }
-        });
-      });
-    };
-  }
-});
-
-// ../agx-cloud/node_modules/better-sqlite3/lib/methods/serialize.js
-var require_serialize = __commonJS({
-  "../agx-cloud/node_modules/better-sqlite3/lib/methods/serialize.js"(exports2, module2) {
-    "use strict";
-    var { cppdb } = require_util();
-    module2.exports = function serialize(options) {
-      if (options == null) options = {};
-      if (typeof options !== "object") throw new TypeError("Expected first argument to be an options object");
-      const attachedName = "attached" in options ? options.attached : "main";
-      if (typeof attachedName !== "string") throw new TypeError('Expected the "attached" option to be a string');
-      if (!attachedName) throw new TypeError('The "attached" option cannot be an empty string');
-      return this[cppdb].serialize(attachedName);
-    };
-  }
-});
-
-// ../agx-cloud/node_modules/better-sqlite3/lib/methods/function.js
-var require_function = __commonJS({
-  "../agx-cloud/node_modules/better-sqlite3/lib/methods/function.js"(exports2, module2) {
-    "use strict";
-    var { getBooleanOption, cppdb } = require_util();
-    module2.exports = function defineFunction(name, options, fn) {
-      if (options == null) options = {};
-      if (typeof options === "function") {
-        fn = options;
-        options = {};
-      }
-      if (typeof name !== "string") throw new TypeError("Expected first argument to be a string");
-      if (typeof fn !== "function") throw new TypeError("Expected last argument to be a function");
-      if (typeof options !== "object") throw new TypeError("Expected second argument to be an options object");
-      if (!name) throw new TypeError("User-defined function name cannot be an empty string");
-      const safeIntegers = "safeIntegers" in options ? +getBooleanOption(options, "safeIntegers") : 2;
-      const deterministic = getBooleanOption(options, "deterministic");
-      const directOnly = getBooleanOption(options, "directOnly");
-      const varargs = getBooleanOption(options, "varargs");
-      let argCount = -1;
-      if (!varargs) {
-        argCount = fn.length;
-        if (!Number.isInteger(argCount) || argCount < 0) throw new TypeError("Expected function.length to be a positive integer");
-        if (argCount > 100) throw new RangeError("User-defined functions cannot have more than 100 arguments");
-      }
-      this[cppdb].function(fn, name, argCount, safeIntegers, deterministic, directOnly);
-      return this;
-    };
-  }
-});
-
-// ../agx-cloud/node_modules/better-sqlite3/lib/methods/aggregate.js
-var require_aggregate = __commonJS({
-  "../agx-cloud/node_modules/better-sqlite3/lib/methods/aggregate.js"(exports2, module2) {
-    "use strict";
-    var { getBooleanOption, cppdb } = require_util();
-    module2.exports = function defineAggregate(name, options) {
-      if (typeof name !== "string") throw new TypeError("Expected first argument to be a string");
-      if (typeof options !== "object" || options === null) throw new TypeError("Expected second argument to be an options object");
-      if (!name) throw new TypeError("User-defined function name cannot be an empty string");
-      const start = "start" in options ? options.start : null;
-      const step = getFunctionOption(options, "step", true);
-      const inverse = getFunctionOption(options, "inverse", false);
-      const result = getFunctionOption(options, "result", false);
-      const safeIntegers = "safeIntegers" in options ? +getBooleanOption(options, "safeIntegers") : 2;
-      const deterministic = getBooleanOption(options, "deterministic");
-      const directOnly = getBooleanOption(options, "directOnly");
-      const varargs = getBooleanOption(options, "varargs");
-      let argCount = -1;
-      if (!varargs) {
-        argCount = Math.max(getLength(step), inverse ? getLength(inverse) : 0);
-        if (argCount > 0) argCount -= 1;
-        if (argCount > 100) throw new RangeError("User-defined functions cannot have more than 100 arguments");
-      }
-      this[cppdb].aggregate(start, step, inverse, result, name, argCount, safeIntegers, deterministic, directOnly);
-      return this;
-    };
-    var getFunctionOption = (options, key, required) => {
-      const value = key in options ? options[key] : null;
-      if (typeof value === "function") return value;
-      if (value != null) throw new TypeError(`Expected the "${key}" option to be a function`);
-      if (required) throw new TypeError(`Missing required option "${key}"`);
-      return null;
-    };
-    var getLength = ({ length }) => {
-      if (Number.isInteger(length) && length >= 0) return length;
-      throw new TypeError("Expected function.length to be a positive integer");
-    };
-  }
-});
-
-// ../agx-cloud/node_modules/better-sqlite3/lib/methods/table.js
-var require_table = __commonJS({
-  "../agx-cloud/node_modules/better-sqlite3/lib/methods/table.js"(exports2, module2) {
-    "use strict";
-    var { cppdb } = require_util();
-    module2.exports = function defineTable(name, factory) {
-      if (typeof name !== "string") throw new TypeError("Expected first argument to be a string");
-      if (!name) throw new TypeError("Virtual table module name cannot be an empty string");
-      let eponymous = false;
-      if (typeof factory === "object" && factory !== null) {
-        eponymous = true;
-        factory = defer(parseTableDefinition(factory, "used", name));
-      } else {
-        if (typeof factory !== "function") throw new TypeError("Expected second argument to be a function or a table definition object");
-        factory = wrapFactory(factory);
-      }
-      this[cppdb].table(factory, name, eponymous);
-      return this;
-    };
-    function wrapFactory(factory) {
-      return function virtualTableFactory(moduleName, databaseName, tableName, ...args) {
-        const thisObject = {
-          module: moduleName,
-          database: databaseName,
-          table: tableName
-        };
-        const def = apply.call(factory, thisObject, args);
-        if (typeof def !== "object" || def === null) {
-          throw new TypeError(`Virtual table module "${moduleName}" did not return a table definition object`);
-        }
-        return parseTableDefinition(def, "returned", moduleName);
-      };
-    }
-    function parseTableDefinition(def, verb, moduleName) {
-      if (!hasOwnProperty.call(def, "rows")) {
-        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition without a "rows" property`);
-      }
-      if (!hasOwnProperty.call(def, "columns")) {
-        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition without a "columns" property`);
-      }
-      const rows = def.rows;
-      if (typeof rows !== "function" || Object.getPrototypeOf(rows) !== GeneratorFunctionPrototype) {
-        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "rows" property (should be a generator function)`);
-      }
-      let columns = def.columns;
-      if (!Array.isArray(columns) || !(columns = [...columns]).every((x) => typeof x === "string")) {
-        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "columns" property (should be an array of strings)`);
-      }
-      if (columns.length !== new Set(columns).size) {
-        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with duplicate column names`);
-      }
-      if (!columns.length) {
-        throw new RangeError(`Virtual table module "${moduleName}" ${verb} a table definition with zero columns`);
-      }
-      let parameters;
-      if (hasOwnProperty.call(def, "parameters")) {
-        parameters = def.parameters;
-        if (!Array.isArray(parameters) || !(parameters = [...parameters]).every((x) => typeof x === "string")) {
-          throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "parameters" property (should be an array of strings)`);
-        }
-      } else {
-        parameters = inferParameters(rows);
-      }
-      if (parameters.length !== new Set(parameters).size) {
-        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with duplicate parameter names`);
-      }
-      if (parameters.length > 32) {
-        throw new RangeError(`Virtual table module "${moduleName}" ${verb} a table definition with more than the maximum number of 32 parameters`);
-      }
-      for (const parameter of parameters) {
-        if (columns.includes(parameter)) {
-          throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with column "${parameter}" which was ambiguously defined as both a column and parameter`);
-        }
-      }
-      let safeIntegers = 2;
-      if (hasOwnProperty.call(def, "safeIntegers")) {
-        const bool = def.safeIntegers;
-        if (typeof bool !== "boolean") {
-          throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "safeIntegers" property (should be a boolean)`);
-        }
-        safeIntegers = +bool;
-      }
-      let directOnly = false;
-      if (hasOwnProperty.call(def, "directOnly")) {
-        directOnly = def.directOnly;
-        if (typeof directOnly !== "boolean") {
-          throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "directOnly" property (should be a boolean)`);
-        }
-      }
-      const columnDefinitions = [
-        ...parameters.map(identifier).map((str) => `${str} HIDDEN`),
-        ...columns.map(identifier)
-      ];
-      return [
-        `CREATE TABLE x(${columnDefinitions.join(", ")});`,
-        wrapGenerator(rows, new Map(columns.map((x, i) => [x, parameters.length + i])), moduleName),
-        parameters,
-        safeIntegers,
-        directOnly
-      ];
-    }
-    function wrapGenerator(generator, columnMap, moduleName) {
-      return function* virtualTable(...args) {
-        const output = args.map((x) => Buffer.isBuffer(x) ? Buffer.from(x) : x);
-        for (let i = 0; i < columnMap.size; ++i) {
-          output.push(null);
-        }
-        for (const row of generator(...args)) {
-          if (Array.isArray(row)) {
-            extractRowArray(row, output, columnMap.size, moduleName);
-            yield output;
-          } else if (typeof row === "object" && row !== null) {
-            extractRowObject(row, output, columnMap, moduleName);
-            yield output;
-          } else {
-            throw new TypeError(`Virtual table module "${moduleName}" yielded something that isn't a valid row object`);
-          }
-        }
-      };
-    }
-    function extractRowArray(row, output, columnCount, moduleName) {
-      if (row.length !== columnCount) {
-        throw new TypeError(`Virtual table module "${moduleName}" yielded a row with an incorrect number of columns`);
-      }
-      const offset = output.length - columnCount;
-      for (let i = 0; i < columnCount; ++i) {
-        output[i + offset] = row[i];
-      }
-    }
-    function extractRowObject(row, output, columnMap, moduleName) {
-      let count = 0;
-      for (const key of Object.keys(row)) {
-        const index = columnMap.get(key);
-        if (index === void 0) {
-          throw new TypeError(`Virtual table module "${moduleName}" yielded a row with an undeclared column "${key}"`);
-        }
-        output[index] = row[key];
-        count += 1;
-      }
-      if (count !== columnMap.size) {
-        throw new TypeError(`Virtual table module "${moduleName}" yielded a row with missing columns`);
-      }
-    }
-    function inferParameters({ length }) {
-      if (!Number.isInteger(length) || length < 0) {
-        throw new TypeError("Expected function.length to be a positive integer");
-      }
-      const params = [];
-      for (let i = 0; i < length; ++i) {
-        params.push(`$${i + 1}`);
-      }
-      return params;
-    }
-    var { hasOwnProperty } = Object.prototype;
-    var { apply } = Function.prototype;
-    var GeneratorFunctionPrototype = Object.getPrototypeOf(function* () {
-    });
-    var identifier = (str) => `"${str.replace(/"/g, '""')}"`;
-    var defer = (x) => () => x;
-  }
-});
-
-// ../agx-cloud/node_modules/better-sqlite3/lib/methods/inspect.js
-var require_inspect = __commonJS({
-  "../agx-cloud/node_modules/better-sqlite3/lib/methods/inspect.js"(exports2, module2) {
-    "use strict";
-    var DatabaseInspection = function Database7() {
-    };
-    module2.exports = function inspect(depth, opts) {
-      return Object.assign(new DatabaseInspection(), this);
-    };
-  }
-});
-
-// ../agx-cloud/node_modules/better-sqlite3/lib/database.js
-var require_database = __commonJS({
-  "../agx-cloud/node_modules/better-sqlite3/lib/database.js"(exports2, module2) {
-    "use strict";
-    var fs8 = require("fs");
-    var path11 = require("path");
-    var util = require_util();
-    var SqliteError = require_sqlite_error();
-    var DEFAULT_ADDON;
-    function Database7(filenameGiven, options) {
-      if (new.target == null) {
-        return new Database7(filenameGiven, options);
-      }
-      let buffer;
-      if (Buffer.isBuffer(filenameGiven)) {
-        buffer = filenameGiven;
-        filenameGiven = ":memory:";
-      }
-      if (filenameGiven == null) filenameGiven = "";
-      if (options == null) options = {};
-      if (typeof filenameGiven !== "string") throw new TypeError("Expected first argument to be a string");
-      if (typeof options !== "object") throw new TypeError("Expected second argument to be an options object");
-      if ("readOnly" in options) throw new TypeError('Misspelled option "readOnly" should be "readonly"');
-      if ("memory" in options) throw new TypeError('Option "memory" was removed in v7.0.0 (use ":memory:" filename instead)');
-      const filename = filenameGiven.trim();
-      const anonymous = filename === "" || filename === ":memory:";
-      const readonly = util.getBooleanOption(options, "readonly");
-      const fileMustExist = util.getBooleanOption(options, "fileMustExist");
-      const timeout = "timeout" in options ? options.timeout : 5e3;
-      const verbose = "verbose" in options ? options.verbose : null;
-      const nativeBinding = "nativeBinding" in options ? options.nativeBinding : null;
-      if (readonly && anonymous && !buffer) throw new TypeError("In-memory/temporary databases cannot be readonly");
-      if (!Number.isInteger(timeout) || timeout < 0) throw new TypeError('Expected the "timeout" option to be a positive integer');
-      if (timeout > 2147483647) throw new RangeError('Option "timeout" cannot be greater than 2147483647');
-      if (verbose != null && typeof verbose !== "function") throw new TypeError('Expected the "verbose" option to be a function');
-      if (nativeBinding != null && typeof nativeBinding !== "string" && typeof nativeBinding !== "object") throw new TypeError('Expected the "nativeBinding" option to be a string or addon object');
-      let addon;
-      if (nativeBinding == null) {
-        addon = DEFAULT_ADDON || (DEFAULT_ADDON = require_bindings()("better_sqlite3.node"));
-      } else if (typeof nativeBinding === "string") {
-        const requireFunc = typeof __non_webpack_require__ === "function" ? __non_webpack_require__ : require;
-        addon = requireFunc(path11.resolve(nativeBinding).replace(/(\.node)?$/, ".node"));
-      } else {
-        addon = nativeBinding;
-      }
-      if (!addon.isInitialized) {
-        addon.setErrorConstructor(SqliteError);
-        addon.isInitialized = true;
-      }
-      if (!anonymous && !filename.startsWith("file:") && !fs8.existsSync(path11.dirname(filename))) {
-        throw new TypeError("Cannot open database because the directory does not exist");
-      }
-      Object.defineProperties(this, {
-        [util.cppdb]: { value: new addon.Database(filename, filenameGiven, anonymous, readonly, fileMustExist, timeout, verbose || null, buffer || null) },
-        ...wrappers.getters
-      });
-    }
-    var wrappers = require_wrappers();
-    Database7.prototype.prepare = wrappers.prepare;
-    Database7.prototype.transaction = require_transaction();
-    Database7.prototype.pragma = require_pragma();
-    Database7.prototype.backup = require_backup();
-    Database7.prototype.serialize = require_serialize();
-    Database7.prototype.function = require_function();
-    Database7.prototype.aggregate = require_aggregate();
-    Database7.prototype.table = require_table();
-    Database7.prototype.loadExtension = wrappers.loadExtension;
-    Database7.prototype.exec = wrappers.exec;
-    Database7.prototype.close = wrappers.close;
-    Database7.prototype.defaultSafeIntegers = wrappers.defaultSafeIntegers;
-    Database7.prototype.unsafeMode = wrappers.unsafeMode;
-    Database7.prototype[util.inspect] = require_inspect();
-    module2.exports = Database7;
-  }
-});
-
-// ../agx-cloud/node_modules/better-sqlite3/lib/index.js
-var require_lib = __commonJS({
-  "../agx-cloud/node_modules/better-sqlite3/lib/index.js"(exports2, module2) {
+  };
+}
+var init_sqlite_compat = __esm({
+  "../agx-cloud/lib/sqlite-compat.ts"() {
     "use strict";
-    module2.exports = require_database();
-    module2.exports.SqliteError = require_sqlite_error();
   }
 });
 
@@ -875,7 +143,7 @@ function validateSQLiteEnvironment(db2, dbPath) {
       message: `SQLite version ${version.v} is below minimum ${MIN_SQLITE_VERSION}`,
       found: version.v,
       required: `>= ${MIN_SQLITE_VERSION}`,
-      fix: import_os.default.platform() === "darwin" ? "brew install sqlite3 && npm rebuild better-sqlite3" : "apt-get install -y libsqlite3-dev && npm rebuild better-sqlite3"
+      fix: "Ensure Node.js >= 22.16 is installed (node:sqlite is built-in)"
     });
   }
   for (const ext of REQUIRED_EXTENSIONS) {
@@ -907,16 +175,16 @@ function validateSQLiteEnvironment(db2, dbPath) {
     }
   }
   try {
-    db2.pragma(`journal_mode = ${REQUIRED_PRAGMAS.journal_mode}`);
-    db2.pragma(`foreign_keys = ${REQUIRED_PRAGMAS.foreign_keys}`);
-    db2.pragma(`busy_timeout = ${REQUIRED_PRAGMAS.busy_timeout}`);
-    db2.pragma(`synchronous = ${REQUIRED_PRAGMAS.synchronous}`);
-    db2.pragma(`cache_size = ${REQUIRED_PRAGMAS.cache_size}`);
-    const jm = db2.pragma("journal_mode", { simple: true }).toLowerCase();
+    pragmaSet(db2, `journal_mode = ${REQUIRED_PRAGMAS.journal_mode}`);
+    pragmaSet(db2, `foreign_keys = ${REQUIRED_PRAGMAS.foreign_keys}`);
+    pragmaSet(db2, `busy_timeout = ${REQUIRED_PRAGMAS.busy_timeout}`);
+    pragmaSet(db2, `synchronous = ${REQUIRED_PRAGMAS.synchronous}`);
+    pragmaSet(db2, `cache_size = ${REQUIRED_PRAGMAS.cache_size}`);
+    const jm = pragmaGet(db2, "journal_mode").toLowerCase();
     const ACCEPTABLE_JOURNAL_MODES = /* @__PURE__ */ new Set(["wal", "delete"]);
     if (!ACCEPTABLE_JOURNAL_MODES.has(jm)) {
-      db2.pragma("journal_mode = DELETE");
-      const jm2 = db2.pragma("journal_mode", { simple: true }).toLowerCase();
+      pragmaSet(db2, "journal_mode = DELETE");
+      const jm2 = pragmaGet(db2, "journal_mode").toLowerCase();
       if (!ACCEPTABLE_JOURNAL_MODES.has(jm2)) {
         errors.push({
           kind: "pragma_error",
@@ -926,7 +194,7 @@ function validateSQLiteEnvironment(db2, dbPath) {
           fix: "Ensure the database file is on a local filesystem and no other process holds an exclusive lock."
         });
       } else {
-        db2.pragma("synchronous = FULL");
+        pragmaSet(db2, "synchronous = FULL");
         console.warn(`[startup] WAL unavailable, using journal_mode=${jm2} with synchronous=FULL`);
       }
     }
@@ -939,10 +207,12 @@ function validateSQLiteEnvironment(db2, dbPath) {
   }
   return errors;
 }
-var import_fs, import_os, import_path, MIN_SQLITE_VERSION, REQUIRED_PRAGMAS, REQUIRED_EXTENSIONS, RECOMMENDED_EXTENSIONS, BANNED_FS_PREFIXES;
+var import_node_sqlite, import_fs, import_os, import_path, MIN_SQLITE_VERSION, REQUIRED_PRAGMAS, REQUIRED_EXTENSIONS, RECOMMENDED_EXTENSIONS, BANNED_FS_PREFIXES;
 var init_startup = __esm({
   "../agx-cloud/lib/startup.ts"() {
     "use strict";
+    import_node_sqlite = require("node:sqlite");
+    init_sqlite_compat();
     import_fs = __toESM(require("fs"));
     import_os = __toESM(require("os"));
     import_path = __toESM(require("path"));
@@ -1405,7 +675,7 @@ function migrateLegacyParticipantIds(db2) {
   const tableNames = new Set(
     db2.prepare("SELECT name FROM sqlite_master WHERE type = 'table'").all().map((row) => row.name)
   );
-  const migrateTxn = db2.transaction((participantOps, referenceOps) => {
+  const migrateTxn = transactionFn(db2, (participantOps, referenceOps) => {
     const updateParticipant = db2.prepare("UPDATE participants SET id = ? WHERE id = ?");
     const updateMessages = tableNames.has("messages") ? db2.prepare("UPDATE messages SET participant_id = ? WHERE participant_id = ?") : null;
     const updateAgentProcesses = tableNames.has("agent_processes") ? db2.prepare("UPDATE agent_processes SET agent_id = ? WHERE agent_id = ?") : null;
@@ -1429,8 +699,8 @@ function migrateLegacyParticipantIds(db2) {
 }
 function getDb() {
   (0, import_fs8.mkdirSync)(STORE_DIR, { recursive: true });
-  const db2 = new import_better_sqlite32.default(DB_PATH);
-  db2.pragma("journal_mode = WAL");
+  const db2 = new import_node_sqlite3.DatabaseSync(DB_PATH);
+  pragmaSet(db2, "journal_mode = WAL");
   db2.exec(`
     CREATE TABLE IF NOT EXISTS participants (
       id TEXT PRIMARY KEY,
@@ -1444,7 +714,7 @@ function getDb() {
       sort_order INTEGER NOT NULL DEFAULT 0
     );
   `);
-  const columns = db2.prepare("PRAGMA table_info(participants)").all();
+  const columns = pragmaAll(db2, "table_info(participants)");
   if (columns.some((column) => column.name === "persona")) {
     db2.exec("ALTER TABLE participants RENAME COLUMN persona TO identity");
     db2.exec("ALTER TABLE participants RENAME COLUMN persona_file TO identity_file");
@@ -1506,11 +776,12 @@ function loadParticipants() {
     db2.close();
   }
 }
-var import_better_sqlite32, import_fs8, import_path8, import_os8, STORE_DIR, DB_PATH, AGENTS_DIR5;
+var import_node_sqlite3, import_fs8, import_path8, import_os8, STORE_DIR, DB_PATH, AGENTS_DIR5;
 var init_participants_store = __esm({
   "../agx-cloud/lib/participants-store.ts"() {
     "use strict";
-    import_better_sqlite32 = __toESM(require_lib());
+    import_node_sqlite3 = require("node:sqlite");
+    init_sqlite_compat();
     import_fs8 = require("fs");
     import_path8 = __toESM(require("path"));
     import_os8 = __toESM(require("os"));
@@ -1699,7 +970,7 @@ function migrateLegacyWorkspacesToProjects(inputDb) {
     list.push(row.thread_id);
     workspacesByTeam.set(row.team_id, list);
   }
-  const migrateTxn = db2.transaction(() => {
+  const migrateTxn = () => transaction(db2, () => {
     for (const [userId, userTeams] of teamsByUser.entries()) {
       result.usersProcessed++;
       const effectiveUserId = userId || LOCAL_USER.id;
@@ -1750,7 +1021,7 @@ function migrateLegacyWorkspacesToProjects(inputDb) {
       for (const [projectId, threadIds] of intendedThreadsByProject.entries()) {
         for (const threadId of threadIds) {
           const removed = deleteThreadLinksElsewhere.run(threadId, projectId);
-          result.remappedThreadLinks += removed.changes;
+          result.remappedThreadLinks += Number(removed.changes);
           const linked = insertProjectThread.run(projectId, threadId);
           if (linked.changes > 0) result.projectThreadsLinked++;
         }
@@ -1791,6 +1062,7 @@ var WORKSPACES_TO_PROJECTS_MIGRATION_KEY;
 var init_workspaces_to_projects_migration = __esm({
   "../agx-cloud/lib/workspaces-to-projects-migration.ts"() {
     "use strict";
+    init_sqlite_compat();
     init_participants_store();
     init_auth_mode();
     WORKSPACES_TO_PROJECTS_MIGRATION_KEY = "legacy_workspaces_to_projects_v1";
@@ -1811,7 +1083,7 @@ function sqlExpr(expr) {
 function getSQLiteDb() {
   if (_db) return _db;
   const dbPath = process.env.SQLITE_DB_PATH || import_path9.default.join(AGX_DATA_DIR3, "agx-board.db");
-  _db = new import_better_sqlite33.default(dbPath);
+  _db = new import_node_sqlite4.DatabaseSync(dbPath);
   const errors = validateSQLiteEnvironment(_db, dbPath);
   if (errors.length > 0) {
     const msgs = errors.map((e) => `  - ${e.message}${e.fix ? ` (fix: ${e.fix})` : ""}`);
@@ -1861,14 +1133,14 @@ function dropLegacyTeamsTables(db2) {
 function runMigrations(db2) {
   const graphTables = db2.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='execution_graphs'").all();
   if (graphTables.length > 0) {
-    const columns = db2.pragma("table_info(execution_graphs)");
+    const columns = pragmaAll(db2, "table_info(execution_graphs)");
     if (!columns.some((column) => column.name === "schedule")) {
       db2.exec("ALTER TABLE execution_graphs ADD COLUMN schedule JSON");
     }
   }
   const projectMemoryTables = db2.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='project_memory'").all();
   if (projectMemoryTables.length > 0) {
-    const projectMemoryCols = db2.pragma("table_info(project_memory)");
+    const projectMemoryCols = pragmaAll(db2, "table_info(project_memory)");
     if (!projectMemoryCols.some((column) => column.name === "producer")) {
       db2.exec("ALTER TABLE project_memory ADD COLUMN producer TEXT NOT NULL DEFAULT 'human' CHECK(producer IN ('human', 'system'))");
     }
@@ -1876,7 +1148,7 @@ function runMigrations(db2) {
   }
   const agentTables = db2.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='agents'").all();
   if (agentTables.length > 0) {
-    const agentCols = db2.pragma("table_info(agents)");
+    const agentCols = pragmaAll(db2, "table_info(agents)");
     const agentColNames = new Set(agentCols.map((c) => c.name));
     if (!agentColNames.has("voice")) db2.exec("ALTER TABLE agents ADD COLUMN voice TEXT");
     if (!agentColNames.has("seed")) db2.exec("ALTER TABLE agents ADD COLUMN seed TEXT");
@@ -2273,11 +1545,12 @@ function createAdminDbClientSQLite() {
     }
   };
 }
-var import_better_sqlite33, import_fs9, import_path9, import_os9, AGX_DATA_DIR3, SqlExpression, _db, JSON_COLUMNS, SQLiteQueryBuilder, KNOWN_JSON_COLUMNS;
+var import_node_sqlite4, import_fs9, import_path9, import_os9, AGX_DATA_DIR3, SqlExpression, _db, JSON_COLUMNS, SQLiteQueryBuilder, KNOWN_JSON_COLUMNS;
 var init_sqlite_query_adapter = __esm({
   "../agx-cloud/lib/sqlite-query-adapter.ts"() {
     "use strict";
-    import_better_sqlite33 = __toESM(require_lib());
+    import_node_sqlite4 = require("node:sqlite");
+    init_sqlite_compat();
     import_fs9 = __toESM(require("fs"));
     import_path9 = __toESM(require("path"));
     import_os9 = __toESM(require("os"));
@@ -4500,8 +3773,20 @@ var init_sqlite_adapter = __esm({
   }
 });
 
+// ../agx-cloud/lib/check-node-version.ts
+if (typeof process !== "undefined" && process.versions?.node) {
+  const [major, minor] = process.versions.node.split(".").map(Number);
+  if (major < 22 || major === 22 && minor < 16) {
+    console.error(
+      `agx-cloud requires Node.js >= 22.16.0 (found ${process.version}). node:sqlite is not available on older versions.`
+    );
+    process.exit(1);
+  }
+}
+
 // ../agx-cloud/lib/queue/sqlite-adapter.ts
-var import_better_sqlite3 = __toESM(require_lib());
+var import_node_sqlite2 = require("node:sqlite");
+init_sqlite_compat();
 
 // ../agx-cloud/node_modules/uuid/dist-node/stringify.js
 var byteToHex = [];
@@ -4660,7 +3945,7 @@ var SQLiteQueueAdapter = class {
     if (!import_fs3.default.existsSync(dir)) {
       import_fs3.default.mkdirSync(dir, { recursive: true });
     }
-    this.db = new import_better_sqlite3.default(finalPath);
+    this.db = new import_node_sqlite2.DatabaseSync(finalPath);
     const errors = validateSQLiteEnvironment(this.db, finalPath);
     if (errors.length > 0) {
       const msgs = errors.map((e) => e.message).join("; ");
@@ -4695,7 +3980,7 @@ var SQLiteQueueAdapter = class {
       );
       CREATE INDEX IF NOT EXISTS idx_jobs_fetch ON agx_jobs (queue, status, start_after, priority DESC, created_at ASC);
     `);
-    const cols = this.db.pragma("table_info(agx_jobs)");
+    const cols = pragmaAll(this.db, "table_info(agx_jobs)");
     const colNames = new Set(cols.map((c) => c.name));
     if (!colNames.has("failed_at")) {
       this.db.exec(`ALTER TABLE agx_jobs ADD COLUMN failed_at INTEGER`);
@@ -4771,7 +4056,7 @@ var SQLiteQueueAdapter = class {
     const batchSize = worker.options.batchSize || 1;
     const now = Date.now();
     const staleBefore = now - getStaleJobTimeoutMs();
-    const jobs = this.db.transaction(() => {
+    const jobs = transaction(this.db, () => {
       const reapedJobs = this.reapStaleJobs(queue2, now, staleBefore);
       if (reapedJobs.length > 0) {
         writeDebugLog("queue.reap_stale", {
@@ -4804,7 +4089,7 @@ var SQLiteQueueAdapter = class {
         name: queue2,
         data: JSON.parse(c.data)
       }));
-    })();
+    });
     if (jobs.length > 0) {
       writeDebugLog("queue.claim", {
         queue: queue2,
@@ -4836,9 +4121,9 @@ var SQLiteQueueAdapter = class {
       SET status = 'completed', completed_at = ?, worker_id = NULL
       WHERE id = ?
     `);
-    this.db.transaction(() => {
+    transaction(this.db, () => {
       for (const id of ids) stmt.run(now, id);
-    })();
+    });
   }
   failJobs(ids, error) {
     const now = Date.now();
@@ -4859,7 +4144,7 @@ var SQLiteQueueAdapter = class {
       SET status = 'failed', failed_at = ?, started_at = NULL, worker_id = NULL, error = ?
       WHERE id = ?
     `);
-    this.db.transaction(() => {
+    transaction(this.db, () => {
       for (const id of ids) {
         const job = stmt.get(id);
         if (job && job.retry_count < job.retry_limit) {
@@ -4869,7 +4154,7 @@ var SQLiteQueueAdapter = class {
           updateFailed.run(now, error, id);
         }
       }
-    })();
+    });
   }
   reapStaleJobs(queue2, now, staleBefore) {
     const staleJobs = this.db.prepare(`
@@ -5837,6 +5122,7 @@ init_sqlite_query_adapter();
 // ../agx-cloud/lib/knowledge-store.ts
 var import_crypto2 = require("crypto");
 init_sqlite_query_adapter();
+init_sqlite_compat();
 function clampUnitNumber(value) {
   if (typeof value !== "number" || !Number.isFinite(value)) return null;
   return Math.max(0, Math.min(1, value));
@@ -5928,7 +5214,7 @@ function storeKnowledgeEntries(drafts) {
     ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
   );
   let inserted = 0;
-  const tx = db2.transaction((entries) => {
+  const tx = transactionFn(db2, (entries) => {
     for (const draft of entries) {
       const subjectId = draft.subjectId.trim();
       const title = draft.title.trim();
@@ -6890,7 +6176,8 @@ async function handleCancel(taskId, userId, reason) {
 var import_promises = require("fs/promises");
 
 // ../agx-cloud/lib/agent-process-registry.ts
-var import_better_sqlite34 = __toESM(require_lib());
+var import_node_sqlite5 = require("node:sqlite");
+init_sqlite_compat();
 var import_path11 = __toESM(require("path"));
 var import_os10 = __toESM(require("os"));
 var import_fs11 = require("fs");
@@ -6913,8 +6200,8 @@ function toEntry(row) {
 }
 function getDb2() {
   (0, import_fs11.mkdirSync)(HISTORY_DIR, { recursive: true });
-  const db2 = new import_better_sqlite34.default(DB_PATH2);
-  db2.pragma("journal_mode = WAL");
+  const db2 = new import_node_sqlite5.DatabaseSync(DB_PATH2);
+  pragmaSet(db2, "journal_mode = WAL");
   db2.exec(`
     CREATE TABLE IF NOT EXISTS agent_processes (
       id           INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -7066,7 +6353,8 @@ function killByWorkspace(workspaceId) {
 }
 
 // ../agx-cloud/lib/history-store.ts
-var import_better_sqlite35 = __toESM(require_lib());
+var import_node_sqlite6 = require("node:sqlite");
+init_sqlite_compat();
 var import_fs12 = require("fs");
 var import_path12 = __toESM(require("path"));
 var import_os11 = __toESM(require("os"));
@@ -7132,11 +6420,11 @@ function initializeMessageSearch(db2) {
   }
 }
 function isThreadScopedTable(db2, tableName) {
-  const columns = db2.prepare(`PRAGMA table_info(${tableName})`).all();
+  const columns = pragmaAll(db2, `table_info(${tableName})`);
   return columns.some((column) => column.name === "thread_id");
 }
 function migrateThreadReplyColumns(db2) {
-  const columns = db2.prepare(`PRAGMA table_info(messages)`).all();
+  const columns = pragmaAll(db2, `table_info(messages)`);
   const colNames = new Set(columns.map((c) => c.name));
   if (!colNames.has("root_message_id")) {
     db2.exec(`
@@ -7148,7 +6436,7 @@ function migrateThreadReplyColumns(db2) {
   }
 }
 function migrateThreadStatusColumns(db2) {
-  const columns = db2.prepare(`PRAGMA table_info(messages)`).all();
+  const columns = pragmaAll(db2, `table_info(messages)`);
   const colNames = new Set(columns.map((c) => c.name));
   if (!colNames.has("thread_status")) {
     db2.exec(`
@@ -7158,7 +6446,7 @@ function migrateThreadStatusColumns(db2) {
   }
 }
 function migrateReactionHostPidColumn(db2) {
-  const columns = db2.prepare(`PRAGMA table_info(message_reactions)`).all();
+  const columns = pragmaAll(db2, `table_info(message_reactions)`);
   const colNames = new Set(columns.map((c) => c.name));
   if (!colNames.has("host_pid")) {
     db2.exec(`ALTER TABLE message_reactions ADD COLUMN host_pid INTEGER`);
@@ -7168,7 +6456,7 @@ function migrateReactionHostPidColumn(db2) {
   }
 }
 function migrateLogsToAgentProcessId(db2) {
-  const columns = db2.prepare(`PRAGMA table_info(logs)`).all();
+  const columns = pragmaAll(db2, `table_info(logs)`);
   const colNames = new Set(columns.map((c) => c.name));
   if (colNames.has("agent_process_id")) return;
   db2.exec(`
@@ -7183,7 +6471,7 @@ function migrateLogsToAgentProcessId(db2) {
   `);
 }
 function migrateAgentProcessesAddId(db2) {
-  const columns = db2.prepare(`PRAGMA table_info(agent_processes)`).all();
+  const columns = pragmaAll(db2, `table_info(agent_processes)`);
   if (columns.length === 0) return;
   const colNames = new Set(columns.map((c) => c.name));
   if (colNames.has("id")) return;
@@ -7303,8 +6591,8 @@ function migrateLegacyTables(db2) {
 }
 var withDatabase = async (run) => {
   await import_fs12.promises.mkdir(HISTORY_DIR2, { recursive: true });
-  const db2 = new import_better_sqlite35.default(DB_PATH3);
-  db2.pragma("journal_mode = WAL");
+  const db2 = new import_node_sqlite6.DatabaseSync(DB_PATH3);
+  pragmaSet(db2, "journal_mode = WAL");
   try {
     db2.exec(`
       CREATE TABLE IF NOT EXISTS messages (
@@ -7481,7 +6769,7 @@ async function saveMessages(threadId, messages) {
       `INSERT OR REPLACE INTO messages (thread_id, id, role, participant_id, content, timestamp, root_message_id, parent_message_id, depth, thread_status, outcome_note)
        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
     );
-    const insertMany = db2.transaction((msgs) => {
+    const insertMany = transactionFn(db2, (msgs) => {
       for (const m of msgs) {
         stmt.run(normalizedThreadId, m.id, m.role, m.participantId, m.content, m.timestamp, m.rootMessageId ?? null, m.parentMessageId ?? null, m.depth ?? 0, m.threadStatus ?? null, m.outcomeNote ?? null);
       }
@@ -7509,7 +6797,7 @@ async function sweepStaleChatRuns(input) {
              completed_at = COALESCE(completed_at, ?)
          WHERE ${clauses.join(" AND ")}`
     ).run(now, now, ...params);
-    return result.changes;
+    return Number(result.changes);
   });
 }
 async function getChatRun(chatRunId) {
@@ -7688,12 +6976,11 @@ async function saveLogs(agentProcessId, entries) {
     const stmt = db2.prepare(
       "INSERT INTO logs (agent_process_id, stream, line, timestamp) VALUES (?, ?, ?, ?)"
     );
-    const tx = db2.transaction(() => {
+    transaction(db2, () => {
       for (const e of entries) {
         stmt.run(agentProcessId, e.stream, e.line, e.timestamp);
       }
     });
-    tx();
   });
 }
 
@@ -7760,15 +7047,16 @@ function parseReactionSignals(content) {
 }
 
 // ../agx-cloud/lib/attachment-store.ts
-var import_better_sqlite36 = __toESM(require_lib());
+var import_node_sqlite7 = require("node:sqlite");
+init_sqlite_compat();
 var import_path13 = __toESM(require("path"));
 var import_os12 = __toESM(require("os"));
 var HISTORY_DIR3 = process.env.AGX_GROUP_CHAT_DIR?.trim() || import_path13.default.join(import_os12.default.homedir(), ".agx", "group-chat");
 var DB_PATH4 = import_path13.default.join(HISTORY_DIR3, "history.sqlite");
 var UPLOADS_DIR = import_path13.default.join(HISTORY_DIR3, "uploads");
 function getDb3() {
-  const db2 = new import_better_sqlite36.default(DB_PATH4);
-  db2.pragma("journal_mode = WAL");
+  const db2 = new import_node_sqlite7.DatabaseSync(DB_PATH4);
+  pragmaSet(db2, "journal_mode = WAL");
   return db2;
 }
 function initAttachmentsTable(db2) {