@liorandb/core 1.1.0 → 1.1.1

package/dist/index.js

@@ -1,1831 +1,8 @@
-// src/LioranManager.ts
-import path9 from "path";
-import fs9 from "fs";
-import process2 from "process";
-
-// 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, path10) {
-  return path10.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();
-  constructor(dir, schema, schemaVersion = 1) {
-    this.dir = dir;
-    this.db = new ClassicLevel3(dir, { valueEncoding: "utf8" });
-    this.schema = schema;
-    this.schemaVersion = schemaVersion;
-  }
-  /* ===================== 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) {
-    for (const index of this.indexes.values()) {
-      await index.update(oldDoc, newDoc);
-    }
-  }
-  /* ===================== COMPACTION ===================== */
-  async compact() {
-    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) {
-    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) {
-    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);
-    if (!enc) return null;
-    const raw = decryptData(enc);
-    const migrated = this.migrateIfNeeded(raw);
-    if (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) {
-      try {
-        return await this._readAndMigrate(String(query._id));
-      } catch {
-        return null;
-      }
-    }
-    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) {
-    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) {
-    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) {
-    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) {
-    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;
-  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 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() {
-    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;
-  constructor(basePath, dbName, manager) {
-    this.basePath = basePath;
-    this.dbName = dbName;
-    this.manager = manager;
-    this.collections = /* @__PURE__ */ new Map();
-    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.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 (!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() {
-    fs6.writeFileSync(this.metaPath, JSON.stringify(this.meta, null, 2));
-  }
-  getSchemaVersion() {
-    return this.meta.schemaVersion;
-  }
-  setSchemaVersion(v) {
-    this.meta.schemaVersion = v;
-    this.saveMeta();
-  }
-  /* ------------------------- DB MIGRATIONS ------------------------- */
-  migrate(from, to, fn) {
-    this.migrator.register(from, to, async (db) => {
-      await fn(db);
-      db.setSchemaVersion(to);
-    });
-  }
-  async applyMigrations(targetVersion) {
-    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
-    );
-    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 = {}) {
-    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 (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        console.warn(`Index build skipped doc ${key}: ${msg}`);
-      }
-    }
-    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) {
-    const col = this.collection(name);
-    await col.compact();
-  }
-  async compactAll() {
-    for (const name of this.collections.keys()) {
-      await this.compactCollection(name);
-    }
-  }
-  /* ------------------------- TX API ------------------------- */
-  async transaction(fn) {
-    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/ipc/client.ts
-import net from "net";
-
-// src/ipc/socketPath.ts
-import os3 from "os";
-import path8 from "path";
-function getIPCSocketPath(rootPath) {
-  if (os3.platform() === "win32") {
-    return `\\\\.\\pipe\\liorandb_${rootPath.replace(/[:\\\/]/g, "_")}`;
-  }
-  return path8.join(rootPath, ".lioran.sock");
-}
-
-// src/ipc/client.ts
-function delay(ms) {
-  return new Promise((r) => setTimeout(r, ms));
-}
-async function connectWithRetry(path10) {
-  let attempt = 0;
-  while (true) {
-    try {
-      return await new Promise((resolve, reject) => {
-        const socket = net.connect(path10, () => resolve(socket));
-        socket.once("error", reject);
-      });
-    } catch (err) {
-      if (err.code === "ENOENT" || err.code === "ECONNREFUSED") {
-        if (attempt++ > 80) {
-          throw new Error("IPC server not reachable");
-        }
-        await delay(50);
-        continue;
-      }
-      throw err;
-    }
-  }
-}
-var IPCClient = class {
-  socket;
-  buffer = "";
-  seq = 0;
-  pending = /* @__PURE__ */ new Map();
-  ready;
-  constructor(rootPath) {
-    const socketPath = getIPCSocketPath(rootPath);
-    this.ready = this.init(socketPath);
-  }
-  async init(socketPath) {
-    this.socket = await connectWithRetry(socketPath);
-    this.socket.on("data", (data) => {
-      this.buffer += data.toString();
-      while (this.buffer.includes("\n")) {
-        const idx = this.buffer.indexOf("\n");
-        const raw = this.buffer.slice(0, idx);
-        this.buffer = this.buffer.slice(idx + 1);
-        const msg = JSON.parse(raw);
-        const cb = this.pending.get(msg.id);
-        if (cb) {
-          this.pending.delete(msg.id);
-          cb(msg);
-        }
-      }
-    });
-    this.socket.on("error", (err) => {
-      console.error("IPC socket error:", err);
-    });
-  }
-  async exec(action, args) {
-    await this.ready;
-    return new Promise((resolve, reject) => {
-      const id = ++this.seq;
-      this.pending.set(id, (msg) => {
-        msg.ok ? resolve(msg.result) : reject(new Error(msg.error));
-      });
-      this.socket.write(JSON.stringify({ id, action, args }) + "\n");
-    });
-  }
-  close() {
-    try {
-      this.socket.end();
-    } catch {
-    }
-  }
-};
-
-// src/ipc/queue.ts
-var DBQueue = class {
-  client;
-  constructor(rootPath = getDefaultRootPath()) {
-    this.client = new IPCClient(rootPath);
-  }
-  exec(action, args) {
-    return this.client.exec(action, args);
-  }
-  /* ----------------------------- COMPACTION API ----------------------------- */
-  compactCollection(db, col) {
-    return this.exec("compact:collection", { db, col });
-  }
-  compactDB(db) {
-    return this.exec("compact:db", { db });
-  }
-  compactAll() {
-    return this.exec("compact:all", {});
-  }
-  /* ----------------------------- SNAPSHOT API ----------------------------- */
-  snapshot(path10) {
-    return this.exec("snapshot", { path: path10 });
-  }
-  restore(path10) {
-    return this.exec("restore", { path: path10 });
-  }
-  /* ------------------------------ SHUTDOWN ------------------------------ */
-  async shutdown() {
-    try {
-      await this.exec("shutdown", {});
-    } catch {
-    }
-    this.client.close();
-  }
-};
-var dbQueue = new DBQueue();
-
-// src/ipc/server.ts
-import net2 from "net";
-import fs8 from "fs";
-var IPCServer = class {
-  server;
-  manager;
-  socketPath;
-  constructor(manager, rootPath) {
-    this.manager = manager;
-    this.socketPath = getIPCSocketPath(rootPath);
-  }
-  start() {
-    if (!this.socketPath.startsWith("\\\\.\\")) {
-      if (fs8.existsSync(this.socketPath)) fs8.unlinkSync(this.socketPath);
-    }
-    this.server = net2.createServer((socket) => {
-      let buffer = "";
-      socket.on("data", async (data) => {
-        buffer += data.toString();
-        while (buffer.includes("\n")) {
-          const idx = buffer.indexOf("\n");
-          const raw = buffer.slice(0, idx);
-          buffer = buffer.slice(idx + 1);
-          try {
-            const msg = JSON.parse(raw);
-            await this.handleMessage(socket, msg);
-          } catch {
-            socket.write(JSON.stringify({
-              id: null,
-              ok: false,
-              error: "Invalid JSON"
-            }) + "\n");
-          }
-        }
-      });
-    });
-    this.server.listen(this.socketPath, () => {
-      console.log("[IPC] Server listening:", this.socketPath);
-    });
-  }
-  async handleMessage(socket, msg) {
-    const { id, action, args } = msg;
-    try {
-      let result;
-      switch (action) {
-        /* ---------------- DB ---------------- */
-        case "db": {
-          await this.manager.db(args.db);
-          result = true;
-          break;
-        }
-        /* ---------------- OPS ---------------- */
-        case "op": {
-          const { db, col, method, params } = args;
-          const collection = (await this.manager.db(db)).collection(col);
-          result = await collection[method](...params);
-          break;
-        }
-        /* ---------------- COMPACTION ---------------- */
-        case "compact:collection": {
-          const { db, col } = args;
-          const collection = (await this.manager.db(db)).collection(col);
-          await collection.compact();
-          result = true;
-          break;
-        }
-        case "compact:db": {
-          const { db } = args;
-          const database = await this.manager.db(db);
-          await database.compactAll();
-          result = true;
-          break;
-        }
-        case "compact:all": {
-          for (const db of this.manager.openDBs.values()) {
-            await db.compactAll();
-          }
-          result = true;
-          break;
-        }
-        /* ---------------- SNAPSHOT ---------------- */
-        case "snapshot": {
-          const { path: snapshotPath } = args;
-          await this.manager.snapshot(snapshotPath);
-          result = true;
-          break;
-        }
-        case "restore": {
-          const { path: snapshotPath } = args;
-          await this.manager.restore(snapshotPath);
-          result = true;
-          break;
-        }
-        /* ---------------- CONTROL ---------------- */
-        case "shutdown": {
-          await this.manager.closeAll();
-          result = true;
-          break;
-        }
-        default:
-          throw new Error(`Unknown IPC action: ${action}`);
-      }
-      socket.write(JSON.stringify({ id, ok: true, result }) + "\n");
-    } catch (err) {
-      socket.write(JSON.stringify({
-        id,
-        ok: false,
-        error: err?.message || "IPC error"
-      }) + "\n");
-    }
-  }
-  async close() {
-    if (this.server) this.server.close();
-    if (!this.socketPath.startsWith("\\\\.\\")) {
-      try {
-        fs8.unlinkSync(this.socketPath);
-      } catch {
-      }
-    }
-  }
-};
-
-// src/LioranManager.ts
-var LioranManager = class {
-  rootPath;
-  openDBs;
-  closed = false;
-  mode;
-  lockFd;
-  ipcServer;
-  constructor(options = {}) {
-    const { rootPath, encryptionKey } = options;
-    this.rootPath = rootPath || getDefaultRootPath();
-    if (!fs9.existsSync(this.rootPath)) {
-      fs9.mkdirSync(this.rootPath, { recursive: true });
-    }
-    if (encryptionKey) {
-      setEncryptionKey(encryptionKey);
-    }
-    this.openDBs = /* @__PURE__ */ new Map();
-    this.mode = this.tryAcquireLock() ? "primary" /* PRIMARY */ : "client" /* CLIENT */;
-    if (this.mode === "primary" /* PRIMARY */) {
-      this.ipcServer = new IPCServer(this, this.rootPath);
-      this.ipcServer.start();
-      this._registerShutdownHooks();
-    }
-  }
-  /* ---------------- LOCK MANAGEMENT ---------------- */
-  isProcessAlive(pid) {
-    try {
-      process2.kill(pid, 0);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  tryAcquireLock() {
-    const lockPath = path9.join(this.rootPath, ".lioran.lock");
-    try {
-      this.lockFd = fs9.openSync(lockPath, "wx");
-      fs9.writeSync(this.lockFd, String(process2.pid));
-      return true;
-    } catch {
-      try {
-        const pid = Number(fs9.readFileSync(lockPath, "utf8"));
-        if (!this.isProcessAlive(pid)) {
-          fs9.unlinkSync(lockPath);
-          this.lockFd = fs9.openSync(lockPath, "wx");
-          fs9.writeSync(this.lockFd, String(process2.pid));
-          return true;
-        }
-      } catch {
-      }
-      return false;
-    }
-  }
-  /* ---------------- DB OPEN ---------------- */
-  async db(name) {
-    if (this.mode === "client" /* CLIENT */) {
-      await dbQueue.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 = 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;
-  }
-  /* ---------------- SNAPSHOT ORCHESTRATION ---------------- */
-  /**
-   * Create TAR snapshot of full DB directory
-   */
-  async snapshot(snapshotPath) {
-    if (this.mode === "client" /* CLIENT */) {
-      return dbQueue.exec("snapshot", { path: snapshotPath });
-    }
-    for (const db of this.openDBs.values()) {
-      for (const col of db.collections.values()) {
-        try {
-          await col.db.close();
-        } catch {
-        }
-      }
-    }
-    fs9.mkdirSync(path9.dirname(snapshotPath), { recursive: true });
-    const tar = await import("tar");
-    await tar.c({
-      gzip: true,
-      file: snapshotPath,
-      cwd: this.rootPath,
-      portable: true
-    }, ["./"]);
-    return true;
-  }
-  /**
-   * Restore TAR snapshot safely
-   */
-  async restore(snapshotPath) {
-    if (this.mode === "client" /* CLIENT */) {
-      return dbQueue.exec("restore", { path: snapshotPath });
-    }
-    await this.closeAll();
-    fs9.rmSync(this.rootPath, { recursive: true, force: true });
-    fs9.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 */) {
-      await dbQueue.shutdown();
-      return;
-    }
-    for (const db of this.openDBs.values()) {
-      try {
-        await db.close();
-      } catch {
-      }
-    }
-    this.openDBs.clear();
-    try {
-      if (this.lockFd) fs9.closeSync(this.lockFd);
-      fs9.unlinkSync(path9.join(this.rootPath, ".lioran.lock"));
-    } catch {
-    }
-    await this.ipcServer?.close();
-  }
-  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;
-  }
-  call(method, params) {
-    return dbQueue.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]);
-};
+import {
+  LioranDB,
+  LioranManager,
+  getBaseDBFolder
+} from "./chunk-2FSI7HX7.js";
 export {
   LioranDB,
   LioranManager,