cursor-history-mcp 0.1.3 → 0.1.5

package/dist/{index.js → index.cjs}

@@ -1,20 +1,12 @@
 #!/usr/bin/env node
+"use strict";
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-var __commonJS = (cb, mod) => function __require2() {
+var __commonJS = (cb, mod) => function __require() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
 var __copyProps = (to, from, except, desc) => {
@@ -34,1459 +26,652 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
-// node_modules/tsup/assets/esm_shims.js
-import { fileURLToPath } from "url";
-var getFilename, __filename;
-var init_esm_shims = __esm({
-  "node_modules/tsup/assets/esm_shims.js"() {
-    "use strict";
-    getFilename = () => fileURLToPath(import.meta.url);
-    __filename = /* @__PURE__ */ getFilename();
-  }
-});
-
-// node_modules/better-sqlite3/lib/util.js
-var require_util = __commonJS({
-  "node_modules/better-sqlite3/lib/util.js"(exports) {
+// node_modules/adm-zip/util/constants.js
+var require_constants = __commonJS({
+  "node_modules/adm-zip/util/constants.js"(exports2, module2) {
     "use strict";
-    init_esm_shims();
-    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`);
-      }
-      return value;
+    module2.exports = {
+      /* The local file header */
+      LOCHDR: 30,
+      // LOC header size
+      LOCSIG: 67324752,
+      // "PK\003\004"
+      LOCVER: 4,
+      // version needed to extract
+      LOCFLG: 6,
+      // general purpose bit flag
+      LOCHOW: 8,
+      // compression method
+      LOCTIM: 10,
+      // modification time (2 bytes time, 2 bytes date)
+      LOCCRC: 14,
+      // uncompressed file crc-32 value
+      LOCSIZ: 18,
+      // compressed size
+      LOCLEN: 22,
+      // uncompressed size
+      LOCNAM: 26,
+      // filename length
+      LOCEXT: 28,
+      // extra field length
+      /* The Data descriptor */
+      EXTSIG: 134695760,
+      // "PK\007\008"
+      EXTHDR: 16,
+      // EXT header size
+      EXTCRC: 4,
+      // uncompressed file crc-32 value
+      EXTSIZ: 8,
+      // compressed size
+      EXTLEN: 12,
+      // uncompressed size
+      /* The central directory file header */
+      CENHDR: 46,
+      // CEN header size
+      CENSIG: 33639248,
+      // "PK\001\002"
+      CENVEM: 4,
+      // version made by
+      CENVER: 6,
+      // version needed to extract
+      CENFLG: 8,
+      // encrypt, decrypt flags
+      CENHOW: 10,
+      // compression method
+      CENTIM: 12,
+      // modification time (2 bytes time, 2 bytes date)
+      CENCRC: 16,
+      // uncompressed file crc-32 value
+      CENSIZ: 20,
+      // compressed size
+      CENLEN: 24,
+      // uncompressed size
+      CENNAM: 28,
+      // filename length
+      CENEXT: 30,
+      // extra field length
+      CENCOM: 32,
+      // file comment length
+      CENDSK: 34,
+      // volume number start
+      CENATT: 36,
+      // internal file attributes
+      CENATX: 38,
+      // external file attributes (host system dependent)
+      CENOFF: 42,
+      // LOC header offset
+      /* The entries in the end of central directory */
+      ENDHDR: 22,
+      // END header size
+      ENDSIG: 101010256,
+      // "PK\005\006"
+      ENDSUB: 8,
+      // number of entries on this disk
+      ENDTOT: 10,
+      // total number of entries
+      ENDSIZ: 12,
+      // central directory size in bytes
+      ENDOFF: 16,
+      // offset of first CEN header
+      ENDCOM: 20,
+      // zip file comment length
+      END64HDR: 20,
+      // zip64 END header size
+      END64SIG: 117853008,
+      // zip64 Locator signature, "PK\006\007"
+      END64START: 4,
+      // number of the disk with the start of the zip64
+      END64OFF: 8,
+      // relative offset of the zip64 end of central directory
+      END64NUMDISKS: 16,
+      // total number of disks
+      ZIP64SIG: 101075792,
+      // zip64 signature, "PK\006\006"
+      ZIP64HDR: 56,
+      // zip64 record minimum size
+      ZIP64LEAD: 12,
+      // leading bytes at the start of the record, not counted by the value stored in ZIP64SIZE
+      ZIP64SIZE: 4,
+      // zip64 size of the central directory record
+      ZIP64VEM: 12,
+      // zip64 version made by
+      ZIP64VER: 14,
+      // zip64 version needed to extract
+      ZIP64DSK: 16,
+      // zip64 number of this disk
+      ZIP64DSKDIR: 20,
+      // number of the disk with the start of the record directory
+      ZIP64SUB: 24,
+      // number of entries on this disk
+      ZIP64TOT: 32,
+      // total number of entries
+      ZIP64SIZB: 40,
+      // zip64 central directory size in bytes
+      ZIP64OFF: 48,
+      // offset of start of central directory with respect to the starting disk number
+      ZIP64EXTRA: 56,
+      // extensible data sector
+      /* Compression methods */
+      STORED: 0,
+      // no compression
+      SHRUNK: 1,
+      // shrunk
+      REDUCED1: 2,
+      // reduced with compression factor 1
+      REDUCED2: 3,
+      // reduced with compression factor 2
+      REDUCED3: 4,
+      // reduced with compression factor 3
+      REDUCED4: 5,
+      // reduced with compression factor 4
+      IMPLODED: 6,
+      // imploded
+      // 7 reserved for Tokenizing compression algorithm
+      DEFLATED: 8,
+      // deflated
+      ENHANCED_DEFLATED: 9,
+      // enhanced deflated
+      PKWARE: 10,
+      // PKWare DCL imploded
+      // 11 reserved by PKWARE
+      BZIP2: 12,
+      //  compressed using BZIP2
+      // 13 reserved by PKWARE
+      LZMA: 14,
+      // LZMA
+      // 15-17 reserved by PKWARE
+      IBM_TERSE: 18,
+      // compressed using IBM TERSE
+      IBM_LZ77: 19,
+      // IBM LZ77 z
+      AES_ENCRYPT: 99,
+      // WinZIP AES encryption method
+      /* General purpose bit flag */
+      // values can obtained with expression 2**bitnr
+      FLG_ENC: 1,
+      // Bit 0: encrypted file
+      FLG_COMP1: 2,
+      // Bit 1, compression option
+      FLG_COMP2: 4,
+      // Bit 2, compression option
+      FLG_DESC: 8,
+      // Bit 3, data descriptor
+      FLG_ENH: 16,
+      // Bit 4, enhanced deflating
+      FLG_PATCH: 32,
+      // Bit 5, indicates that the file is compressed patched data.
+      FLG_STR: 64,
+      // Bit 6, strong encryption (patented)
+      // Bits 7-10: Currently unused.
+      FLG_EFS: 2048,
+      // Bit 11: Language encoding flag (EFS)
+      // Bit 12: Reserved by PKWARE for enhanced compression.
+      // Bit 13: encrypted the Central Directory (patented).
+      // Bits 14-15: Reserved by PKWARE.
+      FLG_MSK: 4096,
+      // mask header values
+      /* Load type */
+      FILE: 2,
+      BUFFER: 1,
+      NONE: 0,
+      /* 4.5 Extensible data fields */
+      EF_ID: 0,
+      EF_SIZE: 2,
+      /* Header IDs */
+      ID_ZIP64: 1,
+      ID_AVINFO: 7,
+      ID_PFS: 8,
+      ID_OS2: 9,
+      ID_NTFS: 10,
+      ID_OPENVMS: 12,
+      ID_UNIX: 13,
+      ID_FORK: 14,
+      ID_PATCH: 15,
+      ID_X509_PKCS7: 20,
+      ID_X509_CERTID_F: 21,
+      ID_X509_CERTID_C: 22,
+      ID_STRONGENC: 23,
+      ID_RECORD_MGT: 24,
+      ID_X509_PKCS7_RL: 25,
+      ID_IBM1: 101,
+      ID_IBM2: 102,
+      ID_POSZIP: 18064,
+      EF_ZIP64_OR_32: 4294967295,
+      EF_ZIP64_OR_16: 65535,
+      EF_ZIP64_SUNCOMP: 0,
+      EF_ZIP64_SCOMP: 8,
+      EF_ZIP64_RHO: 16,
+      EF_ZIP64_DSN: 24
     };
-    exports.cppdb = Symbol();
-    exports.inspect = Symbol.for("nodejs.util.inspect.custom");
-  }
-});
-
-// node_modules/better-sqlite3/lib/sqlite-error.js
-var require_sqlite_error = __commonJS({
-  "node_modules/better-sqlite3/lib/sqlite-error.js"(exports, module) {
-    "use strict";
-    init_esm_shims();
-    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);
-    module.exports = SqliteError;
   }
 });
 
-// node_modules/file-uri-to-path/index.js
-var require_file_uri_to_path = __commonJS({
-  "node_modules/file-uri-to-path/index.js"(exports, module) {
+// node_modules/adm-zip/util/errors.js
+var require_errors = __commonJS({
+  "node_modules/adm-zip/util/errors.js"(exports2) {
     "use strict";
-    init_esm_shims();
-    var sep2 = __require("path").sep || "/";
-    module.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 path = rest.substring(firstSlash + 1);
-      if ("localhost" == host) host = "";
-      if (host) {
-        host = sep2 + sep2 + host;
-      }
-      path = path.replace(/^(.+)\|/, "$1:");
-      if (sep2 == "\\") {
-        path = path.replace(/\//g, "\\");
-      }
-      if (/^.+\:/.test(path)) {
-      } else {
-        path = sep2 + path;
-      }
-      return host + path;
+    var errors = {
+      /* Header error messages */
+      INVALID_LOC: "Invalid LOC header (bad signature)",
+      INVALID_CEN: "Invalid CEN header (bad signature)",
+      INVALID_END: "Invalid END header (bad signature)",
+      /* Descriptor */
+      DESCRIPTOR_NOT_EXIST: "No descriptor present",
+      DESCRIPTOR_UNKNOWN: "Unknown descriptor format",
+      DESCRIPTOR_FAULTY: "Descriptor data is malformed",
+      /* ZipEntry error messages*/
+      NO_DATA: "Nothing to decompress",
+      BAD_CRC: "CRC32 checksum failed {0}",
+      FILE_IN_THE_WAY: "There is a file in the way: {0}",
+      UNKNOWN_METHOD: "Invalid/unsupported compression method",
+      /* Inflater error messages */
+      AVAIL_DATA: "inflate::Available inflate data did not terminate",
+      INVALID_DISTANCE: "inflate::Invalid literal/length or distance code in fixed or dynamic block",
+      TO_MANY_CODES: "inflate::Dynamic block code description: too many length or distance codes",
+      INVALID_REPEAT_LEN: "inflate::Dynamic block code description: repeat more than specified lengths",
+      INVALID_REPEAT_FIRST: "inflate::Dynamic block code description: repeat lengths with no first length",
+      INCOMPLETE_CODES: "inflate::Dynamic block code description: code lengths codes incomplete",
+      INVALID_DYN_DISTANCE: "inflate::Dynamic block code description: invalid distance code lengths",
+      INVALID_CODES_LEN: "inflate::Dynamic block code description: invalid literal/length code lengths",
+      INVALID_STORE_BLOCK: "inflate::Stored block length did not match one's complement",
+      INVALID_BLOCK_TYPE: "inflate::Invalid block type (type == 3)",
+      /* ADM-ZIP error messages */
+      CANT_EXTRACT_FILE: "Could not extract the file",
+      CANT_OVERRIDE: "Target file already exists",
+      DISK_ENTRY_TOO_LARGE: "Number of disk entries is too large",
+      NO_ZIP: "No zip file was loaded",
+      NO_ENTRY: "Entry doesn't exist",
+      DIRECTORY_CONTENT_ERROR: "A directory cannot have content",
+      FILE_NOT_FOUND: 'File not found: "{0}"',
+      NOT_IMPLEMENTED: "Not implemented",
+      INVALID_FILENAME: "Invalid filename",
+      INVALID_FORMAT: "Invalid or unsupported zip format. No END header found",
+      INVALID_PASS_PARAM: "Incompatible password parameter",
+      WRONG_PASSWORD: "Wrong Password",
+      /* ADM-ZIP */
+      COMMENT_TOO_LONG: "Comment is too long",
+      // Comment can be max 65535 bytes long (NOTE: some non-US characters may take more space)
+      EXTRA_FIELD_PARSE_ERROR: "Extra field parsing error"
+    };
+    function E(message) {
+      return function(...args) {
+        if (args.length) {
+          message = message.replace(/\{(\d)\}/g, (_, n) => args[n] || "");
+        }
+        return new Error("ADM-ZIP: " + message);
+      };
+    }
+    for (const msg of Object.keys(errors)) {
+      exports2[msg] = E(errors[msg]);
     }
   }
 });
 
-// node_modules/bindings/bindings.js
-var require_bindings = __commonJS({
-  "node_modules/bindings/bindings.js"(exports, module) {
+// node_modules/adm-zip/util/utils.js
+var require_utils = __commonJS({
+  "node_modules/adm-zip/util/utils.js"(exports2, module2) {
     "use strict";
-    init_esm_shims();
-    var fs = __require("fs");
-    var path = __require("path");
-    var fileURLToPath2 = require_file_uri_to_path();
-    var join5 = path.join;
-    var dirname2 = path.dirname;
-    var exists = fs.accessSync && function(path2) {
-      try {
-        fs.accessSync(path2);
-      } catch (e) {
-        return false;
-      }
-      return true;
-    } || fs.existsSync || path.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 = exports.getRoot(exports.getFileName());
-      }
-      if (path.extname(opts.bindings) != ".node") {
-        opts.bindings += ".node";
+    var fsystem = require("fs");
+    var pth = require("path");
+    var Constants = require_constants();
+    var Errors = require_errors();
+    var isWin = typeof process === "object" && "win32" === process.platform;
+    var is_Obj = (obj) => typeof obj === "object" && obj !== null;
+    var crcTable = new Uint32Array(256).map((t, c) => {
+      for (let k = 0; k < 8; k++) {
+        if ((c & 1) !== 0) {
+          c = 3988292384 ^ c >>> 1;
+        } else {
+          c >>>= 1;
+        }
       }
-      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 = join5.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;
-          }
+      return c >>> 0;
+    });
+    function Utils(opts) {
+      this.sep = pth.sep;
+      this.fs = fsystem;
+      if (is_Obj(opts)) {
+        if (is_Obj(opts.fs) && typeof opts.fs.statSync === "function") {
+          this.fs = opts.fs;
         }
       }
-      err = new Error(
-        "Could not locate the bindings file. Tried:\n" + tries.map(function(a) {
-          return opts.arrow + a;
-        }).join("\n")
-      );
-      err.tries = tries;
-      throw err;
     }
-    module.exports = exports = bindings;
-    exports.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;
-            }
+    module2.exports = Utils;
+    Utils.prototype.makeDir = function(folder) {
+      const self = this;
+      function mkdirSync2(fpath) {
+        let resolvedPath = fpath.split(self.sep)[0];
+        fpath.split(self.sep).forEach(function(name) {
+          if (!name || name.substr(-1, 1) === ":") return;
+          resolvedPath += self.sep + name;
+          var stat;
+          try {
+            stat = self.fs.statSync(resolvedPath);
+          } catch (e) {
+            self.fs.mkdirSync(resolvedPath);
           }
-        }
-      };
-      Error.captureStackTrace(dummy);
-      dummy.stack;
-      Error.prepareStackTrace = origPST;
-      Error.stackTraceLimit = origSTL;
-      var fileSchema = "file://";
-      if (fileName.indexOf(fileSchema) === 0) {
-        fileName = fileURLToPath2(fileName);
+          if (stat && stat.isFile()) throw Errors.FILE_IN_THE_WAY(`"${resolvedPath}"`);
+        });
       }
-      return fileName;
+      mkdirSync2(folder);
     };
-    exports.getRoot = function getRoot(file) {
-      var dir = dirname2(file), prev;
-      while (true) {
-        if (dir === ".") {
-          dir = process.cwd();
-        }
-        if (exists(join5(dir, "package.json")) || exists(join5(dir, "node_modules"))) {
-          return dir;
+    Utils.prototype.writeFileTo = function(path, content, overwrite, attr) {
+      const self = this;
+      if (self.fs.existsSync(path)) {
+        if (!overwrite) return false;
+        var stat = self.fs.statSync(path);
+        if (stat.isDirectory()) {
+          return false;
         }
-        if (prev === dir) {
-          throw new Error(
-            'Could not find module root given file: "' + file + '". Do you have a `package.json` file? '
-          );
+      }
+      var folder = pth.dirname(path);
+      if (!self.fs.existsSync(folder)) {
+        self.makeDir(folder);
+      }
+      var fd;
+      try {
+        fd = self.fs.openSync(path, "w", 438);
+      } catch (e) {
+        self.fs.chmodSync(path, 438);
+        fd = self.fs.openSync(path, "w", 438);
+      }
+      if (fd) {
+        try {
+          self.fs.writeSync(fd, content, 0, content.length, 0);
+        } finally {
+          self.fs.closeSync(fd);
         }
-        prev = dir;
-        dir = join5(dir, "..");
       }
+      self.fs.chmodSync(path, attr || 438);
+      return true;
     };
-  }
-});
-
-// node_modules/better-sqlite3/lib/methods/wrappers.js
-var require_wrappers = __commonJS({
-  "node_modules/better-sqlite3/lib/methods/wrappers.js"(exports) {
-    "use strict";
-    init_esm_shims();
-    var { cppdb } = require_util();
-    exports.prepare = function prepare(sql) {
-      return this[cppdb].prepare(sql, this, false);
+    Utils.prototype.writeFileToAsync = function(path, content, overwrite, attr, callback) {
+      if (typeof attr === "function") {
+        callback = attr;
+        attr = void 0;
+      }
+      const self = this;
+      self.fs.exists(path, function(exist) {
+        if (exist && !overwrite) return callback(false);
+        self.fs.stat(path, function(err, stat) {
+          if (exist && stat.isDirectory()) {
+            return callback(false);
+          }
+          var folder = pth.dirname(path);
+          self.fs.exists(folder, function(exists) {
+            if (!exists) self.makeDir(folder);
+            self.fs.open(path, "w", 438, function(err2, fd) {
+              if (err2) {
+                self.fs.chmod(path, 438, function() {
+                  self.fs.open(path, "w", 438, function(err3, fd2) {
+                    self.fs.write(fd2, content, 0, content.length, 0, function() {
+                      self.fs.close(fd2, function() {
+                        self.fs.chmod(path, attr || 438, function() {
+                          callback(true);
+                        });
+                      });
+                    });
+                  });
+                });
+              } else if (fd) {
+                self.fs.write(fd, content, 0, content.length, 0, function() {
+                  self.fs.close(fd, function() {
+                    self.fs.chmod(path, attr || 438, function() {
+                      callback(true);
+                    });
+                  });
+                });
+              } else {
+                self.fs.chmod(path, attr || 438, function() {
+                  callback(true);
+                });
+              }
+            });
+          });
+        });
+      });
     };
-    exports.exec = function exec(sql) {
-      this[cppdb].exec(sql);
-      return this;
+    Utils.prototype.findFiles = function(path) {
+      const self = this;
+      function findSync(dir, pattern, recursive) {
+        if (typeof pattern === "boolean") {
+          recursive = pattern;
+          pattern = void 0;
+        }
+        let files = [];
+        self.fs.readdirSync(dir).forEach(function(file) {
+          const path2 = pth.join(dir, file);
+          const stat = self.fs.statSync(path2);
+          if (!pattern || pattern.test(path2)) {
+            files.push(pth.normalize(path2) + (stat.isDirectory() ? self.sep : ""));
+          }
+          if (stat.isDirectory() && recursive) files = files.concat(findSync(path2, pattern, recursive));
+        });
+        return files;
+      }
+      return findSync(path, void 0, true);
     };
-    exports.close = function close() {
-      this[cppdb].close();
-      return this;
+    Utils.prototype.findFilesAsync = function(dir, cb) {
+      const self = this;
+      let results = [];
+      self.fs.readdir(dir, function(err, list) {
+        if (err) return cb(err);
+        let list_length = list.length;
+        if (!list_length) return cb(null, results);
+        list.forEach(function(file) {
+          file = pth.join(dir, file);
+          self.fs.stat(file, function(err2, stat) {
+            if (err2) return cb(err2);
+            if (stat) {
+              results.push(pth.normalize(file) + (stat.isDirectory() ? self.sep : ""));
+              if (stat.isDirectory()) {
+                self.findFilesAsync(file, function(err3, res) {
+                  if (err3) return cb(err3);
+                  results = results.concat(res);
+                  if (!--list_length) cb(null, results);
+                });
+              } else {
+                if (!--list_length) cb(null, results);
+              }
+            }
+          });
+        });
+      });
     };
-    exports.loadExtension = function loadExtension(...args) {
-      this[cppdb].loadExtension(...args);
-      return this;
+    Utils.prototype.getAttributes = function() {
     };
-    exports.defaultSafeIntegers = function defaultSafeIntegers(...args) {
-      this[cppdb].defaultSafeIntegers(...args);
-      return this;
+    Utils.prototype.setAttributes = function() {
     };
-    exports.unsafeMode = function unsafeMode(...args) {
-      this[cppdb].unsafeMode(...args);
-      return this;
+    Utils.crc32update = function(crc, byte) {
+      return crcTable[(crc ^ byte) & 255] ^ crc >>> 8;
     };
-    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
+    Utils.crc32 = function(buf) {
+      if (typeof buf === "string") {
+        buf = Buffer.from(buf, "utf8");
       }
+      let len = buf.length;
+      let crc = ~0;
+      for (let off = 0; off < len; ) crc = Utils.crc32update(crc, buf[off++]);
+      return ~crc >>> 0;
     };
-  }
-});
-
-// node_modules/better-sqlite3/lib/methods/transaction.js
-var require_transaction = __commonJS({
-  "node_modules/better-sqlite3/lib/methods/transaction.js"(exports, module) {
-    "use strict";
-    init_esm_shims();
-    var { cppdb } = require_util();
-    var controllers = /* @__PURE__ */ 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 getController = (db, self) => {
-      let controller = controllers.get(db);
-      if (!controller) {
-        const shared = {
-          commit: db.prepare("COMMIT", self, false),
-          rollback: db.prepare("ROLLBACK", self, false),
-          savepoint: db.prepare("SAVEPOINT `	_bs3.	`", self, false),
-          release: db.prepare("RELEASE `	_bs3.	`", self, false),
-          rollbackTo: db.prepare("ROLLBACK TO `	_bs3.	`", self, false)
-        };
-        controllers.set(db, controller = {
-          default: Object.assign({ begin: db.prepare("BEGIN", self, false) }, shared),
-          deferred: Object.assign({ begin: db.prepare("BEGIN DEFERRED", self, false) }, shared),
-          immediate: Object.assign({ begin: db.prepare("BEGIN IMMEDIATE", self, false) }, shared),
-          exclusive: Object.assign({ begin: db.prepare("BEGIN EXCLUSIVE", self, false) }, shared)
-        });
+    Utils.methodToString = function(method) {
+      switch (method) {
+        case Constants.STORED:
+          return "STORED (" + method + ")";
+        case Constants.DEFLATED:
+          return "DEFLATED (" + method + ")";
+        default:
+          return "UNSUPPORTED (" + method + ")";
       }
-      return controller;
     };
-    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;
-      }
-      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 (db.inTransaction) {
-          undo.run();
-          if (undo !== rollback) after.run();
+    Utils.canonical = function(path) {
+      if (!path) return "";
+      const safeSuffix = pth.posix.normalize("/" + path.split("\\").join("/"));
+      return pth.join(".", safeSuffix);
+    };
+    Utils.zipnamefix = function(path) {
+      if (!path) return "";
+      const safeSuffix = pth.posix.normalize("/" + path.split("\\").join("/"));
+      return pth.posix.join(".", safeSuffix);
+    };
+    Utils.findLast = function(arr, callback) {
+      if (!Array.isArray(arr)) throw new TypeError("arr is not array");
+      const len = arr.length >>> 0;
+      for (let i = len - 1; i >= 0; i--) {
+        if (callback(arr[i], i, arr)) {
+          return arr[i];
         }
-        throw ex;
       }
+      return void 0;
     };
-  }
-});
-
-// node_modules/better-sqlite3/lib/methods/pragma.js
-var require_pragma = __commonJS({
-  "node_modules/better-sqlite3/lib/methods/pragma.js"(exports, module) {
-    "use strict";
-    init_esm_shims();
-    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();
+    Utils.sanitize = function(prefix, name) {
+      prefix = pth.resolve(pth.normalize(prefix));
+      var parts = name.split("/");
+      for (var i = 0, l = parts.length; i < l; i++) {
+        var path = pth.normalize(pth.join(prefix, parts.slice(i, l).join(pth.sep)));
+        if (path.indexOf(prefix) === 0) {
+          return path;
+        }
+      }
+      return pth.normalize(pth.join(prefix, pth.basename(name)));
     };
-  }
-});
-
-// node_modules/better-sqlite3/lib/methods/backup.js
-var require_backup = __commonJS({
-  "node_modules/better-sqlite3/lib/methods/backup.js"(exports, module) {
-    "use strict";
-    init_esm_shims();
-    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);
+    Utils.toBuffer = function toBuffer(input, encoder) {
+      if (Buffer.isBuffer(input)) {
+        return input;
+      } else if (input instanceof Uint8Array) {
+        return Buffer.from(input);
+      } else {
+        return typeof input === "string" ? encoder(input) : Buffer.alloc(0);
+      }
     };
-    var runBackup = (backup, handler) => {
-      let rate = 0;
-      let useDefault = true;
-      return new Promise((resolve2, reject) => {
-        setImmediate(function step() {
-          try {
-            const progress = backup.transfer(rate);
-            if (!progress.remainingPages) {
-              backup.close();
-              resolve2(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);
-          }
-        });
-      });
+    Utils.readBigUInt64LE = function(buffer, index) {
+      var slice = Buffer.from(buffer.slice(index, index + 8));
+      slice.swap64();
+      return parseInt(`0x${slice.toString("hex")}`);
+    };
+    Utils.fromDOS2Date = function(val) {
+      return new Date((val >> 25 & 127) + 1980, Math.max((val >> 21 & 15) - 1, 0), Math.max(val >> 16 & 31, 1), val >> 11 & 31, val >> 5 & 63, (val & 31) << 1);
+    };
+    Utils.fromDate2DOS = function(val) {
+      let date = 0;
+      let time = 0;
+      if (val.getFullYear() > 1979) {
+        date = (val.getFullYear() - 1980 & 127) << 9 | val.getMonth() + 1 << 5 | val.getDate();
+        time = val.getHours() << 11 | val.getMinutes() << 5 | val.getSeconds() >> 1;
+      }
+      return date << 16 | time;
     };
+    Utils.isWin = isWin;
+    Utils.crcTable = crcTable;
   }
 });
 
-// node_modules/better-sqlite3/lib/methods/serialize.js
-var require_serialize = __commonJS({
-  "node_modules/better-sqlite3/lib/methods/serialize.js"(exports, module) {
+// node_modules/adm-zip/util/fattr.js
+var require_fattr = __commonJS({
+  "node_modules/adm-zip/util/fattr.js"(exports2, module2) {
     "use strict";
-    init_esm_shims();
-    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);
+    var pth = require("path");
+    module2.exports = function(path, { fs }) {
+      var _path = path || "", _obj = newAttr(), _stat = null;
+      function newAttr() {
+        return {
+          directory: false,
+          readonly: false,
+          hidden: false,
+          executable: false,
+          mtime: 0,
+          atime: 0
+        };
+      }
+      if (_path && fs.existsSync(_path)) {
+        _stat = fs.statSync(_path);
+        _obj.directory = _stat.isDirectory();
+        _obj.mtime = _stat.mtime;
+        _obj.atime = _stat.atime;
+        _obj.executable = (73 & _stat.mode) !== 0;
+        _obj.readonly = (128 & _stat.mode) === 0;
+        _obj.hidden = pth.basename(_path)[0] === ".";
+      } else {
+        console.warn("Invalid path: " + _path);
+      }
+      return {
+        get directory() {
+          return _obj.directory;
+        },
+        get readOnly() {
+          return _obj.readonly;
+        },
+        get hidden() {
+          return _obj.hidden;
+        },
+        get mtime() {
+          return _obj.mtime;
+        },
+        get atime() {
+          return _obj.atime;
+        },
+        get executable() {
+          return _obj.executable;
+        },
+        decodeAttributes: function() {
+        },
+        encodeAttributes: function() {
+        },
+        toJSON: function() {
+          return {
+            path: _path,
+            isDirectory: _obj.directory,
+            isReadOnly: _obj.readonly,
+            isHidden: _obj.hidden,
+            isExecutable: _obj.executable,
+            mTime: _obj.mtime,
+            aTime: _obj.atime
+          };
+        },
+        toString: function() {
+          return JSON.stringify(this.toJSON(), null, "	");
+        }
+      };
     };
   }
 });
 
-// node_modules/better-sqlite3/lib/methods/function.js
-var require_function = __commonJS({
-  "node_modules/better-sqlite3/lib/methods/function.js"(exports, module) {
+// node_modules/adm-zip/util/decoder.js
+var require_decoder = __commonJS({
+  "node_modules/adm-zip/util/decoder.js"(exports2, module2) {
     "use strict";
-    init_esm_shims();
-    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;
+    module2.exports = {
+      efs: true,
+      encode: (data) => Buffer.from(data, "utf8"),
+      decode: (data) => data.toString("utf8")
     };
   }
 });
 
-// node_modules/better-sqlite3/lib/methods/aggregate.js
-var require_aggregate = __commonJS({
-  "node_modules/better-sqlite3/lib/methods/aggregate.js"(exports, module) {
+// node_modules/adm-zip/util/index.js
+var require_util = __commonJS({
+  "node_modules/adm-zip/util/index.js"(exports2, module2) {
     "use strict";
-    init_esm_shims();
-    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 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");
-    };
+    module2.exports = require_utils();
+    module2.exports.Constants = require_constants();
+    module2.exports.Errors = require_errors();
+    module2.exports.FileAttr = require_fattr();
+    module2.exports.decoder = require_decoder();
   }
 });
 
-// node_modules/better-sqlite3/lib/methods/table.js
-var require_table = __commonJS({
-  "node_modules/better-sqlite3/lib/methods/table.js"(exports, module) {
+// node_modules/adm-zip/headers/entryHeader.js
+var require_entryHeader = __commonJS({
+  "node_modules/adm-zip/headers/entryHeader.js"(exports2, module2) {
     "use strict";
-    init_esm_shims();
-    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`);
-        }
-        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;
-  }
-});
-
-// node_modules/better-sqlite3/lib/methods/inspect.js
-var require_inspect = __commonJS({
-  "node_modules/better-sqlite3/lib/methods/inspect.js"(exports, module) {
-    "use strict";
-    init_esm_shims();
-    var DatabaseInspection = function Database4() {
-    };
-    module.exports = function inspect(depth, opts) {
-      return Object.assign(new DatabaseInspection(), this);
-    };
-  }
-});
-
-// node_modules/better-sqlite3/lib/database.js
-var require_database = __commonJS({
-  "node_modules/better-sqlite3/lib/database.js"(exports, module) {
-    "use strict";
-    init_esm_shims();
-    var fs = __require("fs");
-    var path = __require("path");
-    var util2 = require_util();
-    var SqliteError = require_sqlite_error();
-    var DEFAULT_ADDON;
-    function Database4(filenameGiven, options) {
-      if (new.target == null) {
-        return new Database4(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 = util2.getBooleanOption(options, "readonly");
-      const fileMustExist = util2.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(path.resolve(nativeBinding).replace(/(\.node)?$/, ".node"));
-      } else {
-        addon = nativeBinding;
-      }
-      if (!addon.isInitialized) {
-        addon.setErrorConstructor(SqliteError);
-        addon.isInitialized = true;
-      }
-      if (!anonymous && !filename.startsWith("file:") && !fs.existsSync(path.dirname(filename))) {
-        throw new TypeError("Cannot open database because the directory does not exist");
-      }
-      Object.defineProperties(this, {
-        [util2.cppdb]: { value: new addon.Database(filename, filenameGiven, anonymous, readonly, fileMustExist, timeout, verbose || null, buffer || null) },
-        ...wrappers.getters
-      });
-    }
-    var wrappers = require_wrappers();
-    Database4.prototype.prepare = wrappers.prepare;
-    Database4.prototype.transaction = require_transaction();
-    Database4.prototype.pragma = require_pragma();
-    Database4.prototype.backup = require_backup();
-    Database4.prototype.serialize = require_serialize();
-    Database4.prototype.function = require_function();
-    Database4.prototype.aggregate = require_aggregate();
-    Database4.prototype.table = require_table();
-    Database4.prototype.loadExtension = wrappers.loadExtension;
-    Database4.prototype.exec = wrappers.exec;
-    Database4.prototype.close = wrappers.close;
-    Database4.prototype.defaultSafeIntegers = wrappers.defaultSafeIntegers;
-    Database4.prototype.unsafeMode = wrappers.unsafeMode;
-    Database4.prototype[util2.inspect] = require_inspect();
-    module.exports = Database4;
-  }
-});
-
-// node_modules/better-sqlite3/lib/index.js
-var require_lib = __commonJS({
-  "node_modules/better-sqlite3/lib/index.js"(exports, module) {
-    "use strict";
-    init_esm_shims();
-    module.exports = require_database();
-    module.exports.SqliteError = require_sqlite_error();
-  }
-});
-
-// node_modules/adm-zip/util/constants.js
-var require_constants = __commonJS({
-  "node_modules/adm-zip/util/constants.js"(exports, module) {
-    "use strict";
-    init_esm_shims();
-    module.exports = {
-      /* The local file header */
-      LOCHDR: 30,
-      // LOC header size
-      LOCSIG: 67324752,
-      // "PK\003\004"
-      LOCVER: 4,
-      // version needed to extract
-      LOCFLG: 6,
-      // general purpose bit flag
-      LOCHOW: 8,
-      // compression method
-      LOCTIM: 10,
-      // modification time (2 bytes time, 2 bytes date)
-      LOCCRC: 14,
-      // uncompressed file crc-32 value
-      LOCSIZ: 18,
-      // compressed size
-      LOCLEN: 22,
-      // uncompressed size
-      LOCNAM: 26,
-      // filename length
-      LOCEXT: 28,
-      // extra field length
-      /* The Data descriptor */
-      EXTSIG: 134695760,
-      // "PK\007\008"
-      EXTHDR: 16,
-      // EXT header size
-      EXTCRC: 4,
-      // uncompressed file crc-32 value
-      EXTSIZ: 8,
-      // compressed size
-      EXTLEN: 12,
-      // uncompressed size
-      /* The central directory file header */
-      CENHDR: 46,
-      // CEN header size
-      CENSIG: 33639248,
-      // "PK\001\002"
-      CENVEM: 4,
-      // version made by
-      CENVER: 6,
-      // version needed to extract
-      CENFLG: 8,
-      // encrypt, decrypt flags
-      CENHOW: 10,
-      // compression method
-      CENTIM: 12,
-      // modification time (2 bytes time, 2 bytes date)
-      CENCRC: 16,
-      // uncompressed file crc-32 value
-      CENSIZ: 20,
-      // compressed size
-      CENLEN: 24,
-      // uncompressed size
-      CENNAM: 28,
-      // filename length
-      CENEXT: 30,
-      // extra field length
-      CENCOM: 32,
-      // file comment length
-      CENDSK: 34,
-      // volume number start
-      CENATT: 36,
-      // internal file attributes
-      CENATX: 38,
-      // external file attributes (host system dependent)
-      CENOFF: 42,
-      // LOC header offset
-      /* The entries in the end of central directory */
-      ENDHDR: 22,
-      // END header size
-      ENDSIG: 101010256,
-      // "PK\005\006"
-      ENDSUB: 8,
-      // number of entries on this disk
-      ENDTOT: 10,
-      // total number of entries
-      ENDSIZ: 12,
-      // central directory size in bytes
-      ENDOFF: 16,
-      // offset of first CEN header
-      ENDCOM: 20,
-      // zip file comment length
-      END64HDR: 20,
-      // zip64 END header size
-      END64SIG: 117853008,
-      // zip64 Locator signature, "PK\006\007"
-      END64START: 4,
-      // number of the disk with the start of the zip64
-      END64OFF: 8,
-      // relative offset of the zip64 end of central directory
-      END64NUMDISKS: 16,
-      // total number of disks
-      ZIP64SIG: 101075792,
-      // zip64 signature, "PK\006\006"
-      ZIP64HDR: 56,
-      // zip64 record minimum size
-      ZIP64LEAD: 12,
-      // leading bytes at the start of the record, not counted by the value stored in ZIP64SIZE
-      ZIP64SIZE: 4,
-      // zip64 size of the central directory record
-      ZIP64VEM: 12,
-      // zip64 version made by
-      ZIP64VER: 14,
-      // zip64 version needed to extract
-      ZIP64DSK: 16,
-      // zip64 number of this disk
-      ZIP64DSKDIR: 20,
-      // number of the disk with the start of the record directory
-      ZIP64SUB: 24,
-      // number of entries on this disk
-      ZIP64TOT: 32,
-      // total number of entries
-      ZIP64SIZB: 40,
-      // zip64 central directory size in bytes
-      ZIP64OFF: 48,
-      // offset of start of central directory with respect to the starting disk number
-      ZIP64EXTRA: 56,
-      // extensible data sector
-      /* Compression methods */
-      STORED: 0,
-      // no compression
-      SHRUNK: 1,
-      // shrunk
-      REDUCED1: 2,
-      // reduced with compression factor 1
-      REDUCED2: 3,
-      // reduced with compression factor 2
-      REDUCED3: 4,
-      // reduced with compression factor 3
-      REDUCED4: 5,
-      // reduced with compression factor 4
-      IMPLODED: 6,
-      // imploded
-      // 7 reserved for Tokenizing compression algorithm
-      DEFLATED: 8,
-      // deflated
-      ENHANCED_DEFLATED: 9,
-      // enhanced deflated
-      PKWARE: 10,
-      // PKWare DCL imploded
-      // 11 reserved by PKWARE
-      BZIP2: 12,
-      //  compressed using BZIP2
-      // 13 reserved by PKWARE
-      LZMA: 14,
-      // LZMA
-      // 15-17 reserved by PKWARE
-      IBM_TERSE: 18,
-      // compressed using IBM TERSE
-      IBM_LZ77: 19,
-      // IBM LZ77 z
-      AES_ENCRYPT: 99,
-      // WinZIP AES encryption method
-      /* General purpose bit flag */
-      // values can obtained with expression 2**bitnr
-      FLG_ENC: 1,
-      // Bit 0: encrypted file
-      FLG_COMP1: 2,
-      // Bit 1, compression option
-      FLG_COMP2: 4,
-      // Bit 2, compression option
-      FLG_DESC: 8,
-      // Bit 3, data descriptor
-      FLG_ENH: 16,
-      // Bit 4, enhanced deflating
-      FLG_PATCH: 32,
-      // Bit 5, indicates that the file is compressed patched data.
-      FLG_STR: 64,
-      // Bit 6, strong encryption (patented)
-      // Bits 7-10: Currently unused.
-      FLG_EFS: 2048,
-      // Bit 11: Language encoding flag (EFS)
-      // Bit 12: Reserved by PKWARE for enhanced compression.
-      // Bit 13: encrypted the Central Directory (patented).
-      // Bits 14-15: Reserved by PKWARE.
-      FLG_MSK: 4096,
-      // mask header values
-      /* Load type */
-      FILE: 2,
-      BUFFER: 1,
-      NONE: 0,
-      /* 4.5 Extensible data fields */
-      EF_ID: 0,
-      EF_SIZE: 2,
-      /* Header IDs */
-      ID_ZIP64: 1,
-      ID_AVINFO: 7,
-      ID_PFS: 8,
-      ID_OS2: 9,
-      ID_NTFS: 10,
-      ID_OPENVMS: 12,
-      ID_UNIX: 13,
-      ID_FORK: 14,
-      ID_PATCH: 15,
-      ID_X509_PKCS7: 20,
-      ID_X509_CERTID_F: 21,
-      ID_X509_CERTID_C: 22,
-      ID_STRONGENC: 23,
-      ID_RECORD_MGT: 24,
-      ID_X509_PKCS7_RL: 25,
-      ID_IBM1: 101,
-      ID_IBM2: 102,
-      ID_POSZIP: 18064,
-      EF_ZIP64_OR_32: 4294967295,
-      EF_ZIP64_OR_16: 65535,
-      EF_ZIP64_SUNCOMP: 0,
-      EF_ZIP64_SCOMP: 8,
-      EF_ZIP64_RHO: 16,
-      EF_ZIP64_DSN: 24
-    };
-  }
-});
-
-// node_modules/adm-zip/util/errors.js
-var require_errors = __commonJS({
-  "node_modules/adm-zip/util/errors.js"(exports) {
-    "use strict";
-    init_esm_shims();
-    var errors = {
-      /* Header error messages */
-      INVALID_LOC: "Invalid LOC header (bad signature)",
-      INVALID_CEN: "Invalid CEN header (bad signature)",
-      INVALID_END: "Invalid END header (bad signature)",
-      /* Descriptor */
-      DESCRIPTOR_NOT_EXIST: "No descriptor present",
-      DESCRIPTOR_UNKNOWN: "Unknown descriptor format",
-      DESCRIPTOR_FAULTY: "Descriptor data is malformed",
-      /* ZipEntry error messages*/
-      NO_DATA: "Nothing to decompress",
-      BAD_CRC: "CRC32 checksum failed {0}",
-      FILE_IN_THE_WAY: "There is a file in the way: {0}",
-      UNKNOWN_METHOD: "Invalid/unsupported compression method",
-      /* Inflater error messages */
-      AVAIL_DATA: "inflate::Available inflate data did not terminate",
-      INVALID_DISTANCE: "inflate::Invalid literal/length or distance code in fixed or dynamic block",
-      TO_MANY_CODES: "inflate::Dynamic block code description: too many length or distance codes",
-      INVALID_REPEAT_LEN: "inflate::Dynamic block code description: repeat more than specified lengths",
-      INVALID_REPEAT_FIRST: "inflate::Dynamic block code description: repeat lengths with no first length",
-      INCOMPLETE_CODES: "inflate::Dynamic block code description: code lengths codes incomplete",
-      INVALID_DYN_DISTANCE: "inflate::Dynamic block code description: invalid distance code lengths",
-      INVALID_CODES_LEN: "inflate::Dynamic block code description: invalid literal/length code lengths",
-      INVALID_STORE_BLOCK: "inflate::Stored block length did not match one's complement",
-      INVALID_BLOCK_TYPE: "inflate::Invalid block type (type == 3)",
-      /* ADM-ZIP error messages */
-      CANT_EXTRACT_FILE: "Could not extract the file",
-      CANT_OVERRIDE: "Target file already exists",
-      DISK_ENTRY_TOO_LARGE: "Number of disk entries is too large",
-      NO_ZIP: "No zip file was loaded",
-      NO_ENTRY: "Entry doesn't exist",
-      DIRECTORY_CONTENT_ERROR: "A directory cannot have content",
-      FILE_NOT_FOUND: 'File not found: "{0}"',
-      NOT_IMPLEMENTED: "Not implemented",
-      INVALID_FILENAME: "Invalid filename",
-      INVALID_FORMAT: "Invalid or unsupported zip format. No END header found",
-      INVALID_PASS_PARAM: "Incompatible password parameter",
-      WRONG_PASSWORD: "Wrong Password",
-      /* ADM-ZIP */
-      COMMENT_TOO_LONG: "Comment is too long",
-      // Comment can be max 65535 bytes long (NOTE: some non-US characters may take more space)
-      EXTRA_FIELD_PARSE_ERROR: "Extra field parsing error"
-    };
-    function E(message) {
-      return function(...args) {
-        if (args.length) {
-          message = message.replace(/\{(\d)\}/g, (_, n) => args[n] || "");
-        }
-        return new Error("ADM-ZIP: " + message);
-      };
-    }
-    for (const msg of Object.keys(errors)) {
-      exports[msg] = E(errors[msg]);
-    }
-  }
-});
-
-// node_modules/adm-zip/util/utils.js
-var require_utils = __commonJS({
-  "node_modules/adm-zip/util/utils.js"(exports, module) {
-    "use strict";
-    init_esm_shims();
-    var fsystem = __require("fs");
-    var pth = __require("path");
-    var Constants = require_constants();
-    var Errors = require_errors();
-    var isWin = typeof process === "object" && "win32" === process.platform;
-    var is_Obj = (obj) => typeof obj === "object" && obj !== null;
-    var crcTable = new Uint32Array(256).map((t, c) => {
-      for (let k = 0; k < 8; k++) {
-        if ((c & 1) !== 0) {
-          c = 3988292384 ^ c >>> 1;
-        } else {
-          c >>>= 1;
-        }
-      }
-      return c >>> 0;
-    });
-    function Utils(opts) {
-      this.sep = pth.sep;
-      this.fs = fsystem;
-      if (is_Obj(opts)) {
-        if (is_Obj(opts.fs) && typeof opts.fs.statSync === "function") {
-          this.fs = opts.fs;
-        }
-      }
-    }
-    module.exports = Utils;
-    Utils.prototype.makeDir = function(folder) {
-      const self = this;
-      function mkdirSync2(fpath) {
-        let resolvedPath = fpath.split(self.sep)[0];
-        fpath.split(self.sep).forEach(function(name) {
-          if (!name || name.substr(-1, 1) === ":") return;
-          resolvedPath += self.sep + name;
-          var stat;
-          try {
-            stat = self.fs.statSync(resolvedPath);
-          } catch (e) {
-            self.fs.mkdirSync(resolvedPath);
-          }
-          if (stat && stat.isFile()) throw Errors.FILE_IN_THE_WAY(`"${resolvedPath}"`);
-        });
-      }
-      mkdirSync2(folder);
-    };
-    Utils.prototype.writeFileTo = function(path, content, overwrite, attr) {
-      const self = this;
-      if (self.fs.existsSync(path)) {
-        if (!overwrite) return false;
-        var stat = self.fs.statSync(path);
-        if (stat.isDirectory()) {
-          return false;
-        }
-      }
-      var folder = pth.dirname(path);
-      if (!self.fs.existsSync(folder)) {
-        self.makeDir(folder);
-      }
-      var fd;
-      try {
-        fd = self.fs.openSync(path, "w", 438);
-      } catch (e) {
-        self.fs.chmodSync(path, 438);
-        fd = self.fs.openSync(path, "w", 438);
-      }
-      if (fd) {
-        try {
-          self.fs.writeSync(fd, content, 0, content.length, 0);
-        } finally {
-          self.fs.closeSync(fd);
-        }
-      }
-      self.fs.chmodSync(path, attr || 438);
-      return true;
-    };
-    Utils.prototype.writeFileToAsync = function(path, content, overwrite, attr, callback) {
-      if (typeof attr === "function") {
-        callback = attr;
-        attr = void 0;
-      }
-      const self = this;
-      self.fs.exists(path, function(exist) {
-        if (exist && !overwrite) return callback(false);
-        self.fs.stat(path, function(err, stat) {
-          if (exist && stat.isDirectory()) {
-            return callback(false);
-          }
-          var folder = pth.dirname(path);
-          self.fs.exists(folder, function(exists) {
-            if (!exists) self.makeDir(folder);
-            self.fs.open(path, "w", 438, function(err2, fd) {
-              if (err2) {
-                self.fs.chmod(path, 438, function() {
-                  self.fs.open(path, "w", 438, function(err3, fd2) {
-                    self.fs.write(fd2, content, 0, content.length, 0, function() {
-                      self.fs.close(fd2, function() {
-                        self.fs.chmod(path, attr || 438, function() {
-                          callback(true);
-                        });
-                      });
-                    });
-                  });
-                });
-              } else if (fd) {
-                self.fs.write(fd, content, 0, content.length, 0, function() {
-                  self.fs.close(fd, function() {
-                    self.fs.chmod(path, attr || 438, function() {
-                      callback(true);
-                    });
-                  });
-                });
-              } else {
-                self.fs.chmod(path, attr || 438, function() {
-                  callback(true);
-                });
-              }
-            });
-          });
-        });
-      });
-    };
-    Utils.prototype.findFiles = function(path) {
-      const self = this;
-      function findSync(dir, pattern, recursive) {
-        if (typeof pattern === "boolean") {
-          recursive = pattern;
-          pattern = void 0;
-        }
-        let files = [];
-        self.fs.readdirSync(dir).forEach(function(file) {
-          const path2 = pth.join(dir, file);
-          const stat = self.fs.statSync(path2);
-          if (!pattern || pattern.test(path2)) {
-            files.push(pth.normalize(path2) + (stat.isDirectory() ? self.sep : ""));
-          }
-          if (stat.isDirectory() && recursive) files = files.concat(findSync(path2, pattern, recursive));
-        });
-        return files;
-      }
-      return findSync(path, void 0, true);
-    };
-    Utils.prototype.findFilesAsync = function(dir, cb) {
-      const self = this;
-      let results = [];
-      self.fs.readdir(dir, function(err, list) {
-        if (err) return cb(err);
-        let list_length = list.length;
-        if (!list_length) return cb(null, results);
-        list.forEach(function(file) {
-          file = pth.join(dir, file);
-          self.fs.stat(file, function(err2, stat) {
-            if (err2) return cb(err2);
-            if (stat) {
-              results.push(pth.normalize(file) + (stat.isDirectory() ? self.sep : ""));
-              if (stat.isDirectory()) {
-                self.findFilesAsync(file, function(err3, res) {
-                  if (err3) return cb(err3);
-                  results = results.concat(res);
-                  if (!--list_length) cb(null, results);
-                });
-              } else {
-                if (!--list_length) cb(null, results);
-              }
-            }
-          });
-        });
-      });
-    };
-    Utils.prototype.getAttributes = function() {
-    };
-    Utils.prototype.setAttributes = function() {
-    };
-    Utils.crc32update = function(crc, byte) {
-      return crcTable[(crc ^ byte) & 255] ^ crc >>> 8;
-    };
-    Utils.crc32 = function(buf) {
-      if (typeof buf === "string") {
-        buf = Buffer.from(buf, "utf8");
-      }
-      let len = buf.length;
-      let crc = ~0;
-      for (let off = 0; off < len; ) crc = Utils.crc32update(crc, buf[off++]);
-      return ~crc >>> 0;
-    };
-    Utils.methodToString = function(method) {
-      switch (method) {
-        case Constants.STORED:
-          return "STORED (" + method + ")";
-        case Constants.DEFLATED:
-          return "DEFLATED (" + method + ")";
-        default:
-          return "UNSUPPORTED (" + method + ")";
-      }
-    };
-    Utils.canonical = function(path) {
-      if (!path) return "";
-      const safeSuffix = pth.posix.normalize("/" + path.split("\\").join("/"));
-      return pth.join(".", safeSuffix);
-    };
-    Utils.zipnamefix = function(path) {
-      if (!path) return "";
-      const safeSuffix = pth.posix.normalize("/" + path.split("\\").join("/"));
-      return pth.posix.join(".", safeSuffix);
-    };
-    Utils.findLast = function(arr, callback) {
-      if (!Array.isArray(arr)) throw new TypeError("arr is not array");
-      const len = arr.length >>> 0;
-      for (let i = len - 1; i >= 0; i--) {
-        if (callback(arr[i], i, arr)) {
-          return arr[i];
-        }
-      }
-      return void 0;
-    };
-    Utils.sanitize = function(prefix, name) {
-      prefix = pth.resolve(pth.normalize(prefix));
-      var parts = name.split("/");
-      for (var i = 0, l = parts.length; i < l; i++) {
-        var path = pth.normalize(pth.join(prefix, parts.slice(i, l).join(pth.sep)));
-        if (path.indexOf(prefix) === 0) {
-          return path;
-        }
-      }
-      return pth.normalize(pth.join(prefix, pth.basename(name)));
-    };
-    Utils.toBuffer = function toBuffer(input, encoder) {
-      if (Buffer.isBuffer(input)) {
-        return input;
-      } else if (input instanceof Uint8Array) {
-        return Buffer.from(input);
-      } else {
-        return typeof input === "string" ? encoder(input) : Buffer.alloc(0);
-      }
-    };
-    Utils.readBigUInt64LE = function(buffer, index) {
-      var slice = Buffer.from(buffer.slice(index, index + 8));
-      slice.swap64();
-      return parseInt(`0x${slice.toString("hex")}`);
-    };
-    Utils.fromDOS2Date = function(val) {
-      return new Date((val >> 25 & 127) + 1980, Math.max((val >> 21 & 15) - 1, 0), Math.max(val >> 16 & 31, 1), val >> 11 & 31, val >> 5 & 63, (val & 31) << 1);
-    };
-    Utils.fromDate2DOS = function(val) {
-      let date = 0;
-      let time = 0;
-      if (val.getFullYear() > 1979) {
-        date = (val.getFullYear() - 1980 & 127) << 9 | val.getMonth() + 1 << 5 | val.getDate();
-        time = val.getHours() << 11 | val.getMinutes() << 5 | val.getSeconds() >> 1;
-      }
-      return date << 16 | time;
-    };
-    Utils.isWin = isWin;
-    Utils.crcTable = crcTable;
-  }
-});
-
-// node_modules/adm-zip/util/fattr.js
-var require_fattr = __commonJS({
-  "node_modules/adm-zip/util/fattr.js"(exports, module) {
-    "use strict";
-    init_esm_shims();
-    var pth = __require("path");
-    module.exports = function(path, { fs }) {
-      var _path = path || "", _obj = newAttr(), _stat = null;
-      function newAttr() {
-        return {
-          directory: false,
-          readonly: false,
-          hidden: false,
-          executable: false,
-          mtime: 0,
-          atime: 0
-        };
-      }
-      if (_path && fs.existsSync(_path)) {
-        _stat = fs.statSync(_path);
-        _obj.directory = _stat.isDirectory();
-        _obj.mtime = _stat.mtime;
-        _obj.atime = _stat.atime;
-        _obj.executable = (73 & _stat.mode) !== 0;
-        _obj.readonly = (128 & _stat.mode) === 0;
-        _obj.hidden = pth.basename(_path)[0] === ".";
-      } else {
-        console.warn("Invalid path: " + _path);
-      }
-      return {
-        get directory() {
-          return _obj.directory;
-        },
-        get readOnly() {
-          return _obj.readonly;
-        },
-        get hidden() {
-          return _obj.hidden;
-        },
-        get mtime() {
-          return _obj.mtime;
-        },
-        get atime() {
-          return _obj.atime;
-        },
-        get executable() {
-          return _obj.executable;
-        },
-        decodeAttributes: function() {
-        },
-        encodeAttributes: function() {
-        },
-        toJSON: function() {
-          return {
-            path: _path,
-            isDirectory: _obj.directory,
-            isReadOnly: _obj.readonly,
-            isHidden: _obj.hidden,
-            isExecutable: _obj.executable,
-            mTime: _obj.mtime,
-            aTime: _obj.atime
-          };
-        },
-        toString: function() {
-          return JSON.stringify(this.toJSON(), null, "	");
-        }
-      };
-    };
-  }
-});
-
-// node_modules/adm-zip/util/decoder.js
-var require_decoder = __commonJS({
-  "node_modules/adm-zip/util/decoder.js"(exports, module) {
-    "use strict";
-    init_esm_shims();
-    module.exports = {
-      efs: true,
-      encode: (data) => Buffer.from(data, "utf8"),
-      decode: (data) => data.toString("utf8")
-    };
-  }
-});
-
-// node_modules/adm-zip/util/index.js
-var require_util2 = __commonJS({
-  "node_modules/adm-zip/util/index.js"(exports, module) {
-    "use strict";
-    init_esm_shims();
-    module.exports = require_utils();
-    module.exports.Constants = require_constants();
-    module.exports.Errors = require_errors();
-    module.exports.FileAttr = require_fattr();
-    module.exports.decoder = require_decoder();
-  }
-});
-
-// node_modules/adm-zip/headers/entryHeader.js
-var require_entryHeader = __commonJS({
-  "node_modules/adm-zip/headers/entryHeader.js"(exports, module) {
-    "use strict";
-    init_esm_shims();
-    var Utils = require_util2();
-    var Constants = Utils.Constants;
-    module.exports = function() {
-      var _verMade = 20, _version = 10, _flags = 0, _method = 0, _time = 0, _crc = 0, _compressedSize = 0, _size = 0, _fnameLen = 0, _extraLen = 0, _comLen = 0, _diskStart = 0, _inattr = 0, _attr = 0, _offset = 0;
-      _verMade |= Utils.isWin ? 2560 : 768;
-      _flags |= Constants.FLG_EFS;
-      const _localHeader = {
-        extraLen: 0
+    var Utils = require_util();
+    var Constants = Utils.Constants;
+    module2.exports = function() {
+      var _verMade = 20, _version = 10, _flags = 0, _method = 0, _time = 0, _crc = 0, _compressedSize = 0, _size = 0, _fnameLen = 0, _extraLen = 0, _comLen = 0, _diskStart = 0, _inattr = 0, _attr = 0, _offset = 0;
+      _verMade |= Utils.isWin ? 2560 : 768;
+      _flags |= Constants.FLG_EFS;
+      const _localHeader = {
+        extraLen: 0
       };
       const uint32 = (val) => Math.max(0, val) >>> 0;
       const uint16 = (val) => Math.max(0, val) & 65535;
@@ -1746,12 +931,11 @@ var require_entryHeader = __commonJS({
 
 // node_modules/adm-zip/headers/mainHeader.js
 var require_mainHeader = __commonJS({
-  "node_modules/adm-zip/headers/mainHeader.js"(exports, module) {
+  "node_modules/adm-zip/headers/mainHeader.js"(exports2, module2) {
     "use strict";
-    init_esm_shims();
-    var Utils = require_util2();
+    var Utils = require_util();
     var Constants = Utils.Constants;
-    module.exports = function() {
+    module2.exports = function() {
       var _volumeEntries = 0, _totalEntries = 0, _size = 0, _offset = 0, _commentLength = 0;
       return {
         get diskEntries() {
@@ -1841,21 +1025,19 @@ var require_mainHeader = __commonJS({
 
 // node_modules/adm-zip/headers/index.js
 var require_headers = __commonJS({
-  "node_modules/adm-zip/headers/index.js"(exports) {
+  "node_modules/adm-zip/headers/index.js"(exports2) {
     "use strict";
-    init_esm_shims();
-    exports.EntryHeader = require_entryHeader();
-    exports.MainHeader = require_mainHeader();
+    exports2.EntryHeader = require_entryHeader();
+    exports2.MainHeader = require_mainHeader();
   }
 });
 
 // node_modules/adm-zip/methods/deflater.js
 var require_deflater = __commonJS({
-  "node_modules/adm-zip/methods/deflater.js"(exports, module) {
+  "node_modules/adm-zip/methods/deflater.js"(exports2, module2) {
     "use strict";
-    init_esm_shims();
-    module.exports = function(inbuf) {
-      var zlib = __require("zlib");
+    module2.exports = function(inbuf) {
+      var zlib = require("zlib");
       var opts = { chunkSize: (parseInt(inbuf.length / 1024) + 1) * 1024 };
       return {
         deflate: function() {
@@ -1886,12 +1068,11 @@ var require_deflater = __commonJS({
 
 // node_modules/adm-zip/methods/inflater.js
 var require_inflater = __commonJS({
-  "node_modules/adm-zip/methods/inflater.js"(exports, module) {
+  "node_modules/adm-zip/methods/inflater.js"(exports2, module2) {
     "use strict";
-    init_esm_shims();
     var version = +(process.versions ? process.versions.node : "").split(".")[0] || 0;
-    module.exports = function(inbuf, expectedLength) {
-      var zlib = __require("zlib");
+    module2.exports = function(inbuf, expectedLength) {
+      var zlib = require("zlib");
       const option = version >= 15 && expectedLength > 0 ? { maxOutputLength: expectedLength } : {};
       return {
         inflate: function() {
@@ -1922,10 +1103,9 @@ var require_inflater = __commonJS({
 
 // node_modules/adm-zip/methods/zipcrypto.js
 var require_zipcrypto = __commonJS({
-  "node_modules/adm-zip/methods/zipcrypto.js"(exports, module) {
+  "node_modules/adm-zip/methods/zipcrypto.js"(exports2, module2) {
     "use strict";
-    init_esm_shims();
-    var { randomFillSync } = __require("crypto");
+    var { randomFillSync } = require("crypto");
     var Errors = require_errors();
     var crctable = new Uint32Array(256).map((t, crc) => {
       for (let j = 0; j < 8; j++) {
@@ -2033,31 +1213,29 @@ var require_zipcrypto = __commonJS({
       encrypter(salt, result);
       return encrypter(data, result, 12);
     }
-    module.exports = { decrypt, encrypt, _salter };
+    module2.exports = { decrypt, encrypt, _salter };
   }
 });
 
 // node_modules/adm-zip/methods/index.js
 var require_methods = __commonJS({
-  "node_modules/adm-zip/methods/index.js"(exports) {
+  "node_modules/adm-zip/methods/index.js"(exports2) {
     "use strict";
-    init_esm_shims();
-    exports.Deflater = require_deflater();
-    exports.Inflater = require_inflater();
-    exports.ZipCrypto = require_zipcrypto();
+    exports2.Deflater = require_deflater();
+    exports2.Inflater = require_inflater();
+    exports2.ZipCrypto = require_zipcrypto();
   }
 });
 
 // node_modules/adm-zip/zipEntry.js
 var require_zipEntry = __commonJS({
-  "node_modules/adm-zip/zipEntry.js"(exports, module) {
+  "node_modules/adm-zip/zipEntry.js"(exports2, module2) {
     "use strict";
-    init_esm_shims();
-    var Utils = require_util2();
+    var Utils = require_util();
     var Headers = require_headers();
     var Constants = Utils.Constants;
     var Methods = require_methods();
-    module.exports = function(options, input) {
+    module2.exports = function(options, input) {
       var _centralHeader = new Headers.EntryHeader(), _entryName = Buffer.alloc(0), _comment = Buffer.alloc(0), _isDirectory = false, uncompressedData = null, _extra = Buffer.alloc(0), _extralocal = Buffer.alloc(0), _efs = true;
       const opts = options;
       const decoder = typeof opts.decoder === "object" ? opts.decoder : Utils.decoder;
@@ -2383,13 +1561,12 @@ var require_zipEntry = __commonJS({
 
 // node_modules/adm-zip/zipFile.js
 var require_zipFile = __commonJS({
-  "node_modules/adm-zip/zipFile.js"(exports, module) {
+  "node_modules/adm-zip/zipFile.js"(exports2, module2) {
     "use strict";
-    init_esm_shims();
     var ZipEntry = require_zipEntry();
     var Headers = require_headers();
-    var Utils = require_util2();
-    module.exports = function(inBuffer, options) {
+    var Utils = require_util();
+    module2.exports = function(inBuffer, options) {
       var entryList = [], entryTable = {}, _comment = Buffer.alloc(0), mainHeader = new Headers.MainHeader(), loadedEntries = false;
       var password = null;
       const temporary = /* @__PURE__ */ new Set();
@@ -2731,11 +1908,10 @@ var require_zipFile = __commonJS({
 
 // node_modules/adm-zip/adm-zip.js
 var require_adm_zip = __commonJS({
-  "node_modules/adm-zip/adm-zip.js"(exports, module) {
+  "node_modules/adm-zip/adm-zip.js"(exports2, module2) {
     "use strict";
-    init_esm_shims();
-    var Utils = require_util2();
-    var pth = __require("path");
+    var Utils = require_util();
+    var pth = require("path");
     var ZipEntry = require_zipEntry();
     var ZipFile = require_zipFile();
     var get_Bool = (...val) => Utils.findLast(val, (c) => typeof c === "boolean");
@@ -2751,7 +1927,7 @@ var require_adm_zip = __commonJS({
       // file system
       fs: null
     };
-    module.exports = function(input, options) {
+    module2.exports = function(input, options) {
       let inBuffer = null;
       const opts = Object.assign(/* @__PURE__ */ Object.create(null), defaultOptions);
       if (input && "object" === typeof input) {
@@ -3462,79 +2638,840 @@ var require_adm_zip = __commonJS({
               targetFileName = "";
             }
           }
-          if (!targetFileName && opts.filename) {
-            targetFileName = opts.filename;
+          if (!targetFileName && opts.filename) {
+            targetFileName = opts.filename;
+          }
+          if (!targetFileName) return;
+          var zipData = _zip.compressToBuffer();
+          if (zipData) {
+            var ok = filetools.writeFileTo(targetFileName, zipData, true);
+            if (typeof callback === "function") callback(!ok ? new Error("failed") : null, "");
+          }
+        },
+        /**
+                 *
+                 * @param {string} targetFileName
+                 * @param {object} [props]
+                 * @param {boolean} [props.overwrite=true] If the file already exists at the target path, the file will be overwriten if this is true.
+                 * @param {boolean} [props.perm] The file will be set as the permission from the entry if this is true.
+        
+                 * @returns {Promise<void>}
+                 */
+        writeZipPromise: function(targetFileName, props) {
+          const { overwrite, perm } = Object.assign({ overwrite: true }, props);
+          return new Promise((resolve2, reject) => {
+            if (!targetFileName && opts.filename) targetFileName = opts.filename;
+            if (!targetFileName) reject("ADM-ZIP: ZIP File Name Missing");
+            this.toBufferPromise().then((zipData) => {
+              const ret = (done) => done ? resolve2(done) : reject("ADM-ZIP: Wasn't able to write zip file");
+              filetools.writeFileToAsync(targetFileName, zipData, overwrite, perm, ret);
+            }, reject);
+          });
+        },
+        /**
+         * @returns {Promise<Buffer>} A promise to the Buffer.
+         */
+        toBufferPromise: function() {
+          return new Promise((resolve2, reject) => {
+            _zip.toAsyncBuffer(resolve2, reject);
+          });
+        },
+        /**
+         * Returns the content of the entire zip file as a Buffer object
+         *
+         * @prop {function} [onSuccess]
+         * @prop {function} [onFail]
+         * @prop {function} [onItemStart]
+         * @prop {function} [onItemEnd]
+         * @returns {Buffer}
+         */
+        toBuffer: function(onSuccess, onFail, onItemStart, onItemEnd) {
+          if (typeof onSuccess === "function") {
+            _zip.toAsyncBuffer(onSuccess, onFail, onItemStart, onItemEnd);
+            return null;
+          }
+          return _zip.compressToBuffer();
+        }
+      };
+    };
+  }
+});
+
+// node_modules/better-sqlite3/lib/util.js
+var require_util2 = __commonJS({
+  "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");
+  }
+});
+
+// node_modules/better-sqlite3/lib/sqlite-error.js
+var require_sqlite_error = __commonJS({
+  "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;
+  }
+});
+
+// node_modules/file-uri-to-path/index.js
+var require_file_uri_to_path = __commonJS({
+  "node_modules/file-uri-to-path/index.js"(exports2, module2) {
+    "use strict";
+    var sep2 = 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 path = rest.substring(firstSlash + 1);
+      if ("localhost" == host) host = "";
+      if (host) {
+        host = sep2 + sep2 + host;
+      }
+      path = path.replace(/^(.+)\|/, "$1:");
+      if (sep2 == "\\") {
+        path = path.replace(/\//g, "\\");
+      }
+      if (/^.+\:/.test(path)) {
+      } else {
+        path = sep2 + path;
+      }
+      return host + path;
+    }
+  }
+});
+
+// node_modules/bindings/bindings.js
+var require_bindings = __commonJS({
+  "node_modules/bindings/bindings.js"(exports2, module2) {
+    "use strict";
+    var fs = require("fs");
+    var path = require("path");
+    var fileURLToPath = require_file_uri_to_path();
+    var join5 = path.join;
+    var dirname2 = path.dirname;
+    var exists = fs.accessSync && function(path2) {
+      try {
+        fs.accessSync(path2);
+      } catch (e) {
+        return false;
+      }
+      return true;
+    } || fs.existsSync || path.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 (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 = join5.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;
           }
-          if (!targetFileName) return;
-          var zipData = _zip.compressToBuffer();
-          if (zipData) {
-            var ok = filetools.writeFileTo(targetFileName, zipData, true);
-            if (typeof callback === "function") callback(!ok ? new Error("failed") : null, "");
+        }
+      }
+      err = new Error(
+        "Could not locate the bindings file. Tried:\n" + tries.map(function(a) {
+          return opts.arrow + a;
+        }).join("\n")
+      );
+      err.tries = tries;
+      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 = dirname2(file), prev;
+      while (true) {
+        if (dir === ".") {
+          dir = process.cwd();
+        }
+        if (exists(join5(dir, "package.json")) || exists(join5(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 = join5(dir, "..");
+      }
+    };
+  }
+});
+
+// node_modules/better-sqlite3/lib/methods/wrappers.js
+var require_wrappers = __commonJS({
+  "node_modules/better-sqlite3/lib/methods/wrappers.js"(exports2) {
+    "use strict";
+    var { cppdb } = require_util2();
+    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;
         },
-        /**
-                 *
-                 * @param {string} targetFileName
-                 * @param {object} [props]
-                 * @param {boolean} [props.overwrite=true] If the file already exists at the target path, the file will be overwriten if this is true.
-                 * @param {boolean} [props.perm] The file will be set as the permission from the entry if this is true.
-        
-                 * @returns {Promise<void>}
-                 */
-        writeZipPromise: function(targetFileName, props) {
-          const { overwrite, perm } = Object.assign({ overwrite: true }, props);
-          return new Promise((resolve2, reject) => {
-            if (!targetFileName && opts.filename) targetFileName = opts.filename;
-            if (!targetFileName) reject("ADM-ZIP: ZIP File Name Missing");
-            this.toBufferPromise().then((zipData) => {
-              const ret = (done) => done ? resolve2(done) : reject("ADM-ZIP: Wasn't able to write zip file");
-              filetools.writeFileToAsync(targetFileName, zipData, overwrite, perm, ret);
-            }, reject);
-          });
+        enumerable: true
+      },
+      open: {
+        get: function open() {
+          return this[cppdb].open;
         },
-        /**
-         * @returns {Promise<Buffer>} A promise to the Buffer.
-         */
-        toBufferPromise: function() {
-          return new Promise((resolve2, reject) => {
-            _zip.toAsyncBuffer(resolve2, reject);
-          });
+        enumerable: true
+      },
+      inTransaction: {
+        get: function inTransaction() {
+          return this[cppdb].inTransaction;
         },
-        /**
-         * Returns the content of the entire zip file as a Buffer object
-         *
-         * @prop {function} [onSuccess]
-         * @prop {function} [onFail]
-         * @prop {function} [onItemStart]
-         * @prop {function} [onItemEnd]
-         * @returns {Buffer}
-         */
-        toBuffer: function(onSuccess, onFail, onItemStart, onItemEnd) {
-          if (typeof onSuccess === "function") {
-            _zip.toAsyncBuffer(onSuccess, onFail, onItemStart, onItemEnd);
-            return null;
+        enumerable: true
+      },
+      readonly: {
+        get: function readonly() {
+          return this[cppdb].readonly;
+        },
+        enumerable: true
+      },
+      memory: {
+        get: function memory() {
+          return this[cppdb].memory;
+        },
+        enumerable: true
+      }
+    };
+  }
+});
+
+// node_modules/better-sqlite3/lib/methods/transaction.js
+var require_transaction = __commonJS({
+  "node_modules/better-sqlite3/lib/methods/transaction.js"(exports2, module2) {
+    "use strict";
+    var { cppdb } = require_util2();
+    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 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 getController = (db, self) => {
+      let controller = controllers.get(db);
+      if (!controller) {
+        const shared = {
+          commit: db.prepare("COMMIT", self, false),
+          rollback: db.prepare("ROLLBACK", self, false),
+          savepoint: db.prepare("SAVEPOINT `	_bs3.	`", self, false),
+          release: db.prepare("RELEASE `	_bs3.	`", self, false),
+          rollbackTo: db.prepare("ROLLBACK TO `	_bs3.	`", self, false)
+        };
+        controllers.set(db, controller = {
+          default: Object.assign({ begin: db.prepare("BEGIN", self, false) }, shared),
+          deferred: Object.assign({ begin: db.prepare("BEGIN DEFERRED", self, false) }, shared),
+          immediate: Object.assign({ begin: db.prepare("BEGIN IMMEDIATE", self, false) }, shared),
+          exclusive: Object.assign({ begin: db.prepare("BEGIN EXCLUSIVE", self, false) }, shared)
+        });
+      }
+      return controller;
+    };
+    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;
+      }
+      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 (db.inTransaction) {
+          undo.run();
+          if (undo !== rollback) after.run();
+        }
+        throw ex;
+      }
+    };
+  }
+});
+
+// node_modules/better-sqlite3/lib/methods/pragma.js
+var require_pragma = __commonJS({
+  "node_modules/better-sqlite3/lib/methods/pragma.js"(exports2, module2) {
+    "use strict";
+    var { getBooleanOption, cppdb } = require_util2();
+    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();
+    };
+  }
+});
+
+// node_modules/better-sqlite3/lib/methods/backup.js
+var require_backup = __commonJS({
+  "node_modules/better-sqlite3/lib/methods/backup.js"(exports2, module2) {
+    "use strict";
+    var fs = require("fs");
+    var path = require("path");
+    var { promisify } = require("util");
+    var { cppdb } = require_util2();
+    var fsAccess = promisify(fs.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(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 runBackup = (backup, handler) => {
+      let rate = 0;
+      let useDefault = true;
+      return new Promise((resolve2, reject) => {
+        setImmediate(function step() {
+          try {
+            const progress = backup.transfer(rate);
+            if (!progress.remainingPages) {
+              backup.close();
+              resolve2(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);
           }
-          return _zip.compressToBuffer();
+        });
+      });
+    };
+  }
+});
+
+// node_modules/better-sqlite3/lib/methods/serialize.js
+var require_serialize = __commonJS({
+  "node_modules/better-sqlite3/lib/methods/serialize.js"(exports2, module2) {
+    "use strict";
+    var { cppdb } = require_util2();
+    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);
+    };
+  }
+});
+
+// node_modules/better-sqlite3/lib/methods/function.js
+var require_function = __commonJS({
+  "node_modules/better-sqlite3/lib/methods/function.js"(exports2, module2) {
+    "use strict";
+    var { getBooleanOption, cppdb } = require_util2();
+    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;
+    };
+  }
+});
+
+// node_modules/better-sqlite3/lib/methods/aggregate.js
+var require_aggregate = __commonJS({
+  "node_modules/better-sqlite3/lib/methods/aggregate.js"(exports2, module2) {
+    "use strict";
+    var { getBooleanOption, cppdb } = require_util2();
+    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");
+    };
+  }
+});
+
+// node_modules/better-sqlite3/lib/methods/table.js
+var require_table = __commonJS({
+  "node_modules/better-sqlite3/lib/methods/table.js"(exports2, module2) {
+    "use strict";
+    var { cppdb } = require_util2();
+    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;
   }
 });
 
-// src/index.ts
-init_esm_shims();
-
-// node_modules/@modelcontextprotocol/sdk/dist/server/index.js
-init_esm_shims();
+// node_modules/better-sqlite3/lib/methods/inspect.js
+var require_inspect = __commonJS({
+  "node_modules/better-sqlite3/lib/methods/inspect.js"(exports2, module2) {
+    "use strict";
+    var DatabaseInspection = function Database() {
+    };
+    module2.exports = function inspect(depth, opts) {
+      return Object.assign(new DatabaseInspection(), this);
+    };
+  }
+});
 
-// node_modules/@modelcontextprotocol/sdk/dist/shared/protocol.js
-init_esm_shims();
+// node_modules/better-sqlite3/lib/database.js
+var require_database = __commonJS({
+  "node_modules/better-sqlite3/lib/database.js"(exports2, module2) {
+    "use strict";
+    var fs = require("fs");
+    var path = require("path");
+    var util2 = require_util2();
+    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 = util2.getBooleanOption(options, "readonly");
+      const fileMustExist = util2.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(path.resolve(nativeBinding).replace(/(\.node)?$/, ".node"));
+      } else {
+        addon = nativeBinding;
+      }
+      if (!addon.isInitialized) {
+        addon.setErrorConstructor(SqliteError);
+        addon.isInitialized = true;
+      }
+      if (!anonymous && !filename.startsWith("file:") && !fs.existsSync(path.dirname(filename))) {
+        throw new TypeError("Cannot open database because the directory does not exist");
+      }
+      Object.defineProperties(this, {
+        [util2.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[util2.inspect] = require_inspect();
+    module2.exports = Database;
+  }
+});
 
-// node_modules/@modelcontextprotocol/sdk/dist/types.js
-init_esm_shims();
+// node_modules/better-sqlite3/lib/index.js
+var require_lib = __commonJS({
+  "node_modules/better-sqlite3/lib/index.js"(exports2, module2) {
+    "use strict";
+    module2.exports = require_database();
+    module2.exports.SqliteError = require_sqlite_error();
+  }
+});
 
 // node_modules/zod/lib/index.mjs
-init_esm_shims();
 var util;
 (function(util2) {
   util2.assertEqual = (val) => val;
@@ -8715,11 +8652,9 @@ var Server = class extends Protocol {
 };
 
 // node_modules/@modelcontextprotocol/sdk/dist/server/stdio.js
-init_esm_shims();
-import process2 from "node:process";
+var import_node_process = __toESM(require("process"), 1);
 
 // node_modules/@modelcontextprotocol/sdk/dist/shared/stdio.js
-init_esm_shims();
 var ReadBuffer = class {
   append(chunk) {
     this._buffer = this._buffer ? Buffer.concat([this._buffer, chunk]) : chunk;
@@ -8749,7 +8684,7 @@ function serializeMessage(message) {
 
 // node_modules/@modelcontextprotocol/sdk/dist/server/stdio.js
 var StdioServerTransport = class {
-  constructor(_stdin = process2.stdin, _stdout = process2.stdout) {
+  constructor(_stdin = import_node_process.default.stdin, _stdout = import_node_process.default.stdout) {
     this._stdin = _stdin;
     this._stdout = _stdout;
     this._readBuffer = new ReadBuffer();
@@ -8807,14 +8742,7 @@ var StdioServerTransport = class {
   }
 };
 
-// src/tools/list-sessions.ts
-init_esm_shims();
-
-// node_modules/cursor-history/dist/lib/index.js
-init_esm_shims();
-
 // node_modules/cursor-history/dist/lib/errors.js
-init_esm_shims();
 var DatabaseLockedError = class _DatabaseLockedError extends Error {
   name = "DatabaseLockedError";
   /** Path to locked database file */
@@ -8960,13 +8888,9 @@ function isInvalidBackupError(error) {
   return error instanceof InvalidBackupError;
 }
 
-// node_modules/cursor-history/dist/lib/utils.js
-init_esm_shims();
-
 // node_modules/cursor-history/dist/lib/platform.js
-init_esm_shims();
-import { homedir } from "node:os";
-import { join } from "node:path";
+var import_node_os = require("os");
+var import_node_path = require("path");
 function detectPlatform() {
   switch (process.platform) {
     case "win32":
@@ -8981,11 +8905,11 @@ function getDefaultCursorDataPath(platform) {
   const p = platform ?? detectPlatform();
   switch (p) {
     case "windows":
-      return join(process.env["APPDATA"] ?? join(homedir(), "AppData", "Roaming"), "Cursor", "User", "workspaceStorage");
+      return (0, import_node_path.join)(process.env["APPDATA"] ?? (0, import_node_path.join)((0, import_node_os.homedir)(), "AppData", "Roaming"), "Cursor", "User", "workspaceStorage");
     case "macos":
-      return join(homedir(), "Library", "Application Support", "Cursor", "User", "workspaceStorage");
+      return (0, import_node_path.join)((0, import_node_os.homedir)(), "Library", "Application Support", "Cursor", "User", "workspaceStorage");
     case "linux":
-      return join(homedir(), ".config", "Cursor", "User", "workspaceStorage");
+      return (0, import_node_path.join)((0, import_node_os.homedir)(), ".config", "Cursor", "User", "workspaceStorage");
   }
 }
 function getCursorDataPath(customPath) {
@@ -9000,12 +8924,12 @@ function getCursorDataPath(customPath) {
 }
 function expandPath(path) {
   if (path.startsWith("~")) {
-    return join(homedir(), path.slice(1));
+    return (0, import_node_path.join)((0, import_node_os.homedir)(), path.slice(1));
   }
   return path;
 }
 function contractPath(path) {
-  const home = homedir();
+  const home = (0, import_node_os.homedir)();
   if (path.startsWith(home)) {
     return "~" + path.slice(home.length);
   }
@@ -9014,7 +8938,7 @@ function contractPath(path) {
 function normalizePath(filePath) {
   let normalized = filePath;
   if (normalized.startsWith("~")) {
-    normalized = join(homedir(), normalized.slice(1));
+    normalized = (0, import_node_path.join)((0, import_node_os.homedir)(), normalized.slice(1));
   }
   while (normalized.length > 1 && normalized.endsWith("/")) {
     normalized = normalized.slice(0, -1);
@@ -9034,8 +8958,9 @@ function pathsEqual(path1, path2) {
 }
 
 // node_modules/cursor-history/dist/lib/config.js
-init_esm_shims();
-import { resolve, normalize, isAbsolute } from "node:path";
+var import_node_fs = require("fs");
+var import_node_path2 = require("path");
+var VALID_SQLITE_DRIVERS = ["better-sqlite3", "node:sqlite"];
 function validateConfig(config) {
   if (!config)
     return;
@@ -9058,13 +8983,18 @@ function validateConfig(config) {
     if (typeof config.workspace !== "string") {
       throw new InvalidConfigError("workspace", config.workspace, "must be a string");
     }
-    if (!isAbsolute(config.workspace)) {
+    if (!(0, import_node_path2.isAbsolute)(config.workspace)) {
       throw new InvalidConfigError("workspace", config.workspace, "must be an absolute path");
     }
   }
   if (config.dataPath !== void 0 && typeof config.dataPath !== "string") {
     throw new InvalidConfigError("dataPath", config.dataPath, "must be a string");
   }
+  if (config.sqliteDriver !== void 0) {
+    if (!VALID_SQLITE_DRIVERS.includes(config.sqliteDriver)) {
+      throw new InvalidConfigError("sqliteDriver", config.sqliteDriver, `must be one of: ${VALID_SQLITE_DRIVERS.join(", ")}`);
+    }
+  }
 }
 function mergeWithDefaults(config) {
   validateConfig(config);
@@ -9075,20 +9005,387 @@ function mergeWithDefaults(config) {
     limit: config?.limit ?? Number.MAX_SAFE_INTEGER,
     offset: config?.offset ?? 0,
     context: config?.context ?? 0,
-    backupPath: config?.backupPath
+    backupPath: config?.backupPath,
+    sqliteDriver: config?.sqliteDriver
   };
 }
 
 // node_modules/cursor-history/dist/core/storage.js
-init_esm_shims();
-var import_better_sqlite32 = __toESM(require_lib(), 1);
+var import_node_fs3 = require("fs");
+var import_node_path4 = require("path");
+var import_node_os3 = require("os");
 var import_adm_zip2 = __toESM(require_adm_zip(), 1);
-import { existsSync as existsSync2, readdirSync as readdirSync2, readFileSync as readFileSync2 } from "node:fs";
-import { join as join3 } from "node:path";
-import { homedir as homedir3 } from "node:os";
+
+// node_modules/cursor-history/dist/core/database/errors.js
+var NoDriverAvailableError = class extends Error {
+  constructor() {
+    super("No SQLite driver available. Either install better-sqlite3 (npm install better-sqlite3) or use Node.js 22.5+ with --experimental-sqlite flag.");
+    this.name = "NoDriverAvailableError";
+  }
+};
+var DriverNotAvailableError = class extends Error {
+  constructor(driverName, availableDrivers) {
+    const available = availableDrivers.length > 0 ? `Available drivers: ${availableDrivers.join(", ")}` : "No drivers are currently available.";
+    super(`Driver "${driverName}" is not available. ${available}`);
+    this.name = "DriverNotAvailableError";
+  }
+};
+var ReadonlyDatabaseError = class extends Error {
+  constructor() {
+    super("Cannot write to a read-only database connection.");
+    this.name = "ReadonlyDatabaseError";
+  }
+};
+
+// node_modules/cursor-history/dist/core/database/debug.js
+function debugLog(message) {
+  if (process.env["DEBUG"] || process.env["CURSOR_HISTORY_DEBUG"]) {
+    console.error(`[cursor-history:sqlite] ${message}`);
+  }
+}
+
+// node_modules/cursor-history/dist/core/database/registry.js
+var DriverRegistry = class {
+  drivers = /* @__PURE__ */ new Map();
+  currentDriver = null;
+  initialized = false;
+  /**
+   * Register a driver with the registry
+   */
+  register(driver) {
+    this.drivers.set(driver.name, driver);
+    debugLog(`Registered driver: ${driver.name}`);
+  }
+  /**
+   * Get all registered driver names
+   */
+  getRegisteredDrivers() {
+    return Array.from(this.drivers.keys());
+  }
+  /**
+   * Check which drivers are currently available
+   */
+  async getAvailableDrivers() {
+    const available = [];
+    for (const [name, driver] of this.drivers) {
+      if (await driver.isAvailable()) {
+        available.push(name);
+      }
+    }
+    return available;
+  }
+  /**
+   * Auto-detect and select the best available driver
+   *
+   * Priority:
+   * 1. User-specified via CURSOR_HISTORY_SQLITE_DRIVER env var
+   * 2. node:sqlite (no native bindings, ESM compatible)
+   * 3. better-sqlite3 (fallback)
+   */
+  async autoSelect() {
+    const envDriver = process.env["CURSOR_HISTORY_SQLITE_DRIVER"];
+    if (envDriver) {
+      debugLog(`Environment override: CURSOR_HISTORY_SQLITE_DRIVER=${envDriver}`);
+      const driver = this.drivers.get(envDriver);
+      if (driver && await driver.isAvailable()) {
+        this.currentDriver = driver;
+        this.initialized = true;
+        debugLog(`Using driver from env var: ${driver.name}`);
+        return driver;
+      }
+      const available = await this.getAvailableDrivers();
+      throw new DriverNotAvailableError(envDriver, available);
+    }
+    const nodeSqlite = this.drivers.get("node:sqlite");
+    if (nodeSqlite && await nodeSqlite.isAvailable()) {
+      this.currentDriver = nodeSqlite;
+      this.initialized = true;
+      debugLog(`Auto-selected driver: node:sqlite`);
+      return nodeSqlite;
+    }
+    const betterSqlite = this.drivers.get("better-sqlite3");
+    if (betterSqlite && await betterSqlite.isAvailable()) {
+      this.currentDriver = betterSqlite;
+      this.initialized = true;
+      debugLog(`Auto-selected driver: better-sqlite3`);
+      return betterSqlite;
+    }
+    throw new NoDriverAvailableError();
+  }
+  /**
+   * Manually set the active driver by name
+   */
+  async setDriver(name) {
+    const driver = this.drivers.get(name);
+    if (!driver) {
+      const available = await this.getAvailableDrivers();
+      throw new DriverNotAvailableError(name, available);
+    }
+    if (!await driver.isAvailable()) {
+      const available = await this.getAvailableDrivers();
+      throw new DriverNotAvailableError(name, available);
+    }
+    this.currentDriver = driver;
+    this.initialized = true;
+    debugLog(`Manually set driver: ${name}`);
+  }
+  /**
+   * Get the name of the currently active driver
+   */
+  getActiveDriver() {
+    if (!this.currentDriver) {
+      throw new Error("No driver is currently active. Call autoSelect() or setDriver() first.");
+    }
+    return this.currentDriver.name;
+  }
+  /**
+   * Check if a driver has been selected
+   */
+  hasActiveDriver() {
+    return this.currentDriver !== null;
+  }
+  /**
+   * Get the current driver, auto-selecting if needed
+   */
+  async ensureDriver() {
+    if (!this.initialized || !this.currentDriver) {
+      return this.autoSelect();
+    }
+    return this.currentDriver;
+  }
+  /**
+   * Open a database in read-only mode
+   */
+  async openDatabase(path) {
+    const driver = await this.ensureDriver();
+    return driver.open(path, { readonly: true });
+  }
+  /**
+   * Open a database in read-write mode
+   */
+  async openDatabaseReadWrite(path) {
+    const driver = await this.ensureDriver();
+    return driver.open(path, { readonly: false });
+  }
+  /**
+   * Synchronous database open (requires driver to already be selected)
+   *
+   * This is used by backup module which needs synchronous access.
+   * Auto-selection must have happened before calling this.
+   */
+  openSync(path, options) {
+    if (!this.currentDriver) {
+      throw new Error("No driver is currently active. Auto-selection must complete before using openSync(). Call a database operation first to trigger auto-selection.");
+    }
+    return this.currentDriver.open(path, options);
+  }
+  /**
+   * Backup a database file to another location
+   *
+   * Uses the native SQLite backup API for consistent snapshots.
+   */
+  async backupDatabase(sourcePath, destPath) {
+    const driver = await this.ensureDriver();
+    return driver.backup(sourcePath, destPath);
+  }
+  /**
+   * Reset the registry (mainly for testing)
+   */
+  reset() {
+    this.currentDriver = null;
+    this.initialized = false;
+    debugLog("Registry reset");
+  }
+};
+var registry = new DriverRegistry();
+
+// node_modules/cursor-history/dist/core/database/drivers/better-sqlite3.js
+var BetterSqlite3 = null;
+var BetterSqlite3Statement = class {
+  stmt;
+  constructor(stmt) {
+    this.stmt = stmt;
+  }
+  get(...params) {
+    return this.stmt.get(...params);
+  }
+  all(...params) {
+    return this.stmt.all(...params);
+  }
+  run(...params) {
+    const result = this.stmt.run(...params);
+    return {
+      changes: result.changes,
+      lastInsertRowid: result.lastInsertRowid
+    };
+  }
+};
+var BetterSqlite3Database = class {
+  nativeDb;
+  constructor(db) {
+    this.nativeDb = db;
+  }
+  prepare(sql) {
+    return new BetterSqlite3Statement(this.nativeDb.prepare(sql));
+  }
+  runSQL(sql) {
+    this.nativeDb.exec(sql);
+  }
+  close() {
+    this.nativeDb.close();
+  }
+};
+var betterSqlite3Driver = {
+  name: "better-sqlite3",
+  async isAvailable() {
+    try {
+      if (!BetterSqlite3) {
+        const module2 = await Promise.resolve().then(() => __toESM(require_lib(), 1));
+        BetterSqlite3 = module2.default;
+      }
+      debugLog("better-sqlite3 is available");
+      return true;
+    } catch {
+      debugLog("better-sqlite3 is not available");
+      return false;
+    }
+  },
+  open(path, options) {
+    if (!BetterSqlite3) {
+      throw new Error("better-sqlite3 is not loaded. Call isAvailable() first.");
+    }
+    const db = new BetterSqlite3(path, { readonly: options.readonly });
+    debugLog(`Opened database with better-sqlite3: ${path} (readonly: ${options.readonly})`);
+    return new BetterSqlite3Database(db);
+  },
+  async backup(sourcePath, destPath) {
+    if (!BetterSqlite3) {
+      throw new Error("better-sqlite3 is not loaded. Call isAvailable() first.");
+    }
+    const sourceDb = new BetterSqlite3(sourcePath, { readonly: true });
+    try {
+      debugLog(`Backing up database with better-sqlite3: ${sourcePath} -> ${destPath}`);
+      await sourceDb.backup(destPath);
+      debugLog(`Backup completed: ${destPath}`);
+    } finally {
+      sourceDb.close();
+    }
+  }
+};
+
+// node_modules/cursor-history/dist/core/database/drivers/node-sqlite.js
+var nodeSqliteModule = null;
+var NodeSqliteStatementWrapper = class {
+  stmt;
+  isReadonly;
+  constructor(stmt, isReadonly) {
+    this.stmt = stmt;
+    this.isReadonly = isReadonly;
+  }
+  get(...params) {
+    return this.stmt.get(...params);
+  }
+  all(...params) {
+    return this.stmt.all(...params);
+  }
+  run(...params) {
+    if (this.isReadonly) {
+      throw new ReadonlyDatabaseError();
+    }
+    const result = this.stmt.run(...params);
+    return {
+      changes: Number(result.changes),
+      lastInsertRowid: result.lastInsertRowid
+    };
+  }
+};
+var NodeSqliteDatabaseWrapper = class {
+  nativeDb;
+  isReadonly;
+  constructor(db, readonly) {
+    this.nativeDb = db;
+    this.isReadonly = readonly;
+  }
+  prepare(sql) {
+    if (this.isReadonly) {
+      const upperSql = sql.trim().toUpperCase();
+      if (upperSql.startsWith("INSERT") || upperSql.startsWith("UPDATE") || upperSql.startsWith("DELETE") || upperSql.startsWith("DROP") || upperSql.startsWith("CREATE") || upperSql.startsWith("ALTER")) {
+        throw new ReadonlyDatabaseError();
+      }
+    }
+    return new NodeSqliteStatementWrapper(this.nativeDb.prepare(sql), this.isReadonly);
+  }
+  runSQL(sql) {
+    if (this.isReadonly) {
+      throw new ReadonlyDatabaseError();
+    }
+    const nativeMethod = "exec";
+    const db = this.nativeDb;
+    if (typeof db[nativeMethod] === "function") {
+      db[nativeMethod](sql);
+    } else {
+      this.nativeDb.prepare(sql).run();
+    }
+  }
+  close() {
+    this.nativeDb.close();
+  }
+};
+var nodeSqliteDriver = {
+  name: "node:sqlite",
+  async isAvailable() {
+    try {
+      if (!nodeSqliteModule) {
+        const module2 = await import("sqlite");
+        nodeSqliteModule = module2;
+      }
+      debugLog("node:sqlite is available");
+      return true;
+    } catch {
+      debugLog("node:sqlite is not available");
+      return false;
+    }
+  },
+  open(path, options) {
+    if (!nodeSqliteModule) {
+      throw new Error("node:sqlite is not loaded. Call isAvailable() first.");
+    }
+    const db = new nodeSqliteModule.DatabaseSync(path);
+    debugLog(`Opened database with node:sqlite: ${path} (readonly: ${options.readonly})`);
+    return new NodeSqliteDatabaseWrapper(db, options.readonly);
+  },
+  async backup(sourcePath, destPath) {
+    if (!nodeSqliteModule) {
+      throw new Error("node:sqlite is not loaded. Call isAvailable() first.");
+    }
+    const sourceDb = new nodeSqliteModule.DatabaseSync(sourcePath);
+    try {
+      debugLog(`Backing up database with node:sqlite: ${sourcePath} -> ${destPath}`);
+      await nodeSqliteModule.backup(sourceDb, destPath);
+      debugLog(`Backup completed: ${destPath}`);
+    } finally {
+      sourceDb.close();
+    }
+  }
+};
+
+// node_modules/cursor-history/dist/core/database/index.js
+registry.register(nodeSqliteDriver);
+registry.register(betterSqlite3Driver);
+async function openDatabase(path) {
+  return registry.openDatabase(path);
+}
+async function openDatabaseReadWrite(path) {
+  return registry.openDatabaseReadWrite(path);
+}
+async function ensureDriver() {
+  await registry.ensureDriver();
+}
+async function backupDatabase(sourcePath, destPath) {
+  return registry.backupDatabase(sourcePath, destPath);
+}
 
 // node_modules/cursor-history/dist/core/parser.js
-init_esm_shims();
 function parseChatData(jsonString, bundle) {
   let data;
   try {
@@ -9326,20 +9623,18 @@ function exportToJson(session, workspacePath) {
 }
 
 // node_modules/cursor-history/dist/core/backup.js
-init_esm_shims();
-var import_better_sqlite3 = __toESM(require_lib(), 1);
+var import_node_crypto = require("crypto");
+var import_node_fs2 = require("fs");
+var import_node_os2 = require("os");
+var import_node_path3 = require("path");
 var import_adm_zip = __toESM(require_adm_zip(), 1);
-import { createHash } from "node:crypto";
-import { existsSync, mkdirSync, readdirSync, statSync, unlinkSync, readFileSync, writeFileSync, rmdirSync } from "node:fs";
-import { homedir as homedir2, tmpdir } from "node:os";
-import { join as join2, basename, dirname, sep } from "node:path";
-var CURSOR_HISTORY_VERSION = "0.8.0";
+var CURSOR_HISTORY_VERSION = "0.9.1";
 var MANIFEST_VERSION = "1.0.0";
 function getDefaultBackupDir() {
-  return join2(homedir2(), "cursor-history-backups");
+  return (0, import_node_path3.join)((0, import_node_os2.homedir)(), "cursor-history-backups");
 }
 function computeChecksum(buffer) {
-  return `sha256:${createHash("sha256").update(buffer).digest("hex")}`;
+  return `sha256:${(0, import_node_crypto.createHash)("sha256").update(buffer).digest("hex")}`;
 }
 function generateBackupFilename() {
   const now = /* @__PURE__ */ new Date();
@@ -9353,10 +9648,10 @@ function generateBackupFilename() {
 }
 function scanDatabaseFiles(dataPath) {
   const files = [];
-  const userDir = dirname(dataPath);
-  const globalDbPath = join2(userDir, "globalStorage", "state.vscdb");
-  if (existsSync(globalDbPath)) {
-    const stat = statSync(globalDbPath);
+  const userDir = (0, import_node_path3.dirname)(dataPath);
+  const globalDbPath = (0, import_node_path3.join)(userDir, "globalStorage", "state.vscdb");
+  if ((0, import_node_fs2.existsSync)(globalDbPath)) {
+    const stat = (0, import_node_fs2.statSync)(globalDbPath);
     files.push({
       absolutePath: globalDbPath,
       relativePath: "globalStorage/state.vscdb",
@@ -9365,15 +9660,15 @@ function scanDatabaseFiles(dataPath) {
     });
   }
   const workspaceStorageDir = dataPath;
-  if (existsSync(workspaceStorageDir)) {
+  if ((0, import_node_fs2.existsSync)(workspaceStorageDir)) {
     try {
-      const entries = readdirSync(workspaceStorageDir, { withFileTypes: true });
+      const entries = (0, import_node_fs2.readdirSync)(workspaceStorageDir, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.isDirectory()) {
-          const workspaceDir = join2(workspaceStorageDir, entry.name);
-          const workspaceDbPath = join2(workspaceDir, "state.vscdb");
-          if (existsSync(workspaceDbPath)) {
-            const stat = statSync(workspaceDbPath);
+          const workspaceDir = (0, import_node_path3.join)(workspaceStorageDir, entry.name);
+          const workspaceDbPath = (0, import_node_path3.join)(workspaceDir, "state.vscdb");
+          if ((0, import_node_fs2.existsSync)(workspaceDbPath)) {
+            const stat = (0, import_node_fs2.statSync)(workspaceDbPath);
             files.push({
               absolutePath: workspaceDbPath,
               relativePath: `workspaceStorage/${entry.name}/state.vscdb`,
@@ -9382,9 +9677,9 @@ function scanDatabaseFiles(dataPath) {
               workspaceId: entry.name
             });
           }
-          const workspaceJsonPath = join2(workspaceDir, "workspace.json");
-          if (existsSync(workspaceJsonPath)) {
-            const stat = statSync(workspaceJsonPath);
+          const workspaceJsonPath = (0, import_node_path3.join)(workspaceDir, "workspace.json");
+          if ((0, import_node_fs2.existsSync)(workspaceJsonPath)) {
+            const stat = (0, import_node_fs2.statSync)(workspaceJsonPath);
             files.push({
               absolutePath: workspaceJsonPath,
               relativePath: `workspaceStorage/${entry.name}/workspace.json`,
@@ -9413,7 +9708,7 @@ function createManifest(files, stats) {
 }
 function countSessions(dbPath) {
   try {
-    const db = new import_better_sqlite3.default(dbPath, { readonly: true });
+    const db = registry.openSync(dbPath, { readonly: true });
     try {
       const row = db.prepare("SELECT value FROM ItemTable WHERE key = 'composer.composerData'").get();
       if (row) {
@@ -9433,19 +9728,11 @@ function countSessions(dbPath) {
     return 0;
   }
 }
-async function backupDatabase(sourcePath, destPath) {
-  const sourceDb = new import_better_sqlite3.default(sourcePath, { readonly: true });
-  try {
-    await sourceDb.backup(destPath);
-  } finally {
-    sourceDb.close();
-  }
-}
 function checkDiskSpace(outputPath, requiredBytes) {
-  const dir = dirname(outputPath);
+  const dir = (0, import_node_path3.dirname)(outputPath);
   try {
-    if (!existsSync(dir)) {
-      mkdirSync(dir, { recursive: true });
+    if (!(0, import_node_fs2.existsSync)(dir)) {
+      (0, import_node_fs2.mkdirSync)(dir, { recursive: true });
     }
     return {
       available: Number.MAX_SAFE_INTEGER,
@@ -9463,14 +9750,14 @@ function checkDiskSpace(outputPath, requiredBytes) {
 async function createBackup(config) {
   const startTime = Date.now();
   const sourcePath = config?.sourcePath ?? getDefaultCursorDataPath2();
-  const outputDir = config?.outputPath ? dirname(config.outputPath) : getDefaultBackupDir();
-  const outputPath = config?.outputPath ?? join2(outputDir, generateBackupFilename());
+  const outputDir = config?.outputPath ? (0, import_node_path3.dirname)(config.outputPath) : getDefaultBackupDir();
+  const outputPath = config?.outputPath ?? (0, import_node_path3.join)(outputDir, generateBackupFilename());
   const force = config?.force ?? false;
   const onProgress = config?.onProgress;
-  if (!existsSync(outputDir)) {
-    mkdirSync(outputDir, { recursive: true });
+  if (!(0, import_node_fs2.existsSync)(outputDir)) {
+    (0, import_node_fs2.mkdirSync)(outputDir, { recursive: true });
   }
-  if (existsSync(outputPath) && !force) {
+  if ((0, import_node_fs2.existsSync)(outputPath) && !force) {
     return {
       success: false,
       backupPath: outputPath,
@@ -9507,8 +9794,8 @@ async function createBackup(config) {
       error: `Insufficient disk space`
     };
   }
-  const tempDir = join2(outputDir, `.backup_temp_${Date.now()}`);
-  mkdirSync(tempDir, { recursive: true });
+  const tempDir = (0, import_node_path3.join)(outputDir, `.backup_temp_${Date.now()}`);
+  (0, import_node_fs2.mkdirSync)(tempDir, { recursive: true });
   try {
     const fileEntries = [];
     let bytesCompleted = 0;
@@ -9524,15 +9811,15 @@ async function createBackup(config) {
         bytesCompleted,
         totalBytes
       });
-      const tempFilePath = join2(tempDir, dbFile.relativePath);
-      mkdirSync(dirname(tempFilePath), { recursive: true });
+      const tempFilePath = (0, import_node_path3.join)(tempDir, dbFile.relativePath);
+      (0, import_node_fs2.mkdirSync)((0, import_node_path3.dirname)(tempFilePath), { recursive: true });
       if (dbFile.type === "global-db" || dbFile.type === "workspace-db") {
         await backupDatabase(dbFile.absolutePath, tempFilePath);
       } else {
-        const content = readFileSync(dbFile.absolutePath);
-        writeFileSync(tempFilePath, content);
+        const content = (0, import_node_fs2.readFileSync)(dbFile.absolutePath);
+        (0, import_node_fs2.writeFileSync)(tempFilePath, content);
       }
-      const buffer = readFileSync(tempFilePath);
+      const buffer = (0, import_node_fs2.readFileSync)(tempFilePath);
       const checksum = computeChecksum(buffer);
       fileEntries.push({
         path: dbFile.relativePath,
@@ -9557,9 +9844,9 @@ async function createBackup(config) {
     });
     const zip = new import_adm_zip.default();
     for (const entry of fileEntries) {
-      const filePath = join2(tempDir, entry.path);
-      const zipPath = entry.path.split(sep).join("/");
-      zip.addLocalFile(filePath, dirname(zipPath), basename(zipPath));
+      const filePath = (0, import_node_path3.join)(tempDir, entry.path);
+      const zipPath = entry.path.split(import_node_path3.sep).join("/");
+      zip.addLocalFile(filePath, (0, import_node_path3.dirname)(zipPath), (0, import_node_path3.basename)(zipPath));
     }
     const stats = {
       totalSize: fileEntries.reduce((sum, f) => sum + f.size, 0),
@@ -9575,8 +9862,8 @@ async function createBackup(config) {
       bytesCompleted: totalBytes,
       totalBytes
     });
-    if (existsSync(outputPath)) {
-      unlinkSync(outputPath);
+    if ((0, import_node_fs2.existsSync)(outputPath)) {
+      (0, import_node_fs2.unlinkSync)(outputPath);
     }
     zip.writeZip(outputPath);
     return {
@@ -9588,47 +9875,67 @@ async function createBackup(config) {
   } finally {
     try {
       const cleanupDir = (dir) => {
-        const entries = readdirSync(dir, { withFileTypes: true });
+        const entries = (0, import_node_fs2.readdirSync)(dir, { withFileTypes: true });
         for (const entry of entries) {
-          const fullPath = join2(dir, entry.name);
+          const fullPath = (0, import_node_path3.join)(dir, entry.name);
           if (entry.isDirectory()) {
             cleanupDir(fullPath);
           } else {
-            unlinkSync(fullPath);
+            (0, import_node_fs2.unlinkSync)(fullPath);
           }
         }
         try {
-          rmdirSync(dir);
+          (0, import_node_fs2.rmdirSync)(dir);
         } catch {
         }
       };
-      if (existsSync(tempDir)) {
+      if ((0, import_node_fs2.existsSync)(tempDir)) {
         cleanupDir(tempDir);
       }
     } catch {
     }
   }
 }
+var TempFileCleanupWrapper = class {
+  innerDb;
+  tempFilePath;
+  constructor(innerDb, tempFilePath) {
+    this.innerDb = innerDb;
+    this.tempFilePath = tempFilePath;
+  }
+  prepare(sql) {
+    return this.innerDb.prepare(sql);
+  }
+  runSQL(sql) {
+    this.innerDb.runSQL(sql);
+  }
+  close() {
+    this.innerDb.close();
+    try {
+      (0, import_node_fs2.unlinkSync)(this.tempFilePath);
+    } catch {
+    }
+  }
+};
 function openBackupDatabase(backupPath, dbPath) {
   const zip = new import_adm_zip.default(backupPath);
   const buffer = zip.readFile(dbPath);
   if (!buffer) {
     throw new Error(`Database not found in backup: ${dbPath}`);
   }
-  const tempFile = join2(tmpdir(), `cursor_history_backup_${Date.now()}_${Math.random().toString(36).slice(2)}.vscdb`);
-  writeFileSync(tempFile, buffer);
-  const db = new import_better_sqlite3.default(tempFile, { readonly: true });
-  db._tempFile = tempFile;
-  const originalClose = db.close.bind(db);
-  db.close = () => {
-    const result = originalClose();
+  const tempFile = (0, import_node_path3.join)((0, import_node_os2.tmpdir)(), `cursor_history_backup_${Date.now()}_${Math.random().toString(36).slice(2)}.vscdb`);
+  (0, import_node_fs2.writeFileSync)(tempFile, buffer);
+  let db = null;
+  try {
+    db = registry.openSync(tempFile, { readonly: true });
+  } catch (err) {
     try {
-      unlinkSync(tempFile);
+      (0, import_node_fs2.unlinkSync)(tempFile);
     } catch {
     }
-    return result;
-  };
-  return db;
+    throw err;
+  }
+  return new TempFileCleanupWrapper(db, tempFile);
 }
 function readBackupManifest(backupPath) {
   try {
@@ -9647,7 +9954,7 @@ function validateBackup(backupPath) {
   const validFiles = [];
   const corruptedFiles = [];
   const missingFiles = [];
-  if (!existsSync(backupPath)) {
+  if (!(0, import_node_fs2.existsSync)(backupPath)) {
     return {
       status: "invalid",
       validFiles: [],
@@ -9750,9 +10057,9 @@ function restoreBackup(config) {
     };
   }
   const manifest = validation.manifest;
-  const userDir = dirname(targetPath);
-  const globalDbPath = join2(userDir, "globalStorage", "state.vscdb");
-  if (!force && existsSync(globalDbPath)) {
+  const userDir = (0, import_node_path3.dirname)(targetPath);
+  const globalDbPath = (0, import_node_path3.join)(userDir, "globalStorage", "state.vscdb");
+  if (!force && (0, import_node_fs2.existsSync)(globalDbPath)) {
     return {
       success: false,
       targetPath,
@@ -9787,10 +10094,10 @@ function restoreBackup(config) {
       if (!buffer) {
         continue;
       }
-      const platformPath = fileEntry.path.split("/").join(sep);
-      const destPath = join2(userDir, platformPath);
-      mkdirSync(dirname(destPath), { recursive: true });
-      writeFileSync(destPath, buffer);
+      const platformPath = fileEntry.path.split("/").join(import_node_path3.sep);
+      const destPath = (0, import_node_path3.join)(userDir, platformPath);
+      (0, import_node_fs2.mkdirSync)((0, import_node_path3.dirname)(destPath), { recursive: true });
+      (0, import_node_fs2.writeFileSync)(destPath, buffer);
       restoredFiles.push(fileEntry.path);
     }
     onProgress?.({
@@ -9809,10 +10116,10 @@ function restoreBackup(config) {
   } catch (e) {
     for (const filePath of restoredFiles) {
       try {
-        const platformPath = filePath.split("/").join(sep);
-        const destPath = join2(userDir, platformPath);
-        if (existsSync(destPath)) {
-          unlinkSync(destPath);
+        const platformPath = filePath.split("/").join(import_node_path3.sep);
+        const destPath = (0, import_node_path3.join)(userDir, platformPath);
+        if ((0, import_node_fs2.existsSync)(destPath)) {
+          (0, import_node_fs2.unlinkSync)(destPath);
         }
       } catch {
       }
@@ -9828,14 +10135,14 @@ function restoreBackup(config) {
   }
 }
 function getDefaultCursorDataPath2() {
-  const home = homedir2();
+  const home = (0, import_node_os2.homedir)();
   switch (process.platform) {
     case "win32":
-      return join2(process.env["APPDATA"] ?? join2(home, "AppData", "Roaming"), "Cursor", "User", "workspaceStorage");
+      return (0, import_node_path3.join)(process.env["APPDATA"] ?? (0, import_node_path3.join)(home, "AppData", "Roaming"), "Cursor", "User", "workspaceStorage");
     case "darwin":
-      return join2(home, "Library", "Application Support", "Cursor", "User", "workspaceStorage");
+      return (0, import_node_path3.join)(home, "Library", "Application Support", "Cursor", "User", "workspaceStorage");
     default:
-      return join2(home, ".config", "Cursor", "User", "workspaceStorage");
+      return (0, import_node_path3.join)(home, ".config", "Cursor", "User", "workspaceStorage");
   }
 }
 
@@ -9852,20 +10159,20 @@ var PROMPTS_KEY = "aiService.prompts";
 var GENERATIONS_KEY = "aiService.generations";
 function getGlobalStoragePath() {
   const platform = process.platform;
-  const home = homedir3();
+  const home = (0, import_node_os3.homedir)();
   if (platform === "win32") {
-    return join3(process.env["APPDATA"] ?? join3(home, "AppData", "Roaming"), "Cursor", "User", "globalStorage");
+    return (0, import_node_path4.join)(process.env["APPDATA"] ?? (0, import_node_path4.join)(home, "AppData", "Roaming"), "Cursor", "User", "globalStorage");
   } else if (platform === "darwin") {
-    return join3(home, "Library", "Application Support", "Cursor", "User", "globalStorage");
+    return (0, import_node_path4.join)(home, "Library", "Application Support", "Cursor", "User", "globalStorage");
   } else {
-    return join3(home, ".config", "Cursor", "User", "globalStorage");
+    return (0, import_node_path4.join)(home, ".config", "Cursor", "User", "globalStorage");
   }
 }
-function openDatabase(dbPath) {
-  return new import_better_sqlite32.default(dbPath, { readonly: true });
+async function openDatabase2(dbPath) {
+  return openDatabase(dbPath);
 }
-function openDatabaseReadWrite(dbPath) {
-  return new import_better_sqlite32.default(dbPath, { readonly: false });
+async function openDatabaseReadWrite2(dbPath) {
+  return openDatabaseReadWrite(dbPath);
 }
 function readWorkspaceJsonFromBackup(backupPath, workspaceId) {
   try {
@@ -9885,11 +10192,12 @@ function readWorkspaceJsonFromBackup(backupPath, workspaceId) {
     return null;
   }
 }
-function findWorkspacesFromBackup(backupPath) {
+async function findWorkspacesFromBackup(backupPath) {
   const manifest = readBackupManifest(backupPath);
   if (!manifest) {
     return [];
   }
+  await ensureDriver();
   const workspaces = [];
   for (const file of manifest.files) {
     if (file.type !== "workspace-db")
@@ -9924,12 +10232,12 @@ function findWorkspacesFromBackup(backupPath) {
   return workspaces;
 }
 function readWorkspaceJson(workspaceDir) {
-  const jsonPath = join3(workspaceDir, "workspace.json");
-  if (!existsSync2(jsonPath)) {
+  const jsonPath = (0, import_node_path4.join)(workspaceDir, "workspace.json");
+  if (!(0, import_node_fs3.existsSync)(jsonPath)) {
     return null;
   }
   try {
-    const content = readFileSync2(jsonPath, "utf-8");
+    const content = (0, import_node_fs3.readFileSync)(jsonPath, "utf-8");
     const data = JSON.parse(content);
     if (data.folder) {
       return data.folder.replace(/^file:\/\//, "").replace(/%20/g, " ");
@@ -9939,30 +10247,30 @@ function readWorkspaceJson(workspaceDir) {
     return null;
   }
 }
-function findWorkspaces(customDataPath, backupPath) {
+async function findWorkspaces(customDataPath, backupPath) {
   if (backupPath) {
-    return findWorkspacesFromBackup(backupPath);
+    return await findWorkspacesFromBackup(backupPath);
   }
   const basePath = getCursorDataPath(customDataPath);
-  if (!existsSync2(basePath)) {
+  if (!(0, import_node_fs3.existsSync)(basePath)) {
     return [];
   }
   const workspaces = [];
   try {
-    const entries = readdirSync2(basePath, { withFileTypes: true });
+    const entries = (0, import_node_fs3.readdirSync)(basePath, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory())
         continue;
-      const workspaceDir = join3(basePath, entry.name);
-      const dbPath = join3(workspaceDir, "state.vscdb");
-      if (!existsSync2(dbPath))
+      const workspaceDir = (0, import_node_path4.join)(basePath, entry.name);
+      const dbPath = (0, import_node_path4.join)(workspaceDir, "state.vscdb");
+      if (!(0, import_node_fs3.existsSync)(dbPath))
         continue;
       const workspacePath = readWorkspaceJson(workspaceDir);
       if (!workspacePath)
         continue;
       let sessionCount = 0;
       try {
-        const db = openDatabase(dbPath);
+        const db = await openDatabase2(dbPath);
         const result = getChatDataFromDb(db);
         if (result) {
           const parsed = parseChatData(result.data, result.bundle);
@@ -10022,13 +10330,13 @@ function getChatDataFromDb(db) {
   }
   return { data: mainData, bundle };
 }
-function listSessions(options, customDataPath, backupPath) {
-  const workspaces = findWorkspaces(customDataPath, backupPath);
+async function listSessions(options, customDataPath, backupPath) {
+  const workspaces = await findWorkspaces(customDataPath, backupPath);
   const filteredWorkspaces = options.workspacePath ? workspaces.filter((w) => w.path === options.workspacePath || w.path.endsWith(options.workspacePath ?? "")) : workspaces;
   const allSessions = [];
   for (const workspace of filteredWorkspaces) {
     try {
-      const db = backupPath ? openBackupDatabase(backupPath, workspace.dbPath) : openDatabase(workspace.dbPath);
+      const db = backupPath ? openBackupDatabase(backupPath, workspace.dbPath) : await openDatabase2(workspace.dbPath);
       const result = getChatDataFromDb(db);
       db.close();
       if (!result)
@@ -10061,8 +10369,8 @@ function listSessions(options, customDataPath, backupPath) {
   }
   return allSessions;
 }
-function getSession(index, customDataPath, backupPath) {
-  const summaries = listSessions({ limit: 0, all: true }, customDataPath, backupPath);
+async function getSession(index, customDataPath, backupPath) {
+  const summaries = await listSessions({ limit: 0, all: true }, customDataPath, backupPath);
   const summary = summaries.find((s) => s.index === index);
   if (!summary) {
     return null;
@@ -10077,9 +10385,9 @@ function getSession(index, customDataPath, backupPath) {
       }
     } else {
       const globalPath = getGlobalStoragePath();
-      const globalDbPath = join3(globalPath, "state.vscdb");
-      if (existsSync2(globalDbPath)) {
-        db = openDatabase(globalDbPath);
+      const globalDbPath = (0, import_node_path4.join)(globalPath, "state.vscdb");
+      if ((0, import_node_fs3.existsSync)(globalDbPath)) {
+        db = await openDatabase2(globalDbPath);
       }
     }
     if (db) {
@@ -10124,13 +10432,13 @@ function getSession(index, customDataPath, backupPath) {
     }
   } catch {
   }
-  const workspaces = findWorkspaces(customDataPath, backupPath);
+  const workspaces = await findWorkspaces(customDataPath, backupPath);
   const workspace = workspaces.find((w) => w.id === summary.workspaceId);
   if (!workspace) {
     return null;
   }
   try {
-    const db = backupPath ? openBackupDatabase(backupPath, workspace.dbPath) : openDatabase(workspace.dbPath);
+    const db = backupPath ? openBackupDatabase(backupPath, workspace.dbPath) : await openDatabase2(workspace.dbPath);
     const result = getChatDataFromDb(db);
     db.close();
     if (!result)
@@ -10149,12 +10457,12 @@ function getSession(index, customDataPath, backupPath) {
     return null;
   }
 }
-function searchSessions(query, options, customDataPath, backupPath) {
-  const summaries = listSessions({ limit: 0, all: true, workspacePath: options.workspacePath }, customDataPath, backupPath);
+async function searchSessions(query, options, customDataPath, backupPath) {
+  const summaries = await listSessions({ limit: 0, all: true, workspacePath: options.workspacePath }, customDataPath, backupPath);
   const results = [];
   const lowerQuery = query.toLowerCase();
   for (const summary of summaries) {
-    const session = getSession(summary.index, customDataPath, backupPath);
+    const session = await getSession(summary.index, customDataPath, backupPath);
     if (!session)
       continue;
     const snippets = getSearchSnippets(session.messages, lowerQuery, options.contextChars);
@@ -10484,11 +10792,11 @@ ${best}`;
   }
   return best;
 }
-function findWorkspaceForSession(sessionId, customDataPath) {
-  const workspaces = findWorkspaces(customDataPath);
+async function findWorkspaceForSession(sessionId, customDataPath) {
+  const workspaces = await findWorkspaces(customDataPath);
   for (const workspace of workspaces) {
     try {
-      const db = openDatabase(workspace.dbPath);
+      const db = await openDatabase2(workspace.dbPath);
       const result = getChatDataFromDb(db);
       db.close();
       if (!result)
@@ -10512,8 +10820,8 @@ function findWorkspaceForSession(sessionId, customDataPath) {
   }
   return null;
 }
-function findWorkspaceByPath(workspacePath, customDataPath) {
-  const workspaces = findWorkspaces(customDataPath);
+async function findWorkspaceByPath(workspacePath, customDataPath) {
+  const workspaces = await findWorkspaces(customDataPath);
   const normalizedPath = normalizePath(workspacePath);
   for (const workspace of workspaces) {
     if (pathsEqual(workspace.path, normalizedPath)) {
@@ -10563,7 +10871,7 @@ function updateComposerData(db, composers, isNewFormat, originalRawData) {
   const jsonValue = JSON.stringify(dataToWrite);
   db.prepare("UPDATE ItemTable SET value = ? WHERE key = ?").run(jsonValue, "composer.composerData");
 }
-function resolveSessionIdentifiers(input, customDataPath) {
+async function resolveSessionIdentifiers(input, customDataPath) {
   let identifiers;
   if (Array.isArray(input)) {
     identifiers = input;
@@ -10572,7 +10880,7 @@ function resolveSessionIdentifiers(input, customDataPath) {
   } else {
     identifiers = [input];
   }
-  const summaries = listSessions({ limit: 0, all: true }, customDataPath);
+  const summaries = await listSessions({ limit: 0, all: true }, customDataPath);
   const resolvedIds = [];
   for (const identifier of identifiers) {
     let sessionId;
@@ -10593,11 +10901,10 @@ function resolveSessionIdentifiers(input, customDataPath) {
 }
 
 // node_modules/cursor-history/dist/core/migrate.js
-init_esm_shims();
-var import_better_sqlite33 = __toESM(require_lib(), 1);
-import { existsSync as existsSync3 } from "node:fs";
-import { join as join4 } from "node:path";
-import { homedir as homedir4 } from "node:os";
+var import_node_fs4 = require("fs");
+var import_node_path5 = require("path");
+var import_node_os4 = require("os");
+var import_better_sqlite32 = __toESM(require_lib(), 1);
 function generateSessionId() {
   return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
     const r = Math.random() * 16 | 0;
@@ -10607,13 +10914,13 @@ function generateSessionId() {
 }
 function getGlobalStoragePath2() {
   const platform = process.platform;
-  const home = homedir4();
+  const home = (0, import_node_os4.homedir)();
   if (platform === "win32") {
-    return join4(process.env["APPDATA"] ?? join4(home, "AppData", "Roaming"), "Cursor", "User", "globalStorage");
+    return (0, import_node_path5.join)(process.env["APPDATA"] ?? (0, import_node_path5.join)(home, "AppData", "Roaming"), "Cursor", "User", "globalStorage");
   } else if (platform === "darwin") {
-    return join4(home, "Library", "Application Support", "Cursor", "User", "globalStorage");
+    return (0, import_node_path5.join)(home, "Library", "Application Support", "Cursor", "User", "globalStorage");
   } else {
-    return join4(home, ".config", "Cursor", "User", "globalStorage");
+    return (0, import_node_path5.join)(home, ".config", "Cursor", "User", "globalStorage");
   }
 }
 function transformPath(path, sourcePrefix, destPrefix) {
@@ -10735,12 +11042,12 @@ function isNestedPath(source, destination) {
   return normalizedDest.startsWith(normalizedSource + "/");
 }
 function copyBubbleDataInGlobalStorage(oldComposerId, newComposerId, sourceWorkspace, destWorkspace, debug = false) {
-  const globalDbPath = join4(getGlobalStoragePath2(), "state.vscdb");
-  if (!existsSync3(globalDbPath)) {
+  const globalDbPath = (0, import_node_path5.join)(getGlobalStoragePath2(), "state.vscdb");
+  if (!(0, import_node_fs4.existsSync)(globalDbPath)) {
     return /* @__PURE__ */ new Map();
   }
   const bubbleIdMap = /* @__PURE__ */ new Map();
-  const db = new import_better_sqlite33.default(globalDbPath, { readonly: false });
+  const db = new import_better_sqlite32.default(globalDbPath, { readonly: false });
   const sourcePrefix = normalizePath(sourceWorkspace).replace(/\/+$/, "");
   const destPrefix = normalizePath(destWorkspace).replace(/\/+$/, "");
   try {
@@ -10789,11 +11096,11 @@ function copyBubbleDataInGlobalStorage(oldComposerId, newComposerId, sourceWorks
   }
 }
 function updateBubblePathsInGlobalStorage(composerId, sourceWorkspace, destWorkspace, debug = false) {
-  const globalDbPath = join4(getGlobalStoragePath2(), "state.vscdb");
-  if (!existsSync3(globalDbPath)) {
+  const globalDbPath = (0, import_node_path5.join)(getGlobalStoragePath2(), "state.vscdb");
+  if (!(0, import_node_fs4.existsSync)(globalDbPath)) {
     return;
   }
-  const db = new import_better_sqlite33.default(globalDbPath, { readonly: false });
+  const db = new import_better_sqlite32.default(globalDbPath, { readonly: false });
   const sourcePrefix = normalizePath(sourceWorkspace).replace(/\/+$/, "");
   const destPrefix = normalizePath(destWorkspace).replace(/\/+$/, "");
   try {
@@ -10813,10 +11120,10 @@ function updateBubblePathsInGlobalStorage(composerId, sourceWorkspace, destWorks
     db.close();
   }
 }
-function migrateSession(sessionId, options) {
+async function migrateSession(sessionId, options) {
   const { destination, mode, dryRun, dataPath, debug = false } = options;
   const normalizedDest = normalizePath(destination);
-  const sourceInfo = findWorkspaceForSession(sessionId, dataPath);
+  const sourceInfo = await findWorkspaceForSession(sessionId, dataPath);
   if (!sourceInfo) {
     throw new SessionNotFoundError(sessionId);
   }
@@ -10827,7 +11134,7 @@ function migrateSession(sessionId, options) {
   if (isNestedPath(sourceWorkspace, normalizedDest)) {
     throw new NestedPathError(sourceWorkspace, normalizedDest);
   }
-  const destInfo = findWorkspaceByPath(normalizedDest, dataPath);
+  const destInfo = await findWorkspaceByPath(normalizedDest, dataPath);
   if (!destInfo) {
     throw new WorkspaceNotFoundError(normalizedDest);
   }
@@ -10843,8 +11150,8 @@ function migrateSession(sessionId, options) {
     };
   }
   try {
-    const sourceDb = openDatabaseReadWrite(sourceInfo.dbPath);
-    const destDb = openDatabaseReadWrite(destInfo.dbPath);
+    const sourceDb = await openDatabaseReadWrite2(sourceInfo.dbPath);
+    const destDb = await openDatabaseReadWrite2(destInfo.dbPath);
     try {
       const sourceResult = getComposerData(sourceDb);
       const destResult = getComposerData(destDb);
@@ -10905,12 +11212,12 @@ function migrateSession(sessionId, options) {
     };
   }
 }
-function migrateSessions(options) {
+async function migrateSessions(options) {
   const { sessionIds, ...sessionOptions } = options;
   const results = [];
   for (const sessionId of sessionIds) {
     try {
-      const result = migrateSession(sessionId, sessionOptions);
+      const result = await migrateSession(sessionId, sessionOptions);
       results.push(result);
     } catch (error) {
       results.push({
@@ -10928,7 +11235,6 @@ function migrateSessions(options) {
 }
 
 // node_modules/cursor-history/dist/lib/backup.js
-init_esm_shims();
 async function createBackup2(config) {
   return createBackup(config);
 }
@@ -10956,10 +11262,10 @@ function convertToLibrarySession(coreSession) {
     }
   };
 }
-function listSessions2(config) {
+async function listSessions2(config) {
   try {
     const resolved = mergeWithDefaults(config);
-    const coreSessions = listSessions({
+    const coreSessions = await listSessions({
       limit: -1,
       // Get all, we'll paginate ourselves
       all: true,
@@ -10969,13 +11275,14 @@ function listSessions2(config) {
     const start = resolved.offset;
     const end = Math.min(start + resolved.limit, total);
     const paginatedSessions = coreSessions.slice(start, end);
-    const sessions = paginatedSessions.map((summary) => {
-      const fullSession = getSession(summary.index, resolved.dataPath, resolved.backupPath);
+    const sessions = [];
+    for (const summary of paginatedSessions) {
+      const fullSession = await getSession(summary.index, resolved.dataPath, resolved.backupPath);
       if (!fullSession) {
         throw new DatabaseNotFoundError(`Session ${summary.index} not found`);
       }
-      return convertToLibrarySession(fullSession);
-    });
+      sessions.push(convertToLibrarySession(fullSession));
+    }
     return {
       data: sessions,
       pagination: {
@@ -10998,11 +11305,11 @@ function listSessions2(config) {
     throw new Error(`Failed to list sessions: ${err instanceof Error ? err.message : String(err)}`);
   }
 }
-function getSession2(index, config) {
+async function getSession2(index, config) {
   try {
     const resolved = mergeWithDefaults(config);
     const coreIndex = index + 1;
-    const coreSession = getSession(coreIndex, resolved.dataPath, resolved.backupPath);
+    const coreSession = await getSession(coreIndex, resolved.dataPath, resolved.backupPath);
     if (!coreSession) {
       throw new DatabaseNotFoundError(`Session at index ${index} not found`);
     }
@@ -11020,17 +11327,18 @@ function getSession2(index, config) {
     throw new Error(`Failed to get session: ${err instanceof Error ? err.message : String(err)}`);
   }
 }
-function searchSessions2(query, config) {
+async function searchSessions2(query, config) {
   try {
     const resolved = mergeWithDefaults(config);
-    const coreResults = searchSessions(query, {
+    const coreResults = await searchSessions(query, {
       limit: resolved.limit === Number.MAX_SAFE_INTEGER ? 0 : resolved.limit,
       contextChars: resolved.context * 80,
       // Rough estimate: 1 line = 80 chars
       workspacePath: resolved.workspace
     }, resolved.dataPath, resolved.backupPath);
-    return coreResults.map((coreResult) => {
-      const fullSession = getSession(coreResult.index, resolved.dataPath, resolved.backupPath);
+    const results = [];
+    for (const coreResult of coreResults) {
+      const fullSession = await getSession(coreResult.index, resolved.dataPath, resolved.backupPath);
       if (!fullSession) {
         throw new DatabaseNotFoundError(`Session ${coreResult.index} not found`);
       }
@@ -11062,7 +11370,7 @@ function searchSessions2(query, config) {
             contextAfter.push(line);
         }
       }
-      return {
+      results.push({
         session: convertToLibrarySession(fullSession),
         match: lines[matchLineIndex] ?? match,
         messageIndex: 0,
@@ -11070,8 +11378,9 @@ function searchSessions2(query, config) {
         offset,
         contextBefore: contextBefore.length > 0 ? contextBefore : void 0,
         contextAfter: contextAfter.length > 0 ? contextAfter : void 0
-      };
-    });
+      });
+    }
+    return results;
   } catch (err) {
     if (err instanceof Error && err.message.includes("SQLITE_BUSY")) {
       throw new DatabaseLockedError(config?.dataPath ?? "default path");
@@ -11085,11 +11394,11 @@ function searchSessions2(query, config) {
     throw new Error(`Failed to search sessions: ${err instanceof Error ? err.message : String(err)}`);
   }
 }
-function exportSessionToJson(index, config) {
+async function exportSessionToJson(index, config) {
   try {
     const resolved = mergeWithDefaults(config);
     const coreIndex = index + 1;
-    const coreSession = getSession(coreIndex, resolved.dataPath, resolved.backupPath);
+    const coreSession = await getSession(coreIndex, resolved.dataPath, resolved.backupPath);
     if (!coreSession) {
       throw new DatabaseNotFoundError(`Session at index ${index} not found`);
     }
@@ -11101,11 +11410,11 @@ function exportSessionToJson(index, config) {
     throw new Error(`Failed to export session to JSON: ${err instanceof Error ? err.message : String(err)}`);
   }
 }
-function exportSessionToMarkdown(index, config) {
+async function exportSessionToMarkdown(index, config) {
   try {
     const resolved = mergeWithDefaults(config);
     const coreIndex = index + 1;
-    const coreSession = getSession(coreIndex, resolved.dataPath, resolved.backupPath);
+    const coreSession = await getSession(coreIndex, resolved.dataPath, resolved.backupPath);
     if (!coreSession) {
       throw new DatabaseNotFoundError(`Session at index ${index} not found`);
     }
@@ -11117,10 +11426,10 @@ function exportSessionToMarkdown(index, config) {
     throw new Error(`Failed to export session to Markdown: ${err instanceof Error ? err.message : String(err)}`);
   }
 }
-function migrateSession2(config) {
-  const sessionIds = resolveSessionIdentifiers(config.sessions, config.dataPath);
+async function migrateSession2(config) {
+  const sessionIds = await resolveSessionIdentifiers(config.sessions, config.dataPath);
   const destination = expandPath(config.destination);
-  return migrateSessions({
+  return await migrateSessions({
     sessionIds,
     destination,
     mode: config.mode ?? "move",
@@ -11130,11 +11439,7 @@ function migrateSession2(config) {
   });
 }
 
-// src/errors.ts
-init_esm_shims();
-
 // src/types.ts
-init_esm_shims();
 var MCP_ERROR_CODES = {
   DATABASE_NOT_FOUND: -32001,
   DATABASE_LOCKED: -32002,
@@ -11248,7 +11553,7 @@ var listSessionsTool = {
 async function handleListSessions(args) {
   try {
     const parsed = ListInputSchema.parse(args);
-    const result = listSessions2({
+    const result = await listSessions2({
       limit: parsed.limit,
       offset: parsed.offset,
       workspace: parsed.workspace
@@ -11292,7 +11597,6 @@ async function handleListSessions(args) {
 }
 
 // src/tools/show-session.ts
-init_esm_shims();
 var ShowInputSchema = z.object({
   sessionIndex: z.number().int().min(1)
 });
@@ -11315,7 +11619,7 @@ var showSessionTool = {
 async function handleShowSession(args) {
   try {
     const parsed = ShowInputSchema.parse(args);
-    const session = getSession2(parsed.sessionIndex - 1);
+    const session = await getSession2(parsed.sessionIndex - 1);
     const workspaceName = session.workspace ? session.workspace.split("/").pop() ?? session.workspace : "No workspace";
     const date = new Date(session.timestamp).toLocaleString();
     const lines = [
@@ -11361,7 +11665,6 @@ async function handleShowSession(args) {
 }
 
 // src/tools/search.ts
-init_esm_shims();
 var SearchInputSchema = z.object({
   query: z.string().min(1),
   limit: z.number().int().min(1).max(100).default(10).optional(),
@@ -11400,7 +11703,7 @@ var searchTool = {
 async function handleSearch(args) {
   try {
     const parsed = SearchInputSchema.parse(args);
-    const results = searchSessions2(parsed.query, {
+    const results = await searchSessions2(parsed.query, {
       limit: parsed.limit,
       context: parsed.context
     });
@@ -11430,7 +11733,6 @@ async function handleSearch(args) {
 }
 
 // src/tools/export.ts
-init_esm_shims();
 var ExportInputSchema = z.object({
   sessionIndex: z.number().int().min(1),
   format: z.enum(["markdown", "json"]).default("markdown").optional()
@@ -11463,10 +11765,10 @@ async function handleExport(args) {
     const format = parsed.format ?? "markdown";
     const index = parsed.sessionIndex - 1;
     if (format === "json") {
-      const result = exportSessionToJson(index);
+      const result = await exportSessionToJson(index);
       return JSON.stringify(result, null, 2);
     } else {
-      const result = exportSessionToMarkdown(index);
+      const result = await exportSessionToMarkdown(index);
       return result;
     }
   } catch (error) {
@@ -11479,7 +11781,6 @@ async function handleExport(args) {
 }
 
 // src/tools/backup.ts
-init_esm_shims();
 var BackupInputSchema = z.object({
   outputPath: z.string().optional(),
   force: z.boolean().default(false).optional()
@@ -11539,7 +11840,6 @@ function formatBytes(bytes) {
 }
 
 // src/tools/restore.ts
-init_esm_shims();
 var RestoreInputSchema = z.object({
   backupPath: z.string(),
   force: z.boolean().default(false).optional()
@@ -11597,7 +11897,6 @@ async function handleRestore(args) {
 }
 
 // src/tools/migrate.ts
-init_esm_shims();
 var MigrateInputSchema = z.object({
   sessionIndexes: z.array(z.number().int().min(1)).min(1),
   destination: z.string(),
@@ -11638,7 +11937,7 @@ async function handleMigrate(args) {
     const parsed = MigrateInputSchema.parse(args);
     const mode = parsed.mode ?? "move";
     const zeroBasedIndexes = parsed.sessionIndexes.map((i) => i - 1);
-    const results = migrateSession2({
+    const results = await migrateSession2({
       sessions: zeroBasedIndexes,
       destination: parsed.destination,
       mode
@@ -11764,4 +12063,4 @@ main().catch((error) => {
   console.error("Fatal error:", error);
   process.exit(1);
 });
-//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.cjs.map