@liorandb/core 1.0.18 → 1.1.0

package/dist/index.js

@@ -1,20 +1,18 @@
 // src/LioranManager.ts
-import path7 from "path";
-import fs7 from "fs";
+import path9 from "path";
+import fs9 from "fs";
 import process2 from "process";
 
 // src/core/database.ts
-import path4 from "path";
-import fs4 from "fs";
-import { execFile } from "child_process";
-import { promisify } from "util";
+import path6 from "path";
+import fs6 from "fs";
 
 // src/core/collection.ts
 import { ClassicLevel as ClassicLevel3 } from "classic-level";
 
 // src/core/query.ts
-function getByPath(obj, path8) {
-  return path8.split(".").reduce((o, p) => o ? o[p] : void 0, obj);
+function getByPath(obj, path10) {
+  return path10.split(".").reduce((o, p) => o ? o[p] : void 0, obj);
 }
 function matchDocument(doc, query) {
   for (const key of Object.keys(query)) {
@@ -295,68 +293,97 @@ var Index = class {
 
 // src/core/compaction.ts
 var TMP_SUFFIX = "__compact_tmp";
-var OLD_SUFFIX = "__old";
+var OLD_SUFFIX = "__compact_old";
+var INDEX_DIR = "__indexes";
 async function compactCollectionEngine(col) {
-  await crashRecovery(col.dir);
   const baseDir = col.dir;
   const tmpDir = baseDir + TMP_SUFFIX;
   const oldDir = baseDir + OLD_SUFFIX;
+  await crashRecovery(baseDir);
   safeRemove(tmpDir);
   safeRemove(oldDir);
   await snapshotRebuild(col, tmpDir);
-  atomicSwap(baseDir, tmpDir, oldDir);
+  await atomicSwap(baseDir, tmpDir, oldDir);
   safeRemove(oldDir);
+  await reopenCollectionDB(col);
+  await rebuildIndexes(col);
 }
 async function snapshotRebuild(col, tmpDir) {
   fs2.mkdirSync(tmpDir, { recursive: true });
-  const tmpDB = new ClassicLevel2(tmpDir, { valueEncoding: "utf8" });
+  const tmpDB = new ClassicLevel2(tmpDir, {
+    valueEncoding: "utf8"
+  });
   for await (const [key, val] of col.db.iterator()) {
-    await tmpDB.put(key, val);
+    if (val !== void 0) {
+      await tmpDB.put(key, val);
+    }
   }
   await tmpDB.close();
   await col.db.close();
 }
-function atomicSwap(base, tmp, old) {
+async function atomicSwap(base, tmp, old) {
   fs2.renameSync(base, old);
-  fs2.renameSync(tmp, base);
+  try {
+    fs2.renameSync(tmp, base);
+  } catch (err) {
+    if (fs2.existsSync(old)) {
+      fs2.renameSync(old, base);
+    }
+    throw err;
+  }
 }
 async function crashRecovery(baseDir) {
   const tmp = baseDir + TMP_SUFFIX;
   const old = baseDir + OLD_SUFFIX;
-  if (fs2.existsSync(tmp) && fs2.existsSync(old)) {
+  const baseExists = fs2.existsSync(baseDir);
+  const tmpExists = fs2.existsSync(tmp);
+  const oldExists = fs2.existsSync(old);
+  if (tmpExists && oldExists) {
     safeRemove(baseDir);
     fs2.renameSync(tmp, baseDir);
     safeRemove(old);
+    return;
   }
-  if (fs2.existsSync(old) && !fs2.existsSync(baseDir)) {
+  if (!baseExists && oldExists) {
     fs2.renameSync(old, baseDir);
+    return;
   }
-  if (fs2.existsSync(tmp) && !fs2.existsSync(old)) {
+  if (tmpExists && !oldExists) {
     safeRemove(tmp);
   }
 }
+async function reopenCollectionDB(col) {
+  col.db = new ClassicLevel2(col.dir, {
+    valueEncoding: "utf8"
+  });
+}
 async function rebuildIndexes(col) {
-  const indexRoot = path2.join(col.dir, "__indexes");
-  safeRemove(indexRoot);
-  fs2.mkdirSync(indexRoot, { recursive: true });
-  for (const idx of col["indexes"].values()) {
+  const indexRoot = path2.join(col.dir, INDEX_DIR);
+  const oldIndexes = new Map(col["indexes"]);
+  for (const idx of oldIndexes.values()) {
     try {
       await idx.close();
     } catch {
     }
   }
-  const newIndexes = /* @__PURE__ */ new Map();
-  for (const idx of col["indexes"].values()) {
-    const fresh = new Index(col.dir, idx.field, {
+  safeRemove(indexRoot);
+  fs2.mkdirSync(indexRoot, { recursive: true });
+  const rebuiltIndexes = /* @__PURE__ */ new Map();
+  for (const idx of oldIndexes.values()) {
+    const rebuilt = new Index(col.dir, idx.field, {
       unique: idx.unique
     });
     for await (const [, enc] of col.db.iterator()) {
-      const doc = decryptData(enc);
-      await fresh.insert(doc);
+      if (!enc) continue;
+      try {
+        const doc = decryptData(enc);
+        await rebuilt.insert(doc);
+      } catch {
+      }
     }
-    newIndexes.set(idx.field, fresh);
+    rebuiltIndexes.set(idx.field, rebuilt);
   }
-  col["indexes"] = newIndexes;
+  col["indexes"] = rebuiltIndexes;
 }
 function safeRemove(p) {
   if (fs2.existsSync(p)) {
@@ -820,10 +847,305 @@ var MigrationEngine = class {
   }
 };
 
+// src/core/wal.ts
+import fs4 from "fs";
+import path4 from "path";
+var MAX_WAL_SIZE = 16 * 1024 * 1024;
+var WAL_DIR = "__wal";
+var CRC32_TABLE = (() => {
+  const table = new Uint32Array(256);
+  for (let i = 0; i < 256; i++) {
+    let c = i;
+    for (let k = 0; k < 8; k++) {
+      c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
+    }
+    table[i] = c >>> 0;
+  }
+  return table;
+})();
+function crc32(input) {
+  let crc = 4294967295;
+  for (let i = 0; i < input.length; i++) {
+    crc = CRC32_TABLE[(crc ^ input.charCodeAt(i)) & 255] ^ crc >>> 8;
+  }
+  return (crc ^ 4294967295) >>> 0;
+}
+var WALManager = class {
+  walDir;
+  currentGen = 1;
+  lsn = 0;
+  fd = null;
+  constructor(baseDir) {
+    this.walDir = path4.join(baseDir, WAL_DIR);
+    fs4.mkdirSync(this.walDir, { recursive: true });
+    this.currentGen = this.detectLastGeneration();
+    this.recoverLSNFromExistingLogs();
+  }
+  /* -------------------------
+     INTERNAL HELPERS
+  ------------------------- */
+  walPath(gen = this.currentGen) {
+    return path4.join(
+      this.walDir,
+      `wal-${String(gen).padStart(6, "0")}.log`
+    );
+  }
+  detectLastGeneration() {
+    if (!fs4.existsSync(this.walDir)) return 1;
+    const files = fs4.readdirSync(this.walDir);
+    let max = 0;
+    for (const f of files) {
+      const m = f.match(/^wal-(\d+)\.log$/);
+      if (m) {
+        const gen = Number(m[1]);
+        if (!Number.isNaN(gen)) {
+          max = Math.max(max, gen);
+        }
+      }
+    }
+    return max || 1;
+  }
+  recoverLSNFromExistingLogs() {
+    const files = this.getSortedWalFiles();
+    for (const file of files) {
+      const filePath = path4.join(this.walDir, file);
+      const lines = fs4.readFileSync(filePath, "utf8").split("\n");
+      for (const line of lines) {
+        if (!line.trim()) continue;
+        try {
+          const parsed = JSON.parse(line);
+          const { crc, ...record } = parsed;
+          if (crc32(JSON.stringify(record)) !== crc) break;
+          this.lsn = Math.max(this.lsn, record.lsn);
+        } catch {
+          break;
+        }
+      }
+    }
+  }
+  getSortedWalFiles() {
+    return fs4.readdirSync(this.walDir).filter((f) => /^wal-\d+\.log$/.test(f)).sort((a, b) => {
+      const ga = Number(a.match(/^wal-(\d+)\.log$/)[1]);
+      const gb = Number(b.match(/^wal-(\d+)\.log$/)[1]);
+      return ga - gb;
+    });
+  }
+  async open() {
+    if (!this.fd) {
+      this.fd = await fs4.promises.open(this.walPath(), "a");
+    }
+  }
+  async rotate() {
+    if (this.fd) {
+      await this.fd.sync();
+      await this.fd.close();
+      this.fd = null;
+    }
+    this.currentGen++;
+  }
+  /* -------------------------
+     APPEND (Crash-safe)
+  ------------------------- */
+  async append(record) {
+    await this.open();
+    const full = {
+      ...record,
+      lsn: ++this.lsn
+    };
+    const body = JSON.stringify(full);
+    const stored = {
+      ...full,
+      crc: crc32(body)
+    };
+    const line = JSON.stringify(stored) + "\n";
+    await this.fd.write(line);
+    await this.fd.sync();
+    const stat = await this.fd.stat();
+    if (stat.size >= MAX_WAL_SIZE) {
+      await this.rotate();
+    }
+    return full.lsn;
+  }
+  /* -------------------------
+     REPLAY (Auto-heal tail)
+  ------------------------- */
+  async replay(fromLSN, apply) {
+    if (!fs4.existsSync(this.walDir)) return;
+    const files = this.getSortedWalFiles();
+    for (const file of files) {
+      const filePath = path4.join(this.walDir, file);
+      const fd = fs4.openSync(filePath, "r+");
+      const content = fs4.readFileSync(filePath, "utf8");
+      const lines = content.split("\n");
+      let validOffset = 0;
+      for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (!line.trim()) {
+          validOffset += line.length + 1;
+          continue;
+        }
+        let parsed;
+        try {
+          parsed = JSON.parse(line);
+        } catch {
+          break;
+        }
+        const { crc, ...record } = parsed;
+        const expected = crc32(JSON.stringify(record));
+        if (expected !== crc) {
+          break;
+        }
+        validOffset += line.length + 1;
+        if (record.lsn <= fromLSN) continue;
+        this.lsn = Math.max(this.lsn, record.lsn);
+        await apply(record);
+      }
+      const stat = fs4.fstatSync(fd);
+      if (validOffset < stat.size) {
+        fs4.ftruncateSync(fd, validOffset);
+      }
+      fs4.closeSync(fd);
+    }
+  }
+  /* -------------------------
+     CLEANUP
+  ------------------------- */
+  async cleanup(beforeGen) {
+    if (!fs4.existsSync(this.walDir)) return;
+    const files = fs4.readdirSync(this.walDir);
+    for (const f of files) {
+      const m = f.match(/^wal-(\d+)\.log$/);
+      if (!m) continue;
+      const gen = Number(m[1]);
+      if (gen < beforeGen) {
+        fs4.unlinkSync(path4.join(this.walDir, f));
+      }
+    }
+  }
+  /* -------------------------
+     GETTERS
+  ------------------------- */
+  getCurrentLSN() {
+    return this.lsn;
+  }
+  getCurrentGen() {
+    return this.currentGen;
+  }
+};
+
+// src/core/checkpoint.ts
+import fs5 from "fs";
+import path5 from "path";
+var CHECKPOINT_A = "__checkpoint_A.json";
+var CHECKPOINT_B = "__checkpoint_B.json";
+var FORMAT_VERSION = 1;
+var CRC32_TABLE2 = (() => {
+  const table = new Uint32Array(256);
+  for (let i = 0; i < 256; i++) {
+    let c = i;
+    for (let k = 0; k < 8; k++) {
+      c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
+    }
+    table[i] = c >>> 0;
+  }
+  return table;
+})();
+function crc322(input) {
+  let crc = 4294967295;
+  for (let i = 0; i < input.length; i++) {
+    crc = CRC32_TABLE2[(crc ^ input.charCodeAt(i)) & 255] ^ crc >>> 8;
+  }
+  return (crc ^ 4294967295) >>> 0;
+}
+var CheckpointManager = class {
+  baseDir;
+  data;
+  constructor(baseDir) {
+    this.baseDir = baseDir;
+    this.data = {
+      lsn: 0,
+      walGen: 1,
+      time: 0,
+      version: FORMAT_VERSION
+    };
+    this.load();
+  }
+  /* -------------------------
+     LOAD (CRC + FALLBACK)
+  ------------------------- */
+  load() {
+    const a = this.readCheckpoint(CHECKPOINT_A);
+    const b = this.readCheckpoint(CHECKPOINT_B);
+    if (a && b) {
+      this.data = a.data.lsn >= b.data.lsn ? a.data : b.data;
+      return;
+    }
+    if (a) {
+      this.data = a.data;
+      return;
+    }
+    if (b) {
+      this.data = b.data;
+      return;
+    }
+    console.warn("No valid checkpoint found, starting from zero");
+  }
+  readCheckpoint(file) {
+    const filePath = path5.join(this.baseDir, file);
+    if (!fs5.existsSync(filePath)) return null;
+    try {
+      const raw = fs5.readFileSync(filePath, "utf8");
+      const parsed = JSON.parse(raw);
+      if (!parsed?.data || typeof parsed.crc !== "number") {
+        return null;
+      }
+      const expected = crc322(JSON.stringify(parsed.data));
+      if (expected !== parsed.crc) {
+        console.error(`Checkpoint CRC mismatch: ${file}`);
+        return null;
+      }
+      return parsed;
+    } catch {
+      return null;
+    }
+  }
+  /* -------------------------
+     SAVE (DUAL WRITE)
+  ------------------------- */
+  save(lsn, walGen) {
+    const data = {
+      lsn,
+      walGen,
+      time: Date.now(),
+      version: FORMAT_VERSION
+    };
+    const stored = {
+      data,
+      crc: crc322(JSON.stringify(data))
+    };
+    const target = lsn % 2 === 0 ? CHECKPOINT_A : CHECKPOINT_B;
+    try {
+      fs5.writeFileSync(
+        path5.join(this.baseDir, target),
+        JSON.stringify(stored, null, 2),
+        "utf8"
+      );
+      this.data = data;
+    } catch (err) {
+      console.error("Failed to write checkpoint:", err);
+    }
+  }
+  /* -------------------------
+     GET CURRENT
+  ------------------------- */
+  get() {
+    return this.data;
+  }
+};
+
 // src/core/database.ts
-var exec = promisify(execFile);
 var META_FILE = "__db_meta.json";
-var META_VERSION = 1;
+var META_VERSION = 2;
 var DEFAULT_SCHEMA_VERSION = "v1";
 var DBTransactionContext = class {
   constructor(db, txId) {
@@ -846,11 +1168,24 @@ var DBTransactionContext = class {
     });
   }
   async commit() {
-    await this.db.writeWAL(this.ops);
-    await this.db.writeWAL([{ tx: this.txId, commit: true }]);
+    for (const op of this.ops) {
+      await this.db.wal.append({
+        tx: this.txId,
+        type: "op",
+        payload: op
+      });
+    }
+    const commitLSN = await this.db.wal.append({
+      tx: this.txId,
+      type: "commit"
+    });
     await this.db.applyTransaction(this.ops);
-    await this.db.writeWAL([{ tx: this.txId, applied: true }]);
-    await this.db.clearWAL();
+    const appliedLSN = await this.db.wal.append({
+      tx: this.txId,
+      type: "applied"
+    });
+    this.db.advanceCheckpoint(appliedLSN);
+    await this.db.postCommitMaintenance();
   }
 };
 var LioranDB = class _LioranDB {
@@ -858,26 +1193,68 @@ var LioranDB = class _LioranDB {
   dbName;
   manager;
   collections;
-  walPath;
   metaPath;
   meta;
   migrator;
   static TX_SEQ = 0;
+  wal;
+  checkpoint;
   constructor(basePath, dbName, manager) {
     this.basePath = basePath;
     this.dbName = dbName;
     this.manager = manager;
     this.collections = /* @__PURE__ */ new Map();
-    this.walPath = path4.join(basePath, "__tx_wal.log");
-    this.metaPath = path4.join(basePath, META_FILE);
-    fs4.mkdirSync(basePath, { recursive: true });
+    this.metaPath = path6.join(basePath, META_FILE);
+    fs6.mkdirSync(basePath, { recursive: true });
     this.loadMeta();
+    this.wal = new WALManager(basePath);
+    this.checkpoint = new CheckpointManager(basePath);
     this.migrator = new MigrationEngine(this);
-    this.recoverFromWAL().catch(console.error);
+    this.initialize().catch(console.error);
+  }
+  /* ------------------------- INIT & RECOVERY ------------------------- */
+  async initialize() {
+    await this.recoverFromWAL();
+  }
+  async recoverFromWAL() {
+    const checkpointData = this.checkpoint.get();
+    const fromLSN = checkpointData.lsn;
+    const committed = /* @__PURE__ */ new Set();
+    const applied = /* @__PURE__ */ new Set();
+    const ops = /* @__PURE__ */ new Map();
+    await this.wal.replay(fromLSN, async (record) => {
+      if (record.type === "commit") {
+        committed.add(record.tx);
+      } else if (record.type === "applied") {
+        applied.add(record.tx);
+      } else if (record.type === "op") {
+        if (!ops.has(record.tx)) ops.set(record.tx, []);
+        ops.get(record.tx).push(record.payload);
+      }
+    });
+    let highestAppliedLSN = fromLSN;
+    for (const tx of committed) {
+      if (applied.has(tx)) continue;
+      const txOps = ops.get(tx);
+      if (txOps) {
+        await this.applyTransaction(txOps);
+        highestAppliedLSN = this.wal.getCurrentLSN();
+      }
+    }
+    this.advanceCheckpoint(highestAppliedLSN);
+  }
+  /* ------------------------- CHECKPOINT ADVANCE ------------------------- */
+  advanceCheckpoint(lsn) {
+    const current = this.checkpoint.get();
+    if (lsn > current.lsn) {
+      this.checkpoint.save(lsn, this.wal.getCurrentGen());
+      this.wal.cleanup(this.wal.getCurrentGen() - 1).catch(() => {
+      });
+    }
   }
   /* ------------------------- META ------------------------- */
   loadMeta() {
-    if (!fs4.existsSync(this.metaPath)) {
+    if (!fs6.existsSync(this.metaPath)) {
       this.meta = {
         version: META_VERSION,
         indexes: {},
@@ -886,14 +1263,14 @@ var LioranDB = class _LioranDB {
       this.saveMeta();
       return;
     }
-    this.meta = JSON.parse(fs4.readFileSync(this.metaPath, "utf8"));
+    this.meta = JSON.parse(fs6.readFileSync(this.metaPath, "utf8"));
     if (!this.meta.schemaVersion) {
       this.meta.schemaVersion = DEFAULT_SCHEMA_VERSION;
       this.saveMeta();
     }
   }
   saveMeta() {
-    fs4.writeFileSync(this.metaPath, JSON.stringify(this.meta, null, 2));
+    fs6.writeFileSync(this.metaPath, JSON.stringify(this.meta, null, 2));
   }
   getSchemaVersion() {
     return this.meta.schemaVersion;
@@ -912,44 +1289,7 @@ var LioranDB = class _LioranDB {
   async applyMigrations(targetVersion) {
     await this.migrator.upgradeToLatest();
   }
-  /* ------------------------- WAL ------------------------- */
-  async writeWAL(entries) {
-    const fd = await fs4.promises.open(this.walPath, "a");
-    for (const e of entries) {
-      await fd.write(JSON.stringify(e) + "\n");
-    }
-    await fd.sync();
-    await fd.close();
-  }
-  async clearWAL() {
-    try {
-      await fs4.promises.unlink(this.walPath);
-    } catch {
-    }
-  }
-  async recoverFromWAL() {
-    if (!fs4.existsSync(this.walPath)) return;
-    const raw = await fs4.promises.readFile(this.walPath, "utf8");
-    const committed = /* @__PURE__ */ new Set();
-    const applied = /* @__PURE__ */ new Set();
-    const ops = /* @__PURE__ */ new Map();
-    for (const line of raw.split("\n")) {
-      if (!line.trim()) continue;
-      const entry = JSON.parse(line);
-      if ("commit" in entry) committed.add(entry.tx);
-      else if ("applied" in entry) applied.add(entry.tx);
-      else {
-        if (!ops.has(entry.tx)) ops.set(entry.tx, []);
-        ops.get(entry.tx).push(entry);
-      }
-    }
-    for (const tx of committed) {
-      if (applied.has(tx)) continue;
-      const txOps = ops.get(tx);
-      if (txOps) await this.applyTransaction(txOps);
-    }
-    await this.clearWAL();
-  }
+  /* ------------------------- TX APPLY ------------------------- */
   async applyTransaction(ops) {
     for (const { col, op, args } of ops) {
       const collection = this.collection(col);
@@ -965,8 +1305,8 @@ var LioranDB = class _LioranDB {
       }
       return col2;
     }
-    const colPath = path4.join(this.basePath, name);
-    fs4.mkdirSync(colPath, { recursive: true });
+    const colPath = path6.join(this.basePath, name);
+    fs6.mkdirSync(colPath, { recursive: true });
     const col = new Collection(
       colPath,
       schema,
@@ -1004,12 +1344,10 @@ var LioranDB = class _LioranDB {
   }
   /* ------------------------- COMPACTION ------------------------- */
   async compactCollection(name) {
-    await this.clearWAL();
     const col = this.collection(name);
     await col.compact();
   }
   async compactAll() {
-    await this.clearWAL();
     for (const name of this.collections.keys()) {
       await this.compactCollection(name);
     }
@@ -1022,6 +1360,9 @@ var LioranDB = class _LioranDB {
     await tx.commit();
     return result;
   }
+  /* ------------------------- POST COMMIT ------------------------- */
+  async postCommitMaintenance() {
+  }
   /* ------------------------- SHUTDOWN ------------------------- */
   async close() {
     for (const col of this.collections.values()) {
@@ -1036,15 +1377,15 @@ var LioranDB = class _LioranDB {
 
 // src/utils/rootpath.ts
 import os2 from "os";
-import path5 from "path";
-import fs5 from "fs";
+import path7 from "path";
+import fs7 from "fs";
 function getDefaultRootPath() {
   let dbPath = process.env.LIORANDB_PATH;
   if (!dbPath) {
     const homeDir = os2.homedir();
-    dbPath = path5.join(homeDir, "LioranDB", "db");
-    if (!fs5.existsSync(dbPath)) {
-      fs5.mkdirSync(dbPath, { recursive: true });
+    dbPath = path7.join(homeDir, "LioranDB", "db");
+    if (!fs7.existsSync(dbPath)) {
+      fs7.mkdirSync(dbPath, { recursive: true });
     }
     process.env.LIORANDB_PATH = dbPath;
   }
@@ -1059,24 +1400,24 @@ import net from "net";
 
 // src/ipc/socketPath.ts
 import os3 from "os";
-import path6 from "path";
+import path8 from "path";
 function getIPCSocketPath(rootPath) {
   if (os3.platform() === "win32") {
     return `\\\\.\\pipe\\liorandb_${rootPath.replace(/[:\\\/]/g, "_")}`;
   }
-  return path6.join(rootPath, ".lioran.sock");
+  return path8.join(rootPath, ".lioran.sock");
 }
 
 // src/ipc/client.ts
 function delay(ms) {
   return new Promise((r) => setTimeout(r, ms));
 }
-async function connectWithRetry(path8) {
+async function connectWithRetry(path10) {
   let attempt = 0;
   while (true) {
     try {
       return await new Promise((resolve, reject) => {
-        const socket = net.connect(path8, () => resolve(socket));
+        const socket = net.connect(path10, () => resolve(socket));
         socket.once("error", reject);
       });
     } catch (err) {
@@ -1159,11 +1500,11 @@ var DBQueue = class {
     return this.exec("compact:all", {});
   }
   /* ----------------------------- SNAPSHOT API ----------------------------- */
-  snapshot(path8) {
-    return this.exec("snapshot", { path: path8 });
+  snapshot(path10) {
+    return this.exec("snapshot", { path: path10 });
   }
-  restore(path8) {
-    return this.exec("restore", { path: path8 });
+  restore(path10) {
+    return this.exec("restore", { path: path10 });
   }
   /* ------------------------------ SHUTDOWN ------------------------------ */
   async shutdown() {
@@ -1178,7 +1519,7 @@ var dbQueue = new DBQueue();
 
 // src/ipc/server.ts
 import net2 from "net";
-import fs6 from "fs";
+import fs8 from "fs";
 var IPCServer = class {
   server;
   manager;
@@ -1189,7 +1530,7 @@ var IPCServer = class {
   }
   start() {
     if (!this.socketPath.startsWith("\\\\.\\")) {
-      if (fs6.existsSync(this.socketPath)) fs6.unlinkSync(this.socketPath);
+      if (fs8.existsSync(this.socketPath)) fs8.unlinkSync(this.socketPath);
     }
     this.server = net2.createServer((socket) => {
       let buffer = "";
@@ -1291,7 +1632,7 @@ var IPCServer = class {
     if (this.server) this.server.close();
     if (!this.socketPath.startsWith("\\\\.\\")) {
       try {
-        fs6.unlinkSync(this.socketPath);
+        fs8.unlinkSync(this.socketPath);
       } catch {
       }
     }
@@ -1309,8 +1650,8 @@ var LioranManager = class {
   constructor(options = {}) {
     const { rootPath, encryptionKey } = options;
     this.rootPath = rootPath || getDefaultRootPath();
-    if (!fs7.existsSync(this.rootPath)) {
-      fs7.mkdirSync(this.rootPath, { recursive: true });
+    if (!fs9.existsSync(this.rootPath)) {
+      fs9.mkdirSync(this.rootPath, { recursive: true });
     }
     if (encryptionKey) {
       setEncryptionKey(encryptionKey);
@@ -1333,18 +1674,18 @@ var LioranManager = class {
     }
   }
   tryAcquireLock() {
-    const lockPath = path7.join(this.rootPath, ".lioran.lock");
+    const lockPath = path9.join(this.rootPath, ".lioran.lock");
     try {
-      this.lockFd = fs7.openSync(lockPath, "wx");
-      fs7.writeSync(this.lockFd, String(process2.pid));
+      this.lockFd = fs9.openSync(lockPath, "wx");
+      fs9.writeSync(this.lockFd, String(process2.pid));
       return true;
     } catch {
       try {
-        const pid = Number(fs7.readFileSync(lockPath, "utf8"));
+        const pid = Number(fs9.readFileSync(lockPath, "utf8"));
         if (!this.isProcessAlive(pid)) {
-          fs7.unlinkSync(lockPath);
-          this.lockFd = fs7.openSync(lockPath, "wx");
-          fs7.writeSync(this.lockFd, String(process2.pid));
+          fs9.unlinkSync(lockPath);
+          this.lockFd = fs9.openSync(lockPath, "wx");
+          fs9.writeSync(this.lockFd, String(process2.pid));
           return true;
         }
       } catch {
@@ -1365,8 +1706,8 @@ var LioranManager = class {
     if (this.openDBs.has(name)) {
       return this.openDBs.get(name);
     }
-    const dbPath = path7.join(this.rootPath, name);
-    await fs7.promises.mkdir(dbPath, { recursive: true });
+    const dbPath = path9.join(this.rootPath, name);
+    await fs9.promises.mkdir(dbPath, { recursive: true });
     const db = new LioranDB(dbPath, name, this);
     this.openDBs.set(name, db);
     return db;
@@ -1387,7 +1728,7 @@ var LioranManager = class {
         }
       }
     }
-    fs7.mkdirSync(path7.dirname(snapshotPath), { recursive: true });
+    fs9.mkdirSync(path9.dirname(snapshotPath), { recursive: true });
     const tar = await import("tar");
     await tar.c({
       gzip: true,
@@ -1405,8 +1746,8 @@ var LioranManager = class {
       return dbQueue.exec("restore", { path: snapshotPath });
     }
     await this.closeAll();
-    fs7.rmSync(this.rootPath, { recursive: true, force: true });
-    fs7.mkdirSync(this.rootPath, { recursive: true });
+    fs9.rmSync(this.rootPath, { recursive: true, force: true });
+    fs9.mkdirSync(this.rootPath, { recursive: true });
     const tar = await import("tar");
     await tar.x({
       file: snapshotPath,
@@ -1431,8 +1772,8 @@ var LioranManager = class {
     }
     this.openDBs.clear();
     try {
-      if (this.lockFd) fs7.closeSync(this.lockFd);
-      fs7.unlinkSync(path7.join(this.rootPath, ".lioran.lock"));
+      if (this.lockFd) fs9.closeSync(this.lockFd);
+      fs9.unlinkSync(path9.join(this.rootPath, ".lioran.lock"));
     } catch {
     }
     await this.ipcServer?.close();