terradb 0.5.3 → 0.5.5

package/dist/index.js

@@ -22225,7 +22225,7 @@ class SchemaDiffer {
         constraint: primaryKeyChange.desiredPK
       });
     }
-    this.collectCheckConstraintAlterations(desiredTable.checkConstraints || [], currentTable.checkConstraints || [], alterations);
+    this.collectCheckConstraintAlterations(desiredTable.name, desiredTable.checkConstraints || [], currentTable.checkConstraints || [], alterations);
     const currentColumns2 = new Set(currentTable.columns.map((c) => c.name));
     const desiredColumns2 = new Set(desiredTable.columns.map((c) => c.name));
     const droppedColumns = new Set([...currentColumns2].filter((col) => !desiredColumns2.has(col)));
@@ -22291,10 +22291,12 @@ class SchemaDiffer {
       }
     }
   }
-  collectCheckConstraintAlterations(desiredConstraints, currentConstraints, alterations) {
+  collectCheckConstraintAlterations(tableName, desiredConstraints, currentConstraints, alterations) {
     const findMatchingConstraint = (expr, constraints) => {
       return constraints.find((c) => expressionsEqual(expr, c.expression));
     };
+    const bareTableName = getBareTableName(tableName);
+    const fallbackName = `${bareTableName}_check`;
     const processedCurrentNames = new Set;
     for (const desired of desiredConstraints) {
       const matchingCurrent = findMatchingConstraint(desired.expression, currentConstraints);
@@ -22302,7 +22304,9 @@ class SchemaDiffer {
         if (matchingCurrent.name) {
           processedCurrentNames.add(matchingCurrent.name);
         }
-        if (matchingCurrent.name !== desired.name) {
+        const desiredEffectiveName = desired.name || fallbackName;
+        const currentEffectiveName = matchingCurrent.name || fallbackName;
+        if (currentEffectiveName !== desiredEffectiveName) {
           if (matchingCurrent.name) {
             alterations.push({
               type: "drop_check",
@@ -25778,788 +25782,715 @@ var init_postgres = __esm(() => {
   init_errors();
 });
 
-// node_modules/better-sqlite3/lib/util.js
-var require_util = __commonJS((exports) => {
-  exports.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`);
+// node_modules/@neon-rs/load/dist/index.js
+var require_dist3 = __commonJS((exports) => {
+  var __createBinding = exports && exports.__createBinding || (Object.create ? function(o, m, k, k2) {
+    if (k2 === undefined)
+      k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() {
+        return m[k];
+      } };
     }
-    return value;
+    Object.defineProperty(o, k2, desc);
+  } : function(o, m, k, k2) {
+    if (k2 === undefined)
+      k2 = k;
+    o[k2] = m[k];
+  });
+  var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+  } : function(o, v) {
+    o["default"] = v;
+  });
+  var __importStar = exports && exports.__importStar || function(mod) {
+    if (mod && mod.__esModule)
+      return mod;
+    var result = {};
+    if (mod != null) {
+      for (var k in mod)
+        if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k))
+          __createBinding(result, mod, k);
+    }
+    __setModuleDefault(result, mod);
+    return result;
   };
-  exports.cppdb = Symbol();
-  exports.inspect = Symbol.for("nodejs.util.inspect.custom");
-});
-
-// node_modules/better-sqlite3/lib/sqlite-error.js
-var require_sqlite_error = __commonJS((exports, module) => {
-  var descriptor = { value: "SqliteError", writable: true, enumerable: false, configurable: true };
-  function SqliteError(message, code) {
-    if (new.target !== SqliteError) {
-      return new SqliteError(message, code);
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.load = exports.currentTarget = undefined;
+  var path = __importStar(__require("path"));
+  var fs = __importStar(__require("fs"));
+  function currentTarget() {
+    let os3 = null;
+    switch (process.platform) {
+      case "android":
+        switch (process.arch) {
+          case "arm":
+            return "android-arm-eabi";
+          case "arm64":
+            return "android-arm64";
+        }
+        os3 = "Android";
+        break;
+      case "win32":
+        switch (process.arch) {
+          case "x64":
+            return "win32-x64-msvc";
+          case "arm64":
+            return "win32-arm64-msvc";
+          case "ia32":
+            return "win32-ia32-msvc";
+        }
+        os3 = "Windows";
+        break;
+      case "darwin":
+        switch (process.arch) {
+          case "x64":
+            return "darwin-x64";
+          case "arm64":
+            return "darwin-arm64";
+        }
+        os3 = "macOS";
+        break;
+      case "linux":
+        switch (process.arch) {
+          case "x64":
+          case "arm64":
+            return isGlibc() ? `linux-${process.arch}-gnu` : `linux-${process.arch}-musl`;
+          case "arm":
+            return "linux-arm-gnueabihf";
+        }
+        os3 = "Linux";
+        break;
+      case "freebsd":
+        if (process.arch === "x64") {
+          return "freebsd-x64";
+        }
+        os3 = "FreeBSD";
+        break;
     }
-    if (typeof code !== "string") {
-      throw new TypeError("Expected second argument to be a string");
+    if (os3) {
+      throw new Error(`Neon: unsupported ${os3} architecture: ${process.arch}`);
     }
-    Error.call(this, message);
-    descriptor.value = "" + message;
-    Object.defineProperty(this, "message", descriptor);
-    Error.captureStackTrace(this, SqliteError);
-    this.code = code;
+    throw new Error(`Neon: unsupported system: ${process.platform}`);
   }
-  Object.setPrototypeOf(SqliteError, Error);
-  Object.setPrototypeOf(SqliteError.prototype, Error.prototype);
-  Object.defineProperty(SqliteError.prototype, "name", descriptor);
-  module.exports = SqliteError;
+  exports.currentTarget = currentTarget;
+  function isGlibc() {
+    const report = process.report?.getReport();
+    if (typeof report !== "object" || !report || !("header" in report)) {
+      return false;
+    }
+    const header = report.header;
+    return typeof header === "object" && !!header && "glibcVersionRuntime" in header;
+  }
+  function load2(dirname) {
+    const m = path.join(dirname, "index.node");
+    return fs.existsSync(m) ? __require(m) : null;
+  }
+  exports.load = load2;
 });
 
-// node_modules/file-uri-to-path/index.js
-var require_file_uri_to_path = __commonJS((exports, module) => {
-  var sep = __require("path").sep || "/";
-  module.exports = fileUriToPath;
-  function fileUriToPath(uri) {
-    if (typeof uri != "string" || uri.length <= 7 || uri.substring(0, 7) != "file://") {
-      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 path = rest.substring(firstSlash + 1);
-    if (host == "localhost")
-      host = "";
-    if (host) {
-      host = sep + sep + host;
-    }
-    path = path.replace(/^(.+)\|/, "$1:");
-    if (sep == "\\") {
-      path = path.replace(/\//g, "\\");
-    }
-    if (/^.+\:/.test(path)) {} else {
-      path = sep + path;
-    }
-    return host + path;
-  }
+// node_modules/detect-libc/lib/process.js
+var require_process = __commonJS((exports, module) => {
+  var isLinux = () => process.platform === "linux";
+  var report = null;
+  var getReport = () => {
+    if (!report) {
+      report = isLinux() && process.report ? process.report.getReport() : {};
+    }
+    return report;
+  };
+  module.exports = { isLinux, getReport };
 });
 
-// node_modules/bindings/bindings.js
-var require_bindings = __commonJS((exports, module) => {
-  var __filename = "/home/runner/work/terradb/terradb/node_modules/bindings/bindings.js";
+// node_modules/detect-libc/lib/filesystem.js
+var require_filesystem = __commonJS((exports, module) => {
   var fs = __require("fs");
-  var path = __require("path");
-  var fileURLToPath = require_file_uri_to_path();
-  var join = path.join;
-  var dirname = path.dirname;
-  var exists = fs.accessSync && function(path2) {
-    try {
-      fs.accessSync(path2);
-    } catch (e) {
-      return false;
+  var LDD_PATH = "/usr/bin/ldd";
+  var readFileSync2 = (path) => fs.readFileSync(path, "utf-8");
+  var readFile = (path) => new Promise((resolve, reject) => {
+    fs.readFile(path, "utf-8", (err, data) => {
+      if (err) {
+        reject(err);
+      } else {
+        resolve(data);
+      }
+    });
+  });
+  module.exports = {
+    LDD_PATH,
+    readFileSync: readFileSync2,
+    readFile
+  };
+});
+
+// node_modules/detect-libc/lib/detect-libc.js
+var require_detect_libc = __commonJS((exports, module) => {
+  var childProcess = __require("child_process");
+  var { isLinux, getReport } = require_process();
+  var { LDD_PATH, readFile, readFileSync: readFileSync2 } = require_filesystem();
+  var cachedFamilyFilesystem;
+  var cachedVersionFilesystem;
+  var command = "getconf GNU_LIBC_VERSION 2>&1 || true; ldd --version 2>&1 || true";
+  var commandOut = "";
+  var safeCommand = () => {
+    if (!commandOut) {
+      return new Promise((resolve) => {
+        childProcess.exec(command, (err, out) => {
+          commandOut = err ? " " : out;
+          resolve(commandOut);
+        });
+      });
     }
-    return true;
-  } || fs.existsSync || path.existsSync;
-  var defaults2 = {
-    arrow: process.env.NODE_BINDINGS_ARROW || " → ",
-    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: [
-      ["module_root", "build", "bindings"],
-      ["module_root", "build", "Debug", "bindings"],
-      ["module_root", "build", "Release", "bindings"],
-      ["module_root", "out", "Debug", "bindings"],
-      ["module_root", "Debug", "bindings"],
-      ["module_root", "out", "Release", "bindings"],
-      ["module_root", "Release", "bindings"],
-      ["module_root", "build", "default", "bindings"],
-      ["module_root", "compiled", "version", "platform", "arch", "bindings"],
-      ["module_root", "addon-build", "release", "install-root", "bindings"],
-      ["module_root", "addon-build", "debug", "install-root", "bindings"],
-      ["module_root", "addon-build", "default", "install-root", "bindings"],
-      ["module_root", "lib", "binding", "nodePreGyp", "bindings"]
-    ]
+    return commandOut;
   };
-  function bindings(opts) {
-    if (typeof opts == "string") {
-      opts = { bindings: opts };
-    } else if (!opts) {
-      opts = {};
-    }
-    Object.keys(defaults2).map(function(i2) {
-      if (!(i2 in opts))
-        opts[i2] = defaults2[i2];
-    });
-    if (!opts.module_root) {
-      opts.module_root = exports.getRoot(exports.getFileName());
-    }
-    if (path.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 = join.apply(null, opts.try[i].map(function(p) {
-        return opts[p] || p;
-      }));
-      tries.push(n);
+  var safeCommandSync = () => {
+    if (!commandOut) {
       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;
-        }
+        commandOut = childProcess.execSync(command, { encoding: "utf8" });
+      } catch (_err) {
+        commandOut = " ";
       }
     }
-    err = new Error(`Could not locate the bindings file. Tried:
-` + tries.map(function(a) {
-      return opts.arrow + a;
-    }).join(`
-`));
-    err.tries = tries;
-    throw err;
-  }
-  module.exports = exports = bindings;
-  exports.getFileName = function getFileName(calling_file) {
-    var { prepareStackTrace: origPST, stackTraceLimit: origSTL } = Error, 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;
+    return commandOut;
   };
-  exports.getRoot = function getRoot(file) {
-    var dir = dirname(file), prev;
-    while (true) {
-      if (dir === ".") {
-        dir = process.cwd();
+  var GLIBC = "glibc";
+  var RE_GLIBC_VERSION = /GLIBC\s(\d+\.\d+)/;
+  var MUSL = "musl";
+  var GLIBC_ON_LDD = GLIBC.toUpperCase();
+  var MUSL_ON_LDD = MUSL.toLowerCase();
+  var isFileMusl = (f) => f.includes("libc.musl-") || f.includes("ld-musl-");
+  var familyFromReport = () => {
+    const report = getReport();
+    if (report.header && report.header.glibcVersionRuntime) {
+      return GLIBC;
+    }
+    if (Array.isArray(report.sharedObjects)) {
+      if (report.sharedObjects.some(isFileMusl)) {
+        return MUSL;
       }
-      if (exists(join(dir, "package.json")) || exists(join(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 = join(dir, "..");
     }
+    return null;
   };
-});
-
-// node_modules/better-sqlite3/lib/methods/wrappers.js
-var require_wrappers = __commonJS((exports) => {
-  var { cppdb } = require_util();
-  exports.prepare = function prepare(sql) {
-    return this[cppdb].prepare(sql, this, false);
-  };
-  exports.exec = function exec(sql) {
-    this[cppdb].exec(sql);
-    return this;
-  };
-  exports.close = function close() {
-    this[cppdb].close();
-    return this;
-  };
-  exports.loadExtension = function loadExtension(...args) {
-    this[cppdb].loadExtension(...args);
-    return this;
+  var familyFromCommand = (out) => {
+    const [getconf, ldd1] = out.split(/[\r\n]+/);
+    if (getconf && getconf.includes(GLIBC)) {
+      return GLIBC;
+    }
+    if (ldd1 && ldd1.includes(MUSL)) {
+      return MUSL;
+    }
+    return null;
   };
-  exports.defaultSafeIntegers = function defaultSafeIntegers(...args) {
-    this[cppdb].defaultSafeIntegers(...args);
-    return this;
+  var getFamilyFromLddContent = (content) => {
+    if (content.includes(MUSL_ON_LDD)) {
+      return MUSL;
+    }
+    if (content.includes(GLIBC_ON_LDD)) {
+      return GLIBC;
+    }
+    return null;
   };
-  exports.unsafeMode = function unsafeMode(...args) {
-    this[cppdb].unsafeMode(...args);
-    return this;
+  var familyFromFilesystem = async () => {
+    if (cachedFamilyFilesystem !== undefined) {
+      return cachedFamilyFilesystem;
+    }
+    cachedFamilyFilesystem = null;
+    try {
+      const lddContent = await readFile(LDD_PATH);
+      cachedFamilyFilesystem = getFamilyFromLddContent(lddContent);
+    } catch (e) {}
+    return cachedFamilyFilesystem;
   };
-  exports.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
+  var familyFromFilesystemSync = () => {
+    if (cachedFamilyFilesystem !== undefined) {
+      return cachedFamilyFilesystem;
     }
+    cachedFamilyFilesystem = null;
+    try {
+      const lddContent = readFileSync2(LDD_PATH);
+      cachedFamilyFilesystem = getFamilyFromLddContent(lddContent);
+    } catch (e) {}
+    return cachedFamilyFilesystem;
   };
-});
-
-// node_modules/better-sqlite3/lib/methods/transaction.js
-var require_transaction = __commonJS((exports, module) => {
-  var { cppdb } = require_util();
-  var controllers = new WeakMap;
-  module.exports = function transaction(fn) {
-    if (typeof fn !== "function")
-      throw new TypeError("Expected first argument to be a function");
-    const db = this[cppdb];
-    const controller = getController(db, this);
-    const { apply } = Function.prototype;
-    const properties = {
-      default: { value: wrapTransaction(apply, fn, db, controller.default) },
-      deferred: { value: wrapTransaction(apply, fn, db, controller.deferred) },
-      immediate: { value: wrapTransaction(apply, fn, db, controller.immediate) },
-      exclusive: { value: wrapTransaction(apply, fn, db, 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 family = async () => {
+    let family2 = null;
+    if (isLinux()) {
+      family2 = await familyFromFilesystem();
+      if (!family2) {
+        family2 = familyFromReport();
+      }
+      if (!family2) {
+        const out = await safeCommand();
+        family2 = familyFromCommand(out);
+      }
+    }
+    return family2;
   };
-  var getController = (db, self2) => {
-    let controller = controllers.get(db);
-    if (!controller) {
-      const shared = {
-        commit: db.prepare("COMMIT", self2, false),
-        rollback: db.prepare("ROLLBACK", self2, false),
-        savepoint: db.prepare("SAVEPOINT `\t_bs3.\t`", self2, false),
-        release: db.prepare("RELEASE `\t_bs3.\t`", self2, false),
-        rollbackTo: db.prepare("ROLLBACK TO `\t_bs3.\t`", self2, false)
-      };
-      controllers.set(db, controller = {
-        default: Object.assign({ begin: db.prepare("BEGIN", self2, false) }, shared),
-        deferred: Object.assign({ begin: db.prepare("BEGIN DEFERRED", self2, false) }, shared),
-        immediate: Object.assign({ begin: db.prepare("BEGIN IMMEDIATE", self2, false) }, shared),
-        exclusive: Object.assign({ begin: db.prepare("BEGIN EXCLUSIVE", self2, false) }, shared)
-      });
+  var familySync = () => {
+    let family2 = null;
+    if (isLinux()) {
+      family2 = familyFromFilesystemSync();
+      if (!family2) {
+        family2 = familyFromReport();
+      }
+      if (!family2) {
+        const out = safeCommandSync();
+        family2 = familyFromCommand(out);
+      }
     }
-    return controller;
+    return family2;
   };
-  var wrapTransaction = (apply, fn, db, { begin, commit, rollback, savepoint, release, rollbackTo }) => function sqliteTransaction() {
-    let before, after, undo;
-    if (db.inTransaction) {
-      before = savepoint;
-      after = release;
-      undo = rollbackTo;
-    } else {
-      before = begin;
-      after = commit;
-      undo = rollback;
+  var isNonGlibcLinux = async () => isLinux() && await family() !== GLIBC;
+  var isNonGlibcLinuxSync = () => isLinux() && familySync() !== GLIBC;
+  var versionFromFilesystem = async () => {
+    if (cachedVersionFilesystem !== undefined) {
+      return cachedVersionFilesystem;
     }
-    before.run();
+    cachedVersionFilesystem = null;
     try {
-      const result = apply.call(fn, this, arguments);
-      if (result && typeof result.then === "function") {
-        throw new TypeError("Transaction function cannot return a promise");
+      const lddContent = await readFile(LDD_PATH);
+      const versionMatch = lddContent.match(RE_GLIBC_VERSION);
+      if (versionMatch) {
+        cachedVersionFilesystem = versionMatch[1];
       }
-      after.run();
-      return result;
-    } catch (ex) {
-      if (db.inTransaction) {
-        undo.run();
-        if (undo !== rollback)
-          after.run();
+    } catch (e) {}
+    return cachedVersionFilesystem;
+  };
+  var versionFromFilesystemSync = () => {
+    if (cachedVersionFilesystem !== undefined) {
+      return cachedVersionFilesystem;
+    }
+    cachedVersionFilesystem = null;
+    try {
+      const lddContent = readFileSync2(LDD_PATH);
+      const versionMatch = lddContent.match(RE_GLIBC_VERSION);
+      if (versionMatch) {
+        cachedVersionFilesystem = versionMatch[1];
       }
-      throw ex;
+    } catch (e) {}
+    return cachedVersionFilesystem;
+  };
+  var versionFromReport = () => {
+    const report = getReport();
+    if (report.header && report.header.glibcVersionRuntime) {
+      return report.header.glibcVersionRuntime;
     }
+    return null;
   };
-});
-
-// node_modules/better-sqlite3/lib/methods/pragma.js
-var require_pragma = __commonJS((exports, module) => {
-  var { getBooleanOption, cppdb } = require_util();
-  module.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();
+  var versionSuffix = (s) => s.trim().split(/\s+/)[1];
+  var versionFromCommand = (out) => {
+    const [getconf, ldd1, ldd2] = out.split(/[\r\n]+/);
+    if (getconf && getconf.includes(GLIBC)) {
+      return versionSuffix(getconf);
+    }
+    if (ldd1 && ldd2 && ldd1.includes(MUSL)) {
+      return versionSuffix(ldd2);
+    }
+    return null;
   };
-});
-
-// node_modules/better-sqlite3/lib/methods/backup.js
-var require_backup = __commonJS((exports, module) => {
-  var fs = __require("fs");
-  var path = __require("path");
-  var { promisify } = __require("util");
-  var { cppdb } = require_util();
-  var fsAccess = promisify(fs.access);
-  module.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(path.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 version = async () => {
+    let version2 = null;
+    if (isLinux()) {
+      version2 = await versionFromFilesystem();
+      if (!version2) {
+        version2 = versionFromReport();
+      }
+      if (!version2) {
+        const out = await safeCommand();
+        version2 = versionFromCommand(out);
+      }
+    }
+    return version2;
   };
-  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 !== undefined) {
-              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);
-        }
-      });
-    });
+  var versionSync = () => {
+    let version2 = null;
+    if (isLinux()) {
+      version2 = versionFromFilesystemSync();
+      if (!version2) {
+        version2 = versionFromReport();
+      }
+      if (!version2) {
+        const out = safeCommandSync();
+        version2 = versionFromCommand(out);
+      }
+    }
+    return version2;
   };
-});
-
-// node_modules/better-sqlite3/lib/methods/serialize.js
-var require_serialize = __commonJS((exports, module) => {
-  var { cppdb } = require_util();
-  module.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);
+  module.exports = {
+    GLIBC,
+    MUSL,
+    family,
+    familySync,
+    isNonGlibcLinux,
+    isNonGlibcLinuxSync,
+    version,
+    versionSync
   };
 });
 
-// node_modules/better-sqlite3/lib/methods/function.js
-var require_function = __commonJS((exports, module) => {
-  var { getBooleanOption, cppdb } = require_util();
-  module.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;
+// node_modules/libsql/auth.js
+var require_auth = __commonJS((exports, module) => {
+  var Authorization = {
+    ALLOW: 0,
+    DENY: 1
   };
+  module.exports = Authorization;
 });
 
-// node_modules/better-sqlite3/lib/methods/aggregate.js
-var require_aggregate = __commonJS((exports, module) => {
-  var { getBooleanOption, cppdb } = require_util();
-  module.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 inverse2 = 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), inverse2 ? getLength(inverse2) : 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, inverse2, 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");
-  };
+// node_modules/libsql/sqlite-error.js
+var require_sqlite_error = __commonJS((exports, module) => {
+  var descriptor = { value: "SqliteError", writable: true, enumerable: false, configurable: true };
+  function SqliteError(message, code, rawCode) {
+    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;
+    this.rawCode = rawCode;
+  }
+  Object.setPrototypeOf(SqliteError, Error);
+  Object.setPrototypeOf(SqliteError.prototype, Error.prototype);
+  Object.defineProperty(SqliteError.prototype, "name", descriptor);
+  module.exports = SqliteError;
 });
 
-// node_modules/better-sqlite3/lib/methods/table.js
-var require_table = __commonJS((exports, module) => {
-  var { cppdb } = require_util();
-  module.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`);
+// node_modules/libsql/index.js
+var require_libsql = __commonJS((exports, module) => {
+  var __dirname = "/home/runner/work/terradb/terradb/node_modules/libsql";
+  var { load: load2, currentTarget } = require_dist3();
+  var { familySync, GLIBC, MUSL } = require_detect_libc();
+  function requireNative() {
+    if (process.env.LIBSQL_JS_DEV) {
+      return load2(__dirname);
+    }
+    let target = currentTarget();
+    if (familySync() == GLIBC) {
+      switch (target) {
+        case "linux-x64-musl":
+          target = "linux-x64-gnu";
+          break;
+        case "linux-arm64-musl":
+          target = "linux-arm64-gnu";
+          break;
       }
-      return parseTableDefinition(def, "returned", moduleName);
-    };
+    }
+    if (target === "linux-arm-gnueabihf" && familySync() == MUSL) {
+      target = "linux-arm-musleabihf";
+    }
+    return __require(`@libsql/${target}`);
+  }
+  var {
+    databaseOpen,
+    databaseOpenWithSync,
+    databaseInTransaction,
+    databaseInterrupt,
+    databaseClose,
+    databaseSyncSync,
+    databaseSyncUntilSync,
+    databaseExecSync,
+    databasePrepareSync,
+    databaseDefaultSafeIntegers,
+    databaseAuthorizer,
+    databaseLoadExtension,
+    databaseMaxWriteReplicationIndex,
+    statementRaw,
+    statementIsReader,
+    statementGet,
+    statementRun,
+    statementInterrupt,
+    statementRowsSync,
+    statementColumns,
+    statementSafeIntegers,
+    rowsNext
+  } = requireNative();
+  var Authorization = require_auth();
+  var SqliteError = require_sqlite_error();
+  function convertError(err) {
+    if (err.libsqlError) {
+      return new SqliteError(err.message, err.code, err.rawCode);
+    }
+    return err;
   }
-  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`);
+
+  class Database {
+    constructor(path, opts) {
+      const encryptionCipher = opts?.encryptionCipher ?? "aes256cbc";
+      if (opts && opts.syncUrl) {
+        var authToken = "";
+        if (opts.syncAuth) {
+          console.warn("Warning: The `syncAuth` option is deprecated, please use `authToken` option instead.");
+          authToken = opts.syncAuth;
+        } else if (opts.authToken) {
+          authToken = opts.authToken;
+        }
+        const encryptionKey = opts?.encryptionKey ?? "";
+        const syncPeriod = opts?.syncPeriod ?? 0;
+        const readYourWrites = opts?.readYourWrites ?? true;
+        const offline = opts?.offline ?? false;
+        const remoteEncryptionKey = opts?.remoteEncryptionKey ?? "";
+        this.db = databaseOpenWithSync(path, opts.syncUrl, authToken, encryptionCipher, encryptionKey, syncPeriod, readYourWrites, offline, remoteEncryptionKey);
+      } else {
+        const authToken2 = opts?.authToken ?? "";
+        const encryptionKey = opts?.encryptionKey ?? "";
+        const timeout = opts?.timeout ?? 0;
+        const remoteEncryptionKey = opts?.remoteEncryptionKey ?? "";
+        this.db = databaseOpen(path, authToken2, encryptionCipher, encryptionKey, timeout, remoteEncryptionKey);
+      }
+      this.memory = path === ":memory:";
+      this.readonly = false;
+      this.name = "";
+      this.open = true;
+      const db = this.db;
+      Object.defineProperties(this, {
+        inTransaction: {
+          get() {
+            return databaseInTransaction(db);
+          }
+        }
+      });
     }
-    if (!hasOwnProperty.call(def, "columns")) {
-      throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition without a "columns" property`);
+    sync() {
+      return databaseSyncSync.call(this.db);
     }
-    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)`);
+    syncUntil(replicationIndex) {
+      return databaseSyncUntilSync.call(this.db, replicationIndex);
     }
-    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)`);
+    prepare(sql) {
+      try {
+        const stmt = databasePrepareSync.call(this.db, sql);
+        return new Statement(stmt);
+      } catch (err) {
+        throw convertError(err);
+      }
     }
-    if (columns.length !== new Set(columns).size) {
-      throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with duplicate column names`);
+    transaction(fn) {
+      if (typeof fn !== "function")
+        throw new TypeError("Expected first argument to be a function");
+      const db = this;
+      const wrapTxn = (mode) => {
+        return (...bindParameters) => {
+          db.exec("BEGIN " + mode);
+          try {
+            const result = fn(...bindParameters);
+            db.exec("COMMIT");
+            return result;
+          } catch (err) {
+            db.exec("ROLLBACK");
+            throw err;
+          }
+        };
+      };
+      const properties = {
+        default: { value: wrapTxn("") },
+        deferred: { value: wrapTxn("DEFERRED") },
+        immediate: { value: wrapTxn("IMMEDIATE") },
+        exclusive: { value: wrapTxn("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;
+    }
+    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 = options["simple"];
+      const stmt = this.prepare(`PRAGMA ${source}`, this, true);
+      return simple ? stmt.pluck().get() : stmt.all();
+    }
+    backup(filename, options) {
+      throw new Error("not implemented");
+    }
+    serialize(options) {
+      throw new Error("not implemented");
+    }
+    function(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");
+      throw new Error("not implemented");
+    }
+    aggregate(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");
+      throw new Error("not implemented");
     }
-    if (!columns.length) {
-      throw new RangeError(`Virtual table module "${moduleName}" ${verb} a table definition with zero columns`);
+    table(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");
+      throw new Error("not implemented");
     }
-    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);
+    authorizer(rules) {
+      databaseAuthorizer.call(this.db, rules);
     }
-    if (parameters.length !== new Set(parameters).size) {
-      throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with duplicate parameter names`);
+    loadExtension(...args) {
+      databaseLoadExtension.call(this.db, ...args);
     }
-    if (parameters.length > 32) {
-      throw new RangeError(`Virtual table module "${moduleName}" ${verb} a table definition with more than the maximum number of 32 parameters`);
+    maxWriteReplicationIndex() {
+      return databaseMaxWriteReplicationIndex.call(this.db);
     }
-    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`);
+    exec(sql) {
+      try {
+        databaseExecSync.call(this.db, sql);
+      } catch (err) {
+        throw convertError(err);
       }
     }
-    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;
+    interrupt() {
+      databaseInterrupt.call(this.db);
     }
-    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)`);
-      }
+    close() {
+      databaseClose.call(this.db);
+      this.open = false;
+    }
+    defaultSafeIntegers(toggle) {
+      databaseDefaultSafeIntegers.call(this.db, toggle ?? true);
+      return this;
+    }
+    unsafeMode(...args) {
+      throw new Error("not implemented");
     }
-    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;
+
+  class Statement {
+    constructor(stmt) {
+      this.stmt = stmt;
+      this.pluckMode = false;
+    }
+    raw(raw) {
+      statementRaw.call(this.stmt, raw ?? true);
+      return this;
+    }
+    pluck(pluckMode) {
+      this.pluckMode = pluckMode ?? true;
+      return this;
+    }
+    get reader() {
+      return statementIsReader.call(this.stmt);
+    }
+    run(...bindParameters) {
+      try {
+        if (bindParameters.length == 1 && typeof bindParameters[0] === "object") {
+          return statementRun.call(this.stmt, bindParameters[0]);
         } else {
-          throw new TypeError(`Virtual table module "${moduleName}" yielded something that isn't a valid row object`);
+          return statementRun.call(this.stmt, bindParameters.flat());
         }
+      } catch (err) {
+        throw convertError(err);
       }
-    };
-  }
-  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 === undefined) {
-        throw new TypeError(`Virtual table module "${moduleName}" yielded a row with an undeclared column "${key}"`);
+    get(...bindParameters) {
+      try {
+        if (bindParameters.length == 1 && typeof bindParameters[0] === "object") {
+          return statementGet.call(this.stmt, bindParameters[0]);
+        } else {
+          return statementGet.call(this.stmt, bindParameters.flat());
+        }
+      } catch (err) {
+        throw convertError(err);
       }
-      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");
+    iterate(...bindParameters) {
+      var rows = undefined;
+      if (bindParameters.length == 1 && typeof bindParameters[0] === "object") {
+        rows = statementRowsSync.call(this.stmt, bindParameters[0]);
+      } else {
+        rows = statementRowsSync.call(this.stmt, bindParameters.flat());
+      }
+      const iter = {
+        nextRows: Array(100),
+        nextRowIndex: 100,
+        next() {
+          try {
+            if (this.nextRowIndex === 100) {
+              rowsNext.call(rows, this.nextRows);
+              this.nextRowIndex = 0;
+            }
+            const row = this.nextRows[this.nextRowIndex];
+            this.nextRows[this.nextRowIndex] = undefined;
+            if (!row) {
+              return { done: true };
+            }
+            this.nextRowIndex++;
+            return { value: row, done: false };
+          } catch (err) {
+            throw convertError(err);
+          }
+        },
+        [Symbol.iterator]() {
+          return this;
+        }
+      };
+      return iter;
     }
-    const params = [];
-    for (let i = 0;i < length; ++i) {
-      params.push(`$${i + 1}`);
+    all(...bindParameters) {
+      try {
+        const result = [];
+        for (const row of this.iterate(...bindParameters)) {
+          if (this.pluckMode) {
+            result.push(row[Object.keys(row)[0]]);
+          } else {
+            result.push(row);
+          }
+        }
+        return result;
+      } catch (err) {
+        throw convertError(err);
+      }
     }
-    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;
-});
-
-// node_modules/better-sqlite3/lib/methods/inspect.js
-var require_inspect = __commonJS((exports, module) => {
-  var DatabaseInspection = function Database() {};
-  module.exports = function inspect(depth, opts) {
-    return Object.assign(new DatabaseInspection, this);
-  };
-});
-
-// node_modules/better-sqlite3/lib/database.js
-var require_database = __commonJS((exports, module) => {
-  var fs = __require("fs");
-  var path = __require("path");
-  var util = require_util();
-  var SqliteError = require_sqlite_error();
-  var DEFAULT_ADDON;
-  function Database(filenameGiven, options) {
-    if (new.target == null) {
-      return new Database(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 : 5000;
-    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(path.resolve(nativeBinding).replace(/(\.node)?$/, ".node"));
-    } else {
-      addon = nativeBinding;
+    interrupt() {
+      statementInterrupt.call(this.stmt);
     }
-    if (!addon.isInitialized) {
-      addon.setErrorConstructor(SqliteError);
-      addon.isInitialized = true;
+    columns() {
+      return statementColumns.call(this.stmt);
     }
-    if (!anonymous && !filename.startsWith("file:") && !fs.existsSync(path.dirname(filename))) {
-      throw new TypeError("Cannot open database because the directory does not exist");
+    safeIntegers(toggle) {
+      statementSafeIntegers.call(this.stmt, toggle ?? true);
+      return this;
     }
-    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();
-  Database.prototype.prepare = wrappers.prepare;
-  Database.prototype.transaction = require_transaction();
-  Database.prototype.pragma = require_pragma();
-  Database.prototype.backup = require_backup();
-  Database.prototype.serialize = require_serialize();
-  Database.prototype.function = require_function();
-  Database.prototype.aggregate = require_aggregate();
-  Database.prototype.table = require_table();
-  Database.prototype.loadExtension = wrappers.loadExtension;
-  Database.prototype.exec = wrappers.exec;
-  Database.prototype.close = wrappers.close;
-  Database.prototype.defaultSafeIntegers = wrappers.defaultSafeIntegers;
-  Database.prototype.unsafeMode = wrappers.unsafeMode;
-  Database.prototype[util.inspect] = require_inspect();
   module.exports = Database;
-});
-
-// node_modules/better-sqlite3/lib/index.js
-var require_lib3 = __commonJS((exports, module) => {
-  module.exports = require_database();
-  module.exports.SqliteError = require_sqlite_error();
+  module.exports.Authorization = Authorization;
+  module.exports.SqliteError = SqliteError;
 });
 
 // src/providers/sqlite/client.ts
-async function loadDatabase(filename) {
-  if (isBun) {
-    const { Database } = await import("bun:sqlite");
-    return new Database(filename);
-  } else {
-    const Database = (await Promise.resolve().then(() => __toESM(require_lib3(), 1))).default;
-    return new Database(filename);
-  }
-}
-
 class SQLiteClient {
   db;
   constructor() {}
   static async create(config6) {
     const client = new SQLiteClient;
-    client.db = await loadDatabase(config6.filename);
+    client.db = new import_libsql.default(config6.filename);
     client.db.exec("PRAGMA foreign_keys = ON");
     return client;
   }
@@ -26591,9 +26522,9 @@ class SQLiteClient {
     return this.db.transaction(fn)();
   }
 }
-var isBun;
+var import_libsql;
 var init_client = __esm(() => {
-  isBun = typeof globalThis.Bun !== "undefined";
+  import_libsql = __toESM(require_libsql(), 1);
 });
 
 // src/providers/sqlite/inspector.ts
@@ -30483,7 +30414,7 @@ async function applyCommand(options, connectionStringOrConfig) {
 // package.json
 var package_default = {
   name: "terradb",
-  version: "0.5.3",
+  version: "0.5.5",
   description: "Declarative schema management for PostgreSQL and SQLite",
   keywords: [
     "postgres",
@@ -30552,18 +30483,17 @@ var package_default = {
     "release:major": "bun run tools/release.ts major"
   },
   dependencies: {
-    "better-sqlite3": "^12.5.0",
     boxen: "^8.0.1",
     chalk: "^5.3.0",
     commander: "^11.1.0",
     diff: "^5.1.0",
+    libsql: "^0.5.22",
     ora: "^9.0.0",
     pg: "^8.11.3",
     "pgsql-parser": "^17.8.2",
     "sql.js": "^1.13.0"
   },
   devDependencies: {
-    "@types/better-sqlite3": "^7.6.13",
     "@types/bun": "latest",
     "@types/diff": "^5.0.8",
     "@types/pg": "^8.10.9",