@liorandb/core 1.1.0 → 1.1.1

package/dist/chunk-2FSI7HX7.js

@@ -0,0 +1,1689 @@
+// src/core/database.ts
+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, path9) {
+  return path9.split(".").reduce((o, p) => o ? o[p] : void 0, obj);
+}
+function matchDocument(doc, query) {
+  for (const key of Object.keys(query)) {
+    const cond = query[key];
+    const val = getByPath(doc, key);
+    if (cond && typeof cond === "object" && !Array.isArray(cond)) {
+      for (const op of Object.keys(cond)) {
+        const v = cond[op];
+        if (op === "$gt" && !(val > v)) return false;
+        if (op === "$gte" && !(val >= v)) return false;
+        if (op === "$lt" && !(val < v)) return false;
+        if (op === "$lte" && !(val <= v)) return false;
+        if (op === "$ne" && val === v) return false;
+        if (op === "$eq" && val !== v) return false;
+        if (op === "$in" && (!Array.isArray(v) || !v.includes(val))) return false;
+      }
+    } else {
+      if (val !== cond) return false;
+    }
+  }
+  return true;
+}
+function applyUpdate(oldDoc, update) {
+  const doc = structuredClone(oldDoc);
+  if (update.$set) {
+    for (const k in update.$set) {
+      const parts = k.split(".");
+      let cur = doc;
+      for (let i = 0; i < parts.length - 1; i++) {
+        cur[parts[i]] ??= {};
+        cur = cur[parts[i]];
+      }
+      cur[parts.at(-1)] = update.$set[k];
+    }
+  }
+  if (update.$inc) {
+    for (const k in update.$inc) {
+      const val = getByPath(doc, k) ?? 0;
+      const parts = k.split(".");
+      let cur = doc;
+      for (let i = 0; i < parts.length - 1; i++) {
+        cur[parts[i]] ??= {};
+        cur = cur[parts[i]];
+      }
+      cur[parts.at(-1)] = val + update.$inc[k];
+    }
+  }
+  const hasOp = Object.keys(update).some((k) => k.startsWith("$"));
+  if (!hasOp) {
+    return { ...doc, ...update };
+  }
+  return doc;
+}
+function selectIndex(query, indexes) {
+  for (const key of Object.keys(query)) {
+    if (!indexes.has(key)) continue;
+    const cond = query[key];
+    if (cond && typeof cond === "object" && !Array.isArray(cond)) {
+      return { field: key, cond };
+    }
+    return { field: key, cond: { $eq: cond } };
+  }
+  return null;
+}
+async function runIndexedQuery(query, indexProvider, allDocIds) {
+  const indexes = indexProvider.indexes;
+  if (!indexes?.size) {
+    return new Set(await allDocIds());
+  }
+  const sel = selectIndex(query, indexes);
+  if (!sel) {
+    return new Set(await allDocIds());
+  }
+  const { field, cond } = sel;
+  if ("$eq" in cond) {
+    return await indexProvider.findByIndex(field, cond.$eq) ?? new Set(await allDocIds());
+  }
+  if ("$in" in cond) {
+    const out = /* @__PURE__ */ new Set();
+    for (const v of cond.$in) {
+      const r = await indexProvider.findByIndex(field, v);
+      if (r) for (const id of r) out.add(id);
+    }
+    return out;
+  }
+  if (indexProvider.rangeByIndex && ("$gt" in cond || "$gte" in cond || "$lt" in cond || "$lte" in cond)) {
+    return await indexProvider.rangeByIndex(field, cond) ?? new Set(await allDocIds());
+  }
+  return new Set(await allDocIds());
+}
+
+// src/core/collection.ts
+import { v4 as uuid } from "uuid";
+
+// src/utils/encryption.ts
+import crypto2 from "crypto";
+
+// src/utils/secureKey.ts
+import crypto from "crypto";
+import os from "os";
+function getMasterKey() {
+  const fingerprint = [
+    os.hostname(),
+    os.platform(),
+    os.arch(),
+    os.cpus()?.[0]?.model ?? "unknown",
+    os.cpus()?.length ?? 0,
+    os.totalmem()
+  ].join("|");
+  return crypto.createHash("sha256").update(fingerprint).digest();
+}
+
+// src/utils/encryption.ts
+var algorithm = "aes-256-gcm";
+var ACTIVE_KEY = getMasterKey();
+function setEncryptionKey(key) {
+  if (!key) return;
+  if (typeof key === "string") {
+    ACTIVE_KEY = crypto2.createHash("sha256").update(key).digest();
+    return;
+  }
+  if (Buffer.isBuffer(key)) {
+    if (key.length !== 32) {
+      throw new Error("Encryption key must be 32 bytes");
+    }
+    ACTIVE_KEY = key;
+    return;
+  }
+  throw new Error("Invalid encryption key format");
+}
+function encryptData(obj) {
+  const iv = crypto2.randomBytes(16);
+  const json = JSON.stringify(obj);
+  if (json.length > 5e6) {
+    throw new Error("Document too large (>5MB)");
+  }
+  const data = Buffer.from(json, "utf8");
+  const cipher = crypto2.createCipheriv(algorithm, ACTIVE_KEY, iv);
+  const encrypted = Buffer.concat([cipher.update(data), cipher.final()]);
+  const tag = cipher.getAuthTag();
+  return Buffer.concat([iv, tag, encrypted]).toString("base64");
+}
+function decryptData(enc) {
+  const buf = Buffer.from(enc, "base64");
+  const iv = buf.subarray(0, 16);
+  const tag = buf.subarray(16, 32);
+  const encrypted = buf.subarray(32);
+  const decipher = crypto2.createDecipheriv(algorithm, ACTIVE_KEY, iv);
+  decipher.setAuthTag(tag);
+  const decrypted = Buffer.concat([
+    decipher.update(encrypted),
+    decipher.final()
+  ]);
+  return JSON.parse(decrypted.toString("utf8"));
+}
+
+// src/utils/schema.ts
+function validateSchema(schema, data) {
+  const result = schema.safeParse(data);
+  if (!result.success) {
+    throw new Error(
+      "Schema validation failed:\n" + JSON.stringify(result.error.format(), null, 2)
+    );
+  }
+  return result.data;
+}
+
+// src/core/compaction.ts
+import fs2 from "fs";
+import path2 from "path";
+import { ClassicLevel as ClassicLevel2 } from "classic-level";
+
+// src/core/index.ts
+import path from "path";
+import fs from "fs";
+import { ClassicLevel } from "classic-level";
+var Index = class {
+  field;
+  unique;
+  dir;
+  db;
+  constructor(baseDir, field, options = {}) {
+    this.field = field;
+    this.unique = !!options.unique;
+    this.dir = path.join(baseDir, "__indexes", field + ".idx");
+    fs.mkdirSync(this.dir, { recursive: true });
+    this.db = new ClassicLevel(this.dir, { valueEncoding: "utf8" });
+  }
+  /* ------------------------- INTERNAL ------------------------- */
+  normalizeKey(value) {
+    if (value === null || value === void 0) return "__null__";
+    if (typeof value === "object") {
+      return JSON.stringify(value);
+    }
+    return String(value);
+  }
+  async getRaw(key) {
+    try {
+      const v = await this.db.get(key);
+      if (v === void 0) return null;
+      return JSON.parse(v);
+    } catch {
+      return null;
+    }
+  }
+  async setRaw(key, value) {
+    await this.db.put(key, JSON.stringify(value));
+  }
+  async delRaw(key) {
+    try {
+      await this.db.del(key);
+    } catch {
+    }
+  }
+  /* --------------------------- API --------------------------- */
+  async insert(doc) {
+    const val = doc[this.field];
+    if (val === void 0) return;
+    const key = this.normalizeKey(val);
+    if (this.unique) {
+      const existing = await this.getRaw(key);
+      if (existing) {
+        throw new Error(
+          `Unique index violation on "${this.field}" = ${val}`
+        );
+      }
+      await this.setRaw(key, doc._id);
+      return;
+    }
+    const arr = await this.getRaw(key);
+    if (!arr) {
+      await this.setRaw(key, [doc._id]);
+    } else {
+      if (!arr.includes(doc._id)) {
+        arr.push(doc._id);
+        await this.setRaw(key, arr);
+      }
+    }
+  }
+  async delete(doc) {
+    const val = doc[this.field];
+    if (val === void 0) return;
+    const key = this.normalizeKey(val);
+    if (this.unique) {
+      await this.delRaw(key);
+      return;
+    }
+    const arr = await this.getRaw(key);
+    if (!arr) return;
+    const next = arr.filter((id) => id !== doc._id);
+    if (next.length === 0) {
+      await this.delRaw(key);
+    } else {
+      await this.setRaw(key, next);
+    }
+  }
+  async update(oldDoc, newDoc) {
+    const oldVal = oldDoc?.[this.field];
+    const newVal = newDoc?.[this.field];
+    if (oldVal === newVal) return;
+    if (oldDoc) await this.delete(oldDoc);
+    if (newDoc) await this.insert(newDoc);
+  }
+  async find(value) {
+    const key = this.normalizeKey(value);
+    const raw = await this.getRaw(key);
+    if (!raw) return [];
+    if (this.unique) return [raw];
+    return raw;
+  }
+  async close() {
+    try {
+      await this.db.close();
+    } catch {
+    }
+  }
+};
+
+// src/core/compaction.ts
+var TMP_SUFFIX = "__compact_tmp";
+var OLD_SUFFIX = "__compact_old";
+var INDEX_DIR = "__indexes";
+async function compactCollectionEngine(col) {
+  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);
+  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"
+  });
+  for await (const [key, val] of col.db.iterator()) {
+    if (val !== void 0) {
+      await tmpDB.put(key, val);
+    }
+  }
+  await tmpDB.close();
+  await col.db.close();
+}
+async function atomicSwap(base, tmp, old) {
+  fs2.renameSync(base, old);
+  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;
+  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 (!baseExists && oldExists) {
+    fs2.renameSync(old, baseDir);
+    return;
+  }
+  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, INDEX_DIR);
+  const oldIndexes = new Map(col["indexes"]);
+  for (const idx of oldIndexes.values()) {
+    try {
+      await idx.close();
+    } catch {
+    }
+  }
+  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()) {
+      if (!enc) continue;
+      try {
+        const doc = decryptData(enc);
+        await rebuilt.insert(doc);
+      } catch {
+      }
+    }
+    rebuiltIndexes.set(idx.field, rebuilt);
+  }
+  col["indexes"] = rebuiltIndexes;
+}
+function safeRemove(p) {
+  if (fs2.existsSync(p)) {
+    fs2.rmSync(p, { recursive: true, force: true });
+  }
+}
+
+// src/core/collection.ts
+var Collection = class {
+  dir;
+  db;
+  queue = Promise.resolve();
+  schema;
+  schemaVersion = 1;
+  migrations = [];
+  indexes = /* @__PURE__ */ new Map();
+  readonlyMode;
+  constructor(dir, schema, schemaVersion = 1, options) {
+    this.dir = dir;
+    this.schema = schema;
+    this.schemaVersion = schemaVersion;
+    this.readonlyMode = options?.readonly ?? false;
+    this.db = new ClassicLevel3(dir, {
+      valueEncoding: "utf8",
+      readOnly: this.readonlyMode
+    });
+  }
+  /* ===================== INTERNAL ===================== */
+  assertWritable() {
+    if (this.readonlyMode) {
+      throw new Error("Collection is in readonly replica mode");
+    }
+  }
+  /* ===================== SCHEMA ===================== */
+  setSchema(schema, version) {
+    this.schema = schema;
+    this.schemaVersion = version;
+  }
+  addMigration(migration) {
+    this.migrations.push(migration);
+    this.migrations.sort((a, b) => a.from - b.from);
+  }
+  validate(doc) {
+    return this.schema ? validateSchema(this.schema, doc) : doc;
+  }
+  migrateIfNeeded(doc) {
+    let currentVersion = doc.__v ?? 1;
+    if (currentVersion === this.schemaVersion) {
+      return doc;
+    }
+    let working = doc;
+    for (const migration of this.migrations) {
+      if (migration.from === currentVersion) {
+        working = migration.migrate(working);
+        currentVersion = migration.to;
+      }
+    }
+    working.__v = this.schemaVersion;
+    return this.validate(working);
+  }
+  /* ===================== QUEUE ===================== */
+  _enqueue(task) {
+    this.queue = this.queue.then(task).catch(console.error);
+    return this.queue;
+  }
+  async close() {
+    for (const idx of this.indexes.values()) {
+      try {
+        await idx.close();
+      } catch {
+      }
+    }
+    try {
+      await this.db.close();
+    } catch {
+    }
+  }
+  /* ===================== INDEX MANAGEMENT ===================== */
+  registerIndex(index) {
+    this.indexes.set(index.field, index);
+  }
+  getIndex(field) {
+    return this.indexes.get(field);
+  }
+  async _updateIndexes(oldDoc, newDoc) {
+    if (this.readonlyMode) return;
+    for (const index of this.indexes.values()) {
+      await index.update(oldDoc, newDoc);
+    }
+  }
+  /* ===================== COMPACTION ===================== */
+  async compact() {
+    this.assertWritable();
+    return this._enqueue(async () => {
+      try {
+        await this.db.close();
+      } catch {
+      }
+      await compactCollectionEngine(this);
+      this.db = new ClassicLevel3(this.dir, { valueEncoding: "utf8" });
+      await rebuildIndexes(this);
+    });
+  }
+  /* ===================== INTERNAL EXEC ===================== */
+  async _exec(op, args) {
+    switch (op) {
+      case "insertOne":
+        return this._insertOne(args[0]);
+      case "insertMany":
+        return this._insertMany(args[0]);
+      case "find":
+        return this._find(args[0]);
+      case "findOne":
+        return this._findOne(args[0]);
+      case "updateOne":
+        return this._updateOne(args[0], args[1], args[2]);
+      case "updateMany":
+        return this._updateMany(args[0], args[1]);
+      case "deleteOne":
+        return this._deleteOne(args[0]);
+      case "deleteMany":
+        return this._deleteMany(args[0]);
+      case "countDocuments":
+        return this._countDocuments(args[0]);
+      default:
+        throw new Error(`Unknown operation: ${op}`);
+    }
+  }
+  /* ===================== STORAGE ===================== */
+  async _insertOne(doc) {
+    this.assertWritable();
+    const _id = doc._id ?? uuid();
+    const final = this.validate({
+      _id,
+      ...doc,
+      __v: this.schemaVersion
+    });
+    await this.db.put(String(_id), encryptData(final));
+    await this._updateIndexes(null, final);
+    return final;
+  }
+  async _insertMany(docs) {
+    this.assertWritable();
+    const batch = [];
+    const out = [];
+    for (const d of docs) {
+      const _id = d._id ?? uuid();
+      const final = this.validate({
+        _id,
+        ...d,
+        __v: this.schemaVersion
+      });
+      batch.push({
+        type: "put",
+        key: String(_id),
+        value: encryptData(final)
+      });
+      out.push(final);
+    }
+    await this.db.batch(batch);
+    for (const doc of out) {
+      await this._updateIndexes(null, doc);
+    }
+    return out;
+  }
+  /* ===================== QUERY ===================== */
+  async _getCandidateIds(query) {
+    const indexedFields = new Set(this.indexes.keys());
+    return runIndexedQuery(
+      query,
+      {
+        indexes: indexedFields,
+        findByIndex: async (field, value) => {
+          const idx = this.indexes.get(field);
+          if (!idx) return null;
+          return new Set(await idx.find(value));
+        }
+      },
+      async () => {
+        const ids = [];
+        for await (const [key] of this.db.iterator()) {
+          ids.push(key);
+        }
+        return ids;
+      }
+    );
+  }
+  async _readAndMigrate(id) {
+    const enc = await this.db.get(id).catch(() => null);
+    if (!enc) return null;
+    const raw = decryptData(enc);
+    const migrated = this.migrateIfNeeded(raw);
+    if (!this.readonlyMode && raw.__v !== this.schemaVersion) {
+      await this.db.put(id, encryptData(migrated));
+      await this._updateIndexes(raw, migrated);
+    }
+    return migrated;
+  }
+  async _find(query) {
+    const ids = await this._getCandidateIds(query);
+    const out = [];
+    for (const id of ids) {
+      try {
+        const doc = await this._readAndMigrate(id);
+        if (doc && matchDocument(doc, query)) {
+          out.push(doc);
+        }
+      } catch {
+      }
+    }
+    return out;
+  }
+  async _findOne(query) {
+    if (query?._id) {
+      return this._readAndMigrate(String(query._id));
+    }
+    const ids = await this._getCandidateIds(query);
+    for (const id of ids) {
+      try {
+        const doc = await this._readAndMigrate(id);
+        if (doc && matchDocument(doc, query)) {
+          return doc;
+        }
+      } catch {
+      }
+    }
+    return null;
+  }
+  async _countDocuments(filter) {
+    const ids = await this._getCandidateIds(filter);
+    let count = 0;
+    for (const id of ids) {
+      try {
+        const doc = await this._readAndMigrate(id);
+        if (doc && matchDocument(doc, filter)) {
+          count++;
+        }
+      } catch {
+      }
+    }
+    return count;
+  }
+  /* ===================== UPDATE ===================== */
+  async _updateOne(filter, update, options) {
+    this.assertWritable();
+    const ids = await this._getCandidateIds(filter);
+    for (const id of ids) {
+      const existing = await this._readAndMigrate(id);
+      if (!existing) continue;
+      if (matchDocument(existing, filter)) {
+        const updated = this.validate({
+          ...applyUpdate(existing, update),
+          _id: existing._id,
+          __v: this.schemaVersion
+        });
+        await this.db.put(id, encryptData(updated));
+        await this._updateIndexes(existing, updated);
+        return updated;
+      }
+    }
+    if (options?.upsert) {
+      return this._insertOne(applyUpdate({}, update));
+    }
+    return null;
+  }
+  async _updateMany(filter, update) {
+    this.assertWritable();
+    const ids = await this._getCandidateIds(filter);
+    const out = [];
+    for (const id of ids) {
+      const existing = await this._readAndMigrate(id);
+      if (!existing) continue;
+      if (matchDocument(existing, filter)) {
+        const updated = this.validate({
+          ...applyUpdate(existing, update),
+          _id: existing._id,
+          __v: this.schemaVersion
+        });
+        await this.db.put(id, encryptData(updated));
+        await this._updateIndexes(existing, updated);
+        out.push(updated);
+      }
+    }
+    return out;
+  }
+  /* ===================== DELETE ===================== */
+  async _deleteOne(filter) {
+    this.assertWritable();
+    const ids = await this._getCandidateIds(filter);
+    for (const id of ids) {
+      const existing = await this._readAndMigrate(id);
+      if (!existing) continue;
+      if (matchDocument(existing, filter)) {
+        await this.db.del(id);
+        await this._updateIndexes(existing, null);
+        return true;
+      }
+    }
+    return false;
+  }
+  async _deleteMany(filter) {
+    this.assertWritable();
+    const ids = await this._getCandidateIds(filter);
+    let count = 0;
+    for (const id of ids) {
+      const existing = await this._readAndMigrate(id);
+      if (!existing) continue;
+      if (matchDocument(existing, filter)) {
+        await this.db.del(id);
+        await this._updateIndexes(existing, null);
+        count++;
+      }
+    }
+    return count;
+  }
+  /* ===================== PUBLIC API ===================== */
+  insertOne(doc) {
+    return this._enqueue(() => this._exec("insertOne", [doc]));
+  }
+  insertMany(docs) {
+    return this._enqueue(() => this._exec("insertMany", [docs]));
+  }
+  find(query = {}) {
+    return this._enqueue(() => this._exec("find", [query]));
+  }
+  findOne(query = {}) {
+    return this._enqueue(() => this._exec("findOne", [query]));
+  }
+  updateOne(filter, update, options) {
+    return this._enqueue(
+      () => this._exec("updateOne", [filter, update, options])
+    );
+  }
+  updateMany(filter, update) {
+    return this._enqueue(
+      () => this._exec("updateMany", [filter, update])
+    );
+  }
+  deleteOne(filter) {
+    return this._enqueue(
+      () => this._exec("deleteOne", [filter])
+    );
+  }
+  deleteMany(filter) {
+    return this._enqueue(
+      () => this._exec("deleteMany", [filter])
+    );
+  }
+  countDocuments(filter = {}) {
+    return this._enqueue(
+      () => this._exec("countDocuments", [filter])
+    );
+  }
+};
+
+// src/core/migration.ts
+import fs3 from "fs";
+import path3 from "path";
+import crypto3 from "crypto";
+var LOCK_FILE = "__migration.lock";
+var HISTORY_FILE = "__migration_history.json";
+var MigrationEngine = class {
+  constructor(db) {
+    this.db = db;
+  }
+  migrations = /* @__PURE__ */ new Map();
+  /* ------------------------------------------------------------ */
+  /* Public API */
+  /* ------------------------------------------------------------ */
+  register(from, to, fn) {
+    const key = `${from}\u2192${to}`;
+    if (this.migrations.has(key)) {
+      throw new Error(`Duplicate migration: ${key}`);
+    }
+    this.migrations.set(key, fn);
+  }
+  async migrate(from, to, fn) {
+    this.register(from, to, fn);
+    await this.execute();
+  }
+  async upgradeToLatest() {
+    await this.execute();
+  }
+  /* ------------------------------------------------------------ */
+  /* Core Execution Logic */
+  /* ------------------------------------------------------------ */
+  async execute() {
+    let current = this.db.getSchemaVersion();
+    while (true) {
+      const next = this.findNext(current);
+      if (!next) break;
+      const fn = this.migrations.get(`${current}\u2192${next}`);
+      await this.runMigration(current, next, fn);
+      current = next;
+    }
+  }
+  findNext(current) {
+    for (const key of this.migrations.keys()) {
+      const [from, to] = key.split("\u2192");
+      if (from === current) return to;
+    }
+    return null;
+  }
+  /* ------------------------------------------------------------ */
+  /* Atomic Migration Execution */
+  /* ------------------------------------------------------------ */
+  async runMigration(from, to, fn) {
+    const current = this.db.getSchemaVersion();
+    if (current !== from) {
+      throw new Error(
+        `Schema mismatch: DB=${current}, expected=${from}`
+      );
+    }
+    const lockPath = path3.join(this.db.basePath, LOCK_FILE);
+    if (fs3.existsSync(lockPath)) {
+      throw new Error(
+        "Previous migration interrupted. Resolve manually before continuing."
+      );
+    }
+    this.acquireLock(lockPath);
+    try {
+      await this.db.transaction(async () => {
+        await fn(this.db);
+        this.writeHistory(from, to, fn);
+        this.db.setSchemaVersion(to);
+      });
+    } finally {
+      this.releaseLock(lockPath);
+    }
+  }
+  /* ------------------------------------------------------------ */
+  /* Locking */
+  /* ------------------------------------------------------------ */
+  acquireLock(file) {
+    const token = crypto3.randomBytes(16).toString("hex");
+    fs3.writeFileSync(
+      file,
+      JSON.stringify({
+        pid: process.pid,
+        token,
+        time: Date.now()
+      })
+    );
+  }
+  releaseLock(file) {
+    if (fs3.existsSync(file)) fs3.unlinkSync(file);
+  }
+  /* ------------------------------------------------------------ */
+  /* Migration History */
+  /* ------------------------------------------------------------ */
+  historyPath() {
+    return path3.join(this.db.basePath, HISTORY_FILE);
+  }
+  readHistory() {
+    if (!fs3.existsSync(this.historyPath())) return [];
+    return JSON.parse(fs3.readFileSync(this.historyPath(), "utf8"));
+  }
+  writeHistory(from, to, fn) {
+    const history = this.readHistory();
+    history.push({
+      from,
+      to,
+      checksum: this.hash(fn.toString()),
+      appliedAt: Date.now()
+    });
+    fs3.writeFileSync(this.historyPath(), JSON.stringify(history, null, 2));
+  }
+  hash(data) {
+    return crypto3.createHash("sha256").update(data).digest("hex");
+  }
+  /* ------------------------------------------------------------ */
+  /* Diagnostics */
+  /* ------------------------------------------------------------ */
+  getHistory() {
+    return this.readHistory();
+  }
+};
+
+// 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;
+  readonlyMode;
+  constructor(baseDir, options) {
+    this.walDir = path4.join(baseDir, WAL_DIR);
+    this.readonlyMode = options?.readonly ?? false;
+    if (!this.readonlyMode) {
+      fs4.mkdirSync(this.walDir, { recursive: true });
+    }
+    if (fs4.existsSync(this.walDir)) {
+      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() {
+    if (!fs4.existsSync(this.walDir)) return [];
+    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.readonlyMode) {
+      throw new Error("WAL is in readonly replica mode");
+    }
+    if (!this.fd) {
+      this.fd = await fs4.promises.open(this.walPath(), "a");
+    }
+  }
+  async rotate() {
+    if (this.readonlyMode) return;
+    if (this.fd) {
+      await this.fd.sync();
+      await this.fd.close();
+      this.fd = null;
+    }
+    this.currentGen++;
+  }
+  /* -------------------------
+     APPEND (Primary only)
+  ------------------------- */
+  async append(record) {
+    if (this.readonlyMode) {
+      throw new Error("Cannot append WAL in readonly replica mode");
+    }
+    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 (Replica allowed)
+  ------------------------- */
+  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,
+        this.readonlyMode ? "r" : "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);
+      }
+      if (!this.readonlyMode) {
+        const stat = fs4.fstatSync(fd);
+        if (validOffset < stat.size) {
+          fs4.ftruncateSync(fd, validOffset);
+        }
+      }
+      fs4.closeSync(fd);
+    }
+  }
+  /* -------------------------
+     CLEANUP (Primary only)
+  ------------------------- */
+  async cleanup(beforeGen) {
+    if (this.readonlyMode) return;
+    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;
+  }
+  isReadonly() {
+    return this.readonlyMode;
+  }
+};
+
+// 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 META_FILE = "__db_meta.json";
+var META_VERSION = 2;
+var DEFAULT_SCHEMA_VERSION = "v1";
+var DBTransactionContext = class {
+  constructor(db, txId) {
+    this.db = db;
+    this.txId = txId;
+  }
+  ops = [];
+  collection(name) {
+    return new Proxy(
+      {},
+      {
+        get: (_, prop) => {
+          return (...args) => {
+            this.ops.push({
+              tx: this.txId,
+              col: name,
+              op: prop,
+              args
+            });
+          };
+        }
+      }
+    );
+  }
+  async commit() {
+    if (this.db.isReadonly()) {
+      throw new Error("Cannot commit transaction in readonly mode");
+    }
+    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);
+    const appliedLSN = await this.db.wal.append({
+      tx: this.txId,
+      type: "applied"
+    });
+    this.db.advanceCheckpoint(appliedLSN);
+    await this.db.postCommitMaintenance();
+  }
+};
+var LioranDB = class _LioranDB {
+  basePath;
+  dbName;
+  manager;
+  collections;
+  metaPath;
+  meta;
+  migrator;
+  static TX_SEQ = 0;
+  wal;
+  checkpoint;
+  readonlyMode;
+  constructor(basePath, dbName, manager) {
+    this.basePath = basePath;
+    this.dbName = dbName;
+    this.manager = manager;
+    this.collections = /* @__PURE__ */ new Map();
+    this.readonlyMode = manager?.isReadonly?.() ?? false;
+    this.metaPath = path6.join(basePath, META_FILE);
+    fs6.mkdirSync(basePath, { recursive: true });
+    this.loadMeta();
+    if (!this.readonlyMode) {
+      this.wal = new WALManager(basePath);
+      this.checkpoint = new CheckpointManager(basePath);
+    }
+    this.migrator = new MigrationEngine(this);
+    this.initialize().catch(console.error);
+  }
+  /* ------------------------- MODE ------------------------- */
+  isReadonly() {
+    return this.readonlyMode;
+  }
+  assertWritable() {
+    if (this.readonlyMode) {
+      throw new Error("Database is in readonly replica mode");
+    }
+  }
+  /* ------------------------- INIT & RECOVERY ------------------------- */
+  async initialize() {
+    if (!this.readonlyMode) {
+      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) {
+    if (this.readonlyMode) return;
+    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 (!fs6.existsSync(this.metaPath)) {
+      this.meta = {
+        version: META_VERSION,
+        indexes: {},
+        schemaVersion: DEFAULT_SCHEMA_VERSION
+      };
+      this.saveMeta();
+      return;
+    }
+    this.meta = JSON.parse(fs6.readFileSync(this.metaPath, "utf8"));
+    if (!this.meta.schemaVersion) {
+      this.meta.schemaVersion = DEFAULT_SCHEMA_VERSION;
+      this.saveMeta();
+    }
+  }
+  saveMeta() {
+    if (this.readonlyMode) return;
+    fs6.writeFileSync(this.metaPath, JSON.stringify(this.meta, null, 2));
+  }
+  getSchemaVersion() {
+    return this.meta.schemaVersion;
+  }
+  setSchemaVersion(v) {
+    this.assertWritable();
+    this.meta.schemaVersion = v;
+    this.saveMeta();
+  }
+  /* ------------------------- DB MIGRATIONS ------------------------- */
+  migrate(from, to, fn) {
+    this.assertWritable();
+    this.migrator.register(from, to, async (db) => {
+      await fn(db);
+      db.setSchemaVersion(to);
+    });
+  }
+  async applyMigrations(targetVersion) {
+    this.assertWritable();
+    await this.migrator.upgradeToLatest();
+  }
+  /* ------------------------- TX APPLY ------------------------- */
+  async applyTransaction(ops) {
+    for (const { col, op, args } of ops) {
+      const collection = this.collection(col);
+      await collection._exec(op, args);
+    }
+  }
+  /* ------------------------- COLLECTION ------------------------- */
+  collection(name, schema, schemaVersion) {
+    if (this.collections.has(name)) {
+      const col2 = this.collections.get(name);
+      if (schema && schemaVersion !== void 0) {
+        col2.setSchema(schema, schemaVersion);
+      }
+      return col2;
+    }
+    const colPath = path6.join(this.basePath, name);
+    fs6.mkdirSync(colPath, { recursive: true });
+    const col = new Collection(
+      colPath,
+      schema,
+      schemaVersion ?? 1,
+      { readonly: this.readonlyMode }
+    );
+    const metas = this.meta.indexes[name] ?? [];
+    for (const m of metas) {
+      col.registerIndex(new Index(colPath, m.field, m.options));
+    }
+    this.collections.set(name, col);
+    return col;
+  }
+  /* ------------------------- INDEX API ------------------------- */
+  async createIndex(collection, field, options = {}) {
+    this.assertWritable();
+    const col = this.collection(collection);
+    const existing = this.meta.indexes[collection]?.find((i) => i.field === field);
+    if (existing) return;
+    const index = new Index(col.dir, field, options);
+    for await (const [key, enc] of col.db.iterator()) {
+      if (!enc) continue;
+      try {
+        const doc = decryptData(enc);
+        await index.insert(doc);
+      } catch {
+      }
+    }
+    col.registerIndex(index);
+    if (!this.meta.indexes[collection]) {
+      this.meta.indexes[collection] = [];
+    }
+    this.meta.indexes[collection].push({ field, options });
+    this.saveMeta();
+  }
+  /* ------------------------- COMPACTION ------------------------- */
+  async compactCollection(name) {
+    this.assertWritable();
+    const col = this.collection(name);
+    await col.compact();
+  }
+  async compactAll() {
+    this.assertWritable();
+    for (const name of this.collections.keys()) {
+      await this.compactCollection(name);
+    }
+  }
+  /* ------------------------- TX API ------------------------- */
+  async transaction(fn) {
+    this.assertWritable();
+    const txId = ++_LioranDB.TX_SEQ;
+    const tx = new DBTransactionContext(this, txId);
+    const result = await fn(tx);
+    await tx.commit();
+    return result;
+  }
+  /* ------------------------- POST COMMIT ------------------------- */
+  async postCommitMaintenance() {
+  }
+  /* ------------------------- SHUTDOWN ------------------------- */
+  async close() {
+    for (const col of this.collections.values()) {
+      try {
+        await col.close();
+      } catch {
+      }
+    }
+    this.collections.clear();
+  }
+};
+
+// src/utils/rootpath.ts
+import os2 from "os";
+import path7 from "path";
+import fs7 from "fs";
+function getDefaultRootPath() {
+  let dbPath = process.env.LIORANDB_PATH;
+  if (!dbPath) {
+    const homeDir = os2.homedir();
+    dbPath = path7.join(homeDir, "LioranDB", "db");
+    if (!fs7.existsSync(dbPath)) {
+      fs7.mkdirSync(dbPath, { recursive: true });
+    }
+    process.env.LIORANDB_PATH = dbPath;
+  }
+  return dbPath;
+}
+function getBaseDBFolder() {
+  return getDefaultRootPath();
+}
+
+// src/LioranManager.ts
+import path8 from "path";
+import fs8 from "fs";
+import process2 from "process";
+var LioranManager = class {
+  rootPath;
+  openDBs;
+  closed = false;
+  mode;
+  lockFd;
+  constructor(options = {}) {
+    const { rootPath, encryptionKey, ipc } = options;
+    this.rootPath = rootPath || getDefaultRootPath();
+    if (!fs8.existsSync(this.rootPath)) {
+      fs8.mkdirSync(this.rootPath, { recursive: true });
+    }
+    if (encryptionKey) {
+      setEncryptionKey(encryptionKey);
+    }
+    this.openDBs = /* @__PURE__ */ new Map();
+    if (ipc === "readonly") {
+      this.mode = "readonly" /* READONLY */;
+    } else if (ipc === "client") {
+      this.mode = "client" /* CLIENT */;
+    } else if (ipc === "primary") {
+      this.mode = "primary" /* PRIMARY */;
+      this.tryAcquireLock();
+    } else {
+      this.mode = this.tryAcquireLock() ? "primary" /* PRIMARY */ : "client" /* CLIENT */;
+    }
+    if (this.mode === "primary" /* PRIMARY */) {
+      this._registerShutdownHooks();
+    }
+  }
+  /* ---------------- MODE HELPERS ---------------- */
+  isPrimary() {
+    return this.mode === "primary" /* PRIMARY */;
+  }
+  isClient() {
+    return this.mode === "client" /* CLIENT */;
+  }
+  isReadOnly() {
+    return this.mode === "readonly" /* READONLY */;
+  }
+  /* ---------------- QUEUE HELPER ---------------- */
+  async getQueue() {
+    const { dbQueue } = await import("./queue-YILKSUEI.js");
+    return dbQueue;
+  }
+  /* ---------------- LOCK MANAGEMENT ---------------- */
+  isProcessAlive(pid) {
+    try {
+      process2.kill(pid, 0);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  tryAcquireLock() {
+    const lockPath = path8.join(this.rootPath, ".lioran.lock");
+    try {
+      this.lockFd = fs8.openSync(lockPath, "wx");
+      fs8.writeSync(this.lockFd, String(process2.pid));
+      return true;
+    } catch {
+      try {
+        const pid = Number(fs8.readFileSync(lockPath, "utf8"));
+        if (!this.isProcessAlive(pid)) {
+          fs8.unlinkSync(lockPath);
+          this.lockFd = fs8.openSync(lockPath, "wx");
+          fs8.writeSync(this.lockFd, String(process2.pid));
+          return true;
+        }
+      } catch {
+      }
+      return false;
+    }
+  }
+  /* ---------------- DB OPEN ---------------- */
+  async db(name) {
+    if (this.mode === "client" /* CLIENT */) {
+      const queue = await this.getQueue();
+      await queue.exec("db", { db: name });
+      return new IPCDatabase(name);
+    }
+    return this.openDatabase(name);
+  }
+  async openDatabase(name) {
+    this._assertOpen();
+    if (this.openDBs.has(name)) {
+      return this.openDBs.get(name);
+    }
+    const dbPath = path8.join(this.rootPath, name);
+    await fs8.promises.mkdir(dbPath, { recursive: true });
+    const db = new LioranDB(dbPath, name, this);
+    this.openDBs.set(name, db);
+    return db;
+  }
+  /* ---------------- SNAPSHOT ---------------- */
+  async snapshot(snapshotPath) {
+    if (this.mode === "client" /* CLIENT */) {
+      const queue = await this.getQueue();
+      return queue.exec("snapshot", { path: snapshotPath });
+    }
+    if (this.mode === "readonly" /* READONLY */) {
+      throw new Error("Snapshot not allowed in readonly mode");
+    }
+    for (const db of this.openDBs.values()) {
+      try {
+        await db.close();
+      } catch {
+      }
+    }
+    fs8.mkdirSync(path8.dirname(snapshotPath), { recursive: true });
+    const tar = await import("tar");
+    await tar.c(
+      {
+        gzip: true,
+        file: snapshotPath,
+        cwd: this.rootPath,
+        portable: true
+      },
+      ["./"]
+    );
+    return true;
+  }
+  /* ---------------- RESTORE ---------------- */
+  async restore(snapshotPath) {
+    if (this.mode === "client" /* CLIENT */) {
+      const queue = await this.getQueue();
+      return queue.exec("restore", { path: snapshotPath });
+    }
+    if (this.mode === "readonly" /* READONLY */) {
+      throw new Error("Restore not allowed in readonly mode");
+    }
+    await this.closeAll();
+    fs8.rmSync(this.rootPath, { recursive: true, force: true });
+    fs8.mkdirSync(this.rootPath, { recursive: true });
+    const tar = await import("tar");
+    await tar.x({
+      file: snapshotPath,
+      cwd: this.rootPath
+    });
+    console.log("Restore completed. Restart required.");
+    process2.exit(0);
+  }
+  /* ---------------- SHUTDOWN ---------------- */
+  async closeAll() {
+    if (this.closed) return;
+    this.closed = true;
+    if (this.mode === "client" /* CLIENT */) {
+      const queue = await this.getQueue();
+      await queue.shutdown();
+      return;
+    }
+    for (const db of this.openDBs.values()) {
+      try {
+        await db.close();
+      } catch {
+      }
+    }
+    this.openDBs.clear();
+    if (this.mode === "primary" /* PRIMARY */) {
+      try {
+        if (this.lockFd) fs8.closeSync(this.lockFd);
+        fs8.unlinkSync(path8.join(this.rootPath, ".lioran.lock"));
+      } catch {
+      }
+    }
+  }
+  async close() {
+    return this.closeAll();
+  }
+  _registerShutdownHooks() {
+    const shutdown = async () => {
+      await this.closeAll();
+    };
+    process2.on("SIGINT", shutdown);
+    process2.on("SIGTERM", shutdown);
+    process2.on("exit", shutdown);
+  }
+  _assertOpen() {
+    if (this.closed) {
+      throw new Error("LioranManager is closed");
+    }
+  }
+};
+var IPCDatabase = class {
+  constructor(name) {
+    this.name = name;
+  }
+  collection(name) {
+    return new IPCCollection(this.name, name);
+  }
+};
+var IPCCollection = class {
+  constructor(db, col) {
+    this.db = db;
+    this.col = col;
+  }
+  async getQueue() {
+    const { dbQueue } = await import("./queue-YILKSUEI.js");
+    return dbQueue;
+  }
+  async call(method, params) {
+    const queue = await this.getQueue();
+    return queue.exec("op", {
+      db: this.db,
+      col: this.col,
+      method,
+      params
+    });
+  }
+  insertOne = (doc) => this.call("insertOne", [doc]);
+  insertMany = (docs) => this.call("insertMany", [docs]);
+  find = (query) => this.call("find", [query]);
+  findOne = (query) => this.call("findOne", [query]);
+  updateOne = (filter, update, options) => this.call("updateOne", [filter, update, options]);
+  updateMany = (filter, update) => this.call("updateMany", [filter, update]);
+  deleteOne = (filter) => this.call("deleteOne", [filter]);
+  deleteMany = (filter) => this.call("deleteMany", [filter]);
+  countDocuments = (filter) => this.call("countDocuments", [filter]);
+};
+
+export {
+  LioranDB,
+  getDefaultRootPath,
+  getBaseDBFolder,
+  LioranManager
+};