@wgtechlabs/config-engine 0.1.0-staging.d0d9e7f

package/dist/index.js

@@ -0,0 +1,967 @@
+import {
+  __require,
+  createZodValidator,
+  resolveValidator
+} from "./chunk-gs6j6hrj.js";
+
+// src/index.ts
+import { mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+import { watch } from "node:fs";
+
+// src/cache.ts
+class ConfigCache {
+  #store;
+  #strategy;
+  #data = new Map;
+  #dirty = new Set;
+  #deleted = new Set;
+  #flushScheduled = false;
+  #flushPromise = null;
+  constructor(store, strategy = "batched") {
+    this.#store = store;
+    this.#strategy = strategy;
+  }
+  load(initial) {
+    this.#data.clear();
+    this.#dirty.clear();
+    this.#deleted.clear();
+    const stored = initial ?? this.#store.getAll();
+    for (const [key, value] of Object.entries(stored)) {
+      this.#data.set(key, value);
+    }
+  }
+  get(key) {
+    return this.#data.get(key);
+  }
+  has(key) {
+    return this.#data.has(key);
+  }
+  get size() {
+    return this.#data.size;
+  }
+  getAll() {
+    const obj = Object.create(null);
+    for (const [key, value] of this.#data) {
+      obj[key] = value;
+    }
+    return obj;
+  }
+  entries() {
+    return this.#data.entries();
+  }
+  set(key, value) {
+    this.#data.set(key, value);
+    this.#dirty.add(key);
+    this.#deleted.delete(key);
+    this.#scheduleFlush();
+  }
+  setMany(entries) {
+    for (const [key, value] of entries) {
+      this.#data.set(key, value);
+      this.#dirty.add(key);
+      this.#deleted.delete(key);
+    }
+    this.#scheduleFlush();
+  }
+  delete(key) {
+    const existed = this.#data.delete(key);
+    if (existed) {
+      this.#dirty.delete(key);
+      this.#deleted.add(key);
+      this.#scheduleFlush();
+    }
+    return existed;
+  }
+  clear() {
+    for (const key of this.#data.keys()) {
+      this.#deleted.add(key);
+    }
+    this.#data.clear();
+    this.#dirty.clear();
+    this.#scheduleFlush();
+  }
+  replaceAll(data) {
+    for (const key of this.#data.keys()) {
+      if (!(key in data)) {
+        this.#deleted.add(key);
+      }
+    }
+    this.#data.clear();
+    this.#dirty.clear();
+    for (const [key, value] of Object.entries(data)) {
+      this.#data.set(key, value);
+      this.#dirty.add(key);
+      this.#deleted.delete(key);
+    }
+    this.#scheduleFlush();
+  }
+  #scheduleFlush() {
+    if (this.#strategy === "manual")
+      return;
+    if (this.#strategy === "immediate") {
+      this.flushSync();
+      return;
+    }
+    if (!this.#flushScheduled) {
+      this.#flushScheduled = true;
+      this.#flushPromise = Promise.resolve().then(() => {
+        this.flushSync();
+        this.#flushScheduled = false;
+        this.#flushPromise = null;
+      });
+    }
+  }
+  flushSync() {
+    if (this.#dirty.size === 0 && this.#deleted.size === 0)
+      return;
+    this.#store.transaction(() => {
+      if (this.#dirty.size > 0) {
+        const entries = [];
+        for (const key of this.#dirty) {
+          entries.push([key, this.#data.get(key)]);
+        }
+        this.#store.setMany(entries);
+      }
+      for (const key of this.#deleted) {
+        this.#store.deleteOne(key);
+      }
+      this.#store.touchLastWrite();
+    });
+    this.#dirty.clear();
+    this.#deleted.clear();
+  }
+  async flush() {
+    if (this.#flushPromise) {
+      await this.#flushPromise;
+    } else if (this.#dirty.size > 0 || this.#deleted.size > 0) {
+      this.flushSync();
+    }
+  }
+  reload() {
+    this.#dirty.clear();
+    this.#deleted.clear();
+    this.load();
+  }
+}
+
+// src/dot-prop.ts
+function getByPath(obj, path) {
+  if (typeof obj !== "object" || obj === null)
+    return;
+  const keys = path.split(".");
+  let current = obj;
+  for (const key of keys) {
+    if (typeof current !== "object" || current === null)
+      return;
+    current = current[key];
+  }
+  return current;
+}
+function setByPath(obj, path, value) {
+  const keys = path.split(".");
+  if (keys.length === 0)
+    return obj;
+  const result = { ...obj };
+  let current = result;
+  for (let i = 0;i < keys.length - 1; i++) {
+    const key = keys[i];
+    if (typeof current[key] !== "object" || current[key] === null) {
+      current[key] = {};
+    } else {
+      current[key] = { ...current[key] };
+    }
+    current = current[key];
+  }
+  const lastKey = keys[keys.length - 1];
+  current[lastKey] = value;
+  return result;
+}
+function hasByPath(obj, path) {
+  if (typeof obj !== "object" || obj === null)
+    return false;
+  const keys = path.split(".");
+  let current = obj;
+  for (let i = 0;i < keys.length; i++) {
+    if (typeof current !== "object" || current === null)
+      return false;
+    const key = keys[i];
+    if (!Object.prototype.hasOwnProperty.call(current, key))
+      return false;
+    current = current[key];
+  }
+  return true;
+}
+function deleteByPath(obj, path) {
+  const keys = path.split(".");
+  if (keys.length === 0)
+    return obj;
+  const result = { ...obj };
+  let current = result;
+  for (let i = 0;i < keys.length - 1; i++) {
+    const key = keys[i];
+    if (typeof current[key] !== "object" || current[key] === null) {
+      return obj;
+    }
+    current[key] = { ...current[key] };
+    current = current[key];
+  }
+  const lastKey = keys[keys.length - 1];
+  delete current[lastKey];
+  return result;
+}
+
+// src/encryption.ts
+class SecretsEngineEncryptor {
+  #keyName;
+  #derivedKey = null;
+  #secrets = null;
+  constructor(keyName) {
+    this.#keyName = keyName;
+  }
+  async init() {
+    let SecretsEngine;
+    try {
+      const mod = await import("@wgtechlabs/secrets-engine");
+      SecretsEngine = mod.SecretsEngine ?? mod.default?.SecretsEngine ?? mod;
+    } catch {
+      throw new Error('Encryption requires "@wgtechlabs/secrets-engine" as a peer dependency. Install it with: bun add @wgtechlabs/secrets-engine');
+    }
+    this.#secrets = await SecretsEngine.open();
+    const hasKey = await this.#secrets.has(this.#keyName);
+    if (!hasKey) {
+      const keyBytes = crypto.getRandomValues(new Uint8Array(32));
+      const keyHex2 = Array.from(keyBytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+      await this.#secrets.set(this.#keyName, keyHex2);
+    }
+    const keyHex = await this.#secrets.get(this.#keyName);
+    const keyBuffer = hexToUint8Array(keyHex);
+    this.#derivedKey = await crypto.subtle.importKey("raw", keyBuffer.buffer, { name: "AES-GCM" }, false, ["encrypt", "decrypt"]);
+  }
+  async encrypt(plaintext) {
+    if (!this.#derivedKey)
+      throw new Error("Encryptor not initialized. Call init() first.");
+    const iv = crypto.getRandomValues(new Uint8Array(12));
+    const encoded = new TextEncoder().encode(plaintext);
+    const cipherBuffer = await crypto.subtle.encrypt({ name: "AES-GCM", iv: iv.buffer }, this.#derivedKey, encoded);
+    const ivB64 = uint8ArrayToBase64(iv);
+    const cipherB64 = uint8ArrayToBase64(new Uint8Array(cipherBuffer));
+    return `${ivB64}:${cipherB64}`;
+  }
+  async decrypt(ciphertext) {
+    if (!this.#derivedKey)
+      throw new Error("Encryptor not initialized. Call init() first.");
+    const [ivB64, cipherB64] = ciphertext.split(":");
+    if (!ivB64 || !cipherB64)
+      throw new Error("Invalid encrypted data format.");
+    const iv = base64ToUint8Array(ivB64);
+    const cipherBuffer = base64ToUint8Array(cipherB64);
+    const plainBuffer = await crypto.subtle.decrypt({ name: "AES-GCM", iv: iv.buffer }, this.#derivedKey, cipherBuffer.buffer);
+    return new TextDecoder().decode(plainBuffer);
+  }
+  async close() {
+    if (this.#secrets) {
+      this.#secrets.close();
+      this.#secrets = null;
+    }
+  }
+}
+function hexToUint8Array(hex) {
+  const bytes = new Uint8Array(hex.length / 2);
+  for (let i = 0;i < hex.length; i += 2) {
+    bytes[i / 2] = Number.parseInt(hex.substring(i, i + 2), 16);
+  }
+  return bytes;
+}
+function uint8ArrayToBase64(bytes) {
+  if (typeof Buffer !== "undefined") {
+    return Buffer.from(bytes).toString("base64");
+  }
+  let binary = "";
+  for (const byte of bytes) {
+    binary += String.fromCharCode(byte);
+  }
+  return btoa(binary);
+}
+function base64ToUint8Array(b64) {
+  if (typeof Buffer !== "undefined") {
+    return new Uint8Array(Buffer.from(b64, "base64"));
+  }
+  const binary = atob(b64);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0;i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes;
+}
+async function resolveEncryptor(encryptionKey) {
+  if (!encryptionKey)
+    return;
+  if (typeof encryptionKey === "string") {
+    const enc = new SecretsEngineEncryptor(encryptionKey);
+    await enc.init();
+    return enc;
+  }
+  return encryptionKey;
+}
+
+// src/migrations.ts
+var META_KEY = "schema_version";
+var INITIAL_VERSION = "0.0.0";
+async function runMigrations(options) {
+  const { store, migrations, projectVersion, beforeEachMigration, afterEachMigration } = options;
+  if (migrations.length === 0)
+    return;
+  const currentVersion = store.getMeta(META_KEY) ?? INITIAL_VERSION;
+  const versions = migrations.map((m) => m.version);
+  const finalVersion = projectVersion;
+  const pending = migrations.filter((m) => compareVersions(m.version, currentVersion) > 0);
+  if (pending.length === 0) {
+    store.setMeta(META_KEY, projectVersion);
+    return;
+  }
+  pending.sort((a, b) => compareVersions(a.version, b.version));
+  const ctx = createMigrationContext(store);
+  const snapshot = store.getAll();
+  const snapshotVersion = currentVersion;
+  try {
+    for (const migration of pending) {
+      const hookCtx = {
+        fromVersion: currentVersion,
+        toVersion: migration.version,
+        finalVersion,
+        versions
+      };
+      if (beforeEachMigration) {
+        await beforeEachMigration(hookCtx);
+      }
+      await migration.up(ctx);
+      if (afterEachMigration) {
+        await afterEachMigration(hookCtx);
+      }
+    }
+    store.setMeta(META_KEY, projectVersion);
+    store.touchLastWrite();
+  } catch (error) {
+    store.transaction(() => {
+      store.deleteAll();
+      const entries = Object.entries(snapshot);
+      if (entries.length > 0) {
+        store.setMany(entries);
+      }
+      store.setMeta(META_KEY, snapshotVersion);
+    });
+    throw new Error(`Migration to version "${pending.find(() => true)?.version}" failed. ` + `All changes have been rolled back. Original error: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+function createMigrationContext(store) {
+  return {
+    get(key) {
+      return store.getOne(key);
+    },
+    set(key, value) {
+      store.setOne(key, value);
+    },
+    has(key) {
+      return store.has(key);
+    },
+    delete(key) {
+      return store.deleteOne(key);
+    }
+  };
+}
+function compareVersions(a, b) {
+  const partsA = a.split(".").map(Number);
+  const partsB = b.split(".").map(Number);
+  for (let i = 0;i < 3; i++) {
+    const va = partsA[i] ?? 0;
+    const vb = partsB[i] ?? 0;
+    if (va !== vb)
+      return va - vb;
+  }
+  return 0;
+}
+
+// src/platform.ts
+import { homedir, platform } from "node:os";
+import { join } from "node:path";
+function resolveConfigDir(projectName) {
+  const home = homedir();
+  const os = platform();
+  switch (os) {
+    case "darwin":
+      return join(home, "Library", "Preferences", projectName);
+    case "win32":
+      return join(process.env.APPDATA ?? join(home, "AppData", "Roaming"), projectName);
+    default:
+      return join(process.env.XDG_CONFIG_HOME ?? join(home, ".config"), projectName);
+  }
+}
+function resolveConfigPath(options) {
+  const dir = options.cwd ?? resolveConfigDir(options.projectName);
+  const name = options.configName ?? "config";
+  return join(dir, `${name}.db`);
+}
+
+// src/runtime.ts
+function isBun() {
+  return typeof globalThis.Bun !== "undefined";
+}
+function openDatabase(filepath) {
+  if (isBun()) {
+    return openBunDatabase(filepath);
+  }
+  return openNodeDatabase(filepath);
+}
+function openBunDatabase(filepath) {
+  const { Database } = __require("bun:sqlite");
+  const db = new Database(filepath);
+  db.exec("PRAGMA journal_mode = WAL;");
+  db.exec("PRAGMA busy_timeout = 5000;");
+  return {
+    prepare(sql) {
+      const stmt = db.prepare(sql);
+      return {
+        run(...params) {
+          stmt.run(...params);
+        },
+        get(...params) {
+          return stmt.get(...params);
+        },
+        all(...params) {
+          return stmt.all(...params);
+        }
+      };
+    },
+    exec(sql) {
+      db.exec(sql);
+    },
+    close() {
+      db.close();
+    },
+    transaction(fn) {
+      return db.transaction(fn);
+    }
+  };
+}
+function openNodeDatabase(filepath) {
+  let BetterSqlite3;
+  try {
+    BetterSqlite3 = __require("better-sqlite3");
+  } catch {
+    throw new Error('config-engine requires "better-sqlite3" as a peer dependency when running on Node.js. ' + "Install it with: npm install better-sqlite3");
+  }
+  const db = new BetterSqlite3(filepath);
+  db.pragma("journal_mode = WAL");
+  db.pragma("busy_timeout = 5000");
+  return {
+    prepare(sql) {
+      const stmt = db.prepare(sql);
+      return {
+        run(...params) {
+          stmt.run(...params);
+        },
+        get(...params) {
+          return stmt.get(...params);
+        },
+        all(...params) {
+          return stmt.all(...params);
+        }
+      };
+    },
+    exec(sql) {
+      db.exec(sql);
+    },
+    close() {
+      db.close();
+    },
+    transaction(fn) {
+      return db.transaction(fn);
+    }
+  };
+}
+
+// src/store.ts
+class ConfigStore {
+  #db;
+  constructor(db) {
+    this.#db = db;
+    this.#initialize();
+  }
+  #initialize() {
+    this.#db.exec(`
+			CREATE TABLE IF NOT EXISTS config (
+				key   TEXT PRIMARY KEY,
+				value TEXT NOT NULL
+			);
+		`);
+    this.#db.exec(`
+			CREATE TABLE IF NOT EXISTS _meta (
+				key   TEXT PRIMARY KEY,
+				value TEXT NOT NULL
+			);
+		`);
+  }
+  getAll() {
+    const rows = this.#db.prepare("SELECT key, value FROM config").all();
+    const result = Object.create(null);
+    for (const row of rows) {
+      result[row.key] = JSON.parse(row.value);
+    }
+    return result;
+  }
+  getOne(key) {
+    const row = this.#db.prepare("SELECT value FROM config WHERE key = ?").get(key);
+    return row ? JSON.parse(row.value) : undefined;
+  }
+  setOne(key, value) {
+    this.#db.prepare("INSERT OR REPLACE INTO config (key, value) VALUES (?, ?)").run(key, JSON.stringify(value));
+  }
+  setMany(entries) {
+    const stmt = this.#db.prepare("INSERT OR REPLACE INTO config (key, value) VALUES (?, ?)");
+    const runTransaction = this.#db.transaction(() => {
+      for (const [key, value] of entries) {
+        stmt.run(key, JSON.stringify(value));
+      }
+    });
+    runTransaction();
+  }
+  deleteOne(key) {
+    const before = this.count();
+    this.#db.prepare("DELETE FROM config WHERE key = ?").run(key);
+    return this.count() < before;
+  }
+  deleteAll() {
+    this.#db.exec("DELETE FROM config;");
+  }
+  has(key) {
+    const row = this.#db.prepare("SELECT 1 FROM config WHERE key = ? LIMIT 1").get(key);
+    return row !== undefined && row !== null;
+  }
+  count() {
+    const row = this.#db.prepare("SELECT COUNT(*) as cnt FROM config").get();
+    return row.cnt;
+  }
+  getMeta(key) {
+    const row = this.#db.prepare("SELECT value FROM _meta WHERE key = ?").get(key);
+    return row?.value;
+  }
+  setMeta(key, value) {
+    this.#db.prepare("INSERT OR REPLACE INTO _meta (key, value) VALUES (?, ?)").run(key, value);
+  }
+  hasMeta(key) {
+    const row = this.#db.prepare("SELECT 1 FROM _meta WHERE key = ? LIMIT 1").get(key);
+    return row !== undefined && row !== null;
+  }
+  transaction(fn) {
+    const wrapped = this.#db.transaction(fn);
+    return wrapped();
+  }
+  touchLastWrite() {
+    this.setMeta("last_write", Date.now().toString());
+  }
+  getLastWrite() {
+    const val = this.getMeta("last_write");
+    return val ? Number(val) : 0;
+  }
+  close() {
+    this.#db.close();
+  }
+}
+
+// src/index.ts
+class ConfigEngineError extends Error {
+  name = "ConfigEngineError";
+}
+
+class ValidationError extends ConfigEngineError {
+  name = "ValidationError";
+  errors;
+  constructor(errors) {
+    super(`Config validation failed:
+  - ${errors.join(`
+  - `)}`);
+    this.errors = errors;
+  }
+}
+
+class ConfigEngine {
+  #store;
+  #cache;
+  #validator;
+  #encryptor;
+  #defaults;
+  #dotNotation;
+  #filePath;
+  #listeners = new Map;
+  #anyListeners = new Set;
+  #watcher = null;
+  #lastKnownWrite = 0;
+  #closed = false;
+  constructor(store, cache, options) {
+    this.#store = store;
+    this.#cache = cache;
+    this.#validator = options.validator;
+    this.#encryptor = options.encryptor;
+    this.#defaults = options.defaults;
+    this.#dotNotation = options.dotNotation;
+    this.#filePath = options.filePath;
+    this.#lastKnownWrite = store.getLastWrite();
+    if (options.watch) {
+      this.#startWatching();
+    }
+  }
+  static async open(options) {
+    const {
+      projectName,
+      projectVersion,
+      cwd,
+      configName,
+      defaults = {},
+      encryptionKey,
+      migrations,
+      beforeEachMigration,
+      afterEachMigration,
+      flushStrategy = "batched",
+      accessPropertiesByDotNotation = true,
+      watch: enableWatch = false,
+      clearInvalidConfig = false
+    } = options;
+    const filePath = resolveConfigPath({ projectName, cwd, configName });
+    mkdirSync(dirname(filePath), { recursive: true });
+    const db = openDatabase(filePath);
+    const store = new ConfigStore(db);
+    const encryptor = await resolveEncryptor(encryptionKey);
+    const validator = resolveValidator(options);
+    let storedData;
+    try {
+      storedData = store.getAll();
+      if (encryptor) {
+        storedData = await decryptStore(storedData, encryptor);
+      }
+    } catch (error) {
+      if (clearInvalidConfig) {
+        store.deleteAll();
+        storedData = {};
+      } else {
+        store.close();
+        throw new ConfigEngineError(`Failed to load config: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+    const merged = { ...defaults, ...storedData };
+    if (validator) {
+      const result = validator.validate(merged);
+      if (!result.success) {
+        if (clearInvalidConfig) {
+          store.deleteAll();
+          const freshData = { ...defaults };
+          const freshResult = validator.validate(freshData);
+          if (!freshResult.success) {
+            store.close();
+            throw new ValidationError(freshResult.errors);
+          }
+          const entries = Object.entries(freshData);
+          if (encryptor) {
+            const encrypted = await encryptStore(freshData, encryptor);
+            store.setMany(Object.entries(encrypted));
+          } else {
+            store.setMany(entries);
+          }
+          store.touchLastWrite();
+          const cache2 = new ConfigCache(store, flushStrategy);
+          cache2.load(freshData);
+          return new ConfigEngine(store, cache2, {
+            validator,
+            encryptor,
+            defaults,
+            dotNotation: accessPropertiesByDotNotation,
+            filePath,
+            watch: enableWatch
+          });
+        }
+        store.close();
+        throw new ValidationError(result.errors);
+      }
+    }
+    const hasNewDefaults = Object.keys(defaults).some((key) => !(key in storedData));
+    if (hasNewDefaults) {
+      if (encryptor) {
+        const encrypted = await encryptStore(merged, encryptor);
+        store.setMany(Object.entries(encrypted));
+      } else {
+        store.setMany(Object.entries(merged));
+      }
+      store.touchLastWrite();
+    }
+    if (migrations && migrations.length > 0) {
+      if (!projectVersion) {
+        store.close();
+        throw new ConfigEngineError('"projectVersion" is required when "migrations" is provided.');
+      }
+      await runMigrations({
+        store,
+        migrations,
+        projectVersion,
+        beforeEachMigration,
+        afterEachMigration
+      });
+    }
+    const cache = new ConfigCache(store, flushStrategy);
+    let finalData;
+    if (encryptor) {
+      finalData = await decryptStore(store.getAll(), encryptor);
+    } else {
+      finalData = store.getAll();
+    }
+    const cacheData = { ...defaults, ...finalData };
+    cache.load(cacheData);
+    return new ConfigEngine(store, cache, {
+      validator,
+      encryptor,
+      defaults,
+      dotNotation: accessPropertiesByDotNotation,
+      filePath,
+      watch: enableWatch
+    });
+  }
+  get(key, defaultValue) {
+    this.#ensureOpen();
+    if (this.#dotNotation && key.includes(".")) {
+      const full = this.#cache.getAll();
+      const value2 = getByPath(full, key);
+      return value2 !== undefined ? value2 : defaultValue;
+    }
+    const value = this.#cache.get(key);
+    return value !== undefined ? value : defaultValue;
+  }
+  has(key) {
+    this.#ensureOpen();
+    if (this.#dotNotation && key.includes(".")) {
+      return hasByPath(this.#cache.getAll(), key);
+    }
+    return this.#cache.has(key);
+  }
+  get store() {
+    this.#ensureOpen();
+    return this.#cache.getAll();
+  }
+  set store(value) {
+    this.#ensureOpen();
+    this.#validateFull(value);
+    const oldStore = this.#cache.getAll();
+    this.#cache.replaceAll(value);
+    this.#notifyAnyChange(value, oldStore);
+  }
+  get size() {
+    this.#ensureOpen();
+    return this.#cache.size;
+  }
+  get path() {
+    return this.#filePath;
+  }
+  set(keyOrObject, value) {
+    this.#ensureOpen();
+    if (typeof keyOrObject === "string") {
+      this.#setKey(keyOrObject, value);
+    } else {
+      const entries = Object.entries(keyOrObject);
+      const oldStore = this.#cache.getAll();
+      for (const [key, val] of entries) {
+        if (this.#dotNotation && key.includes(".")) {
+          const full = this.#cache.getAll();
+          const updated = setByPath(full, key, val);
+          this.#validateFull(updated);
+          this.#cache.replaceAll(updated);
+        } else {
+          this.#cache.set(key, val);
+        }
+      }
+      this.#validateFull(this.#cache.getAll());
+      this.#notifyAnyChange(this.#cache.getAll(), oldStore);
+    }
+  }
+  #setKey(key, value) {
+    const oldStore = this.#cache.getAll();
+    const oldValue = this.get(key);
+    if (this.#dotNotation && key.includes(".")) {
+      const full = this.#cache.getAll();
+      const updated = setByPath(full, key, value);
+      this.#validateFull(updated);
+      this.#cache.replaceAll(updated);
+    } else {
+      const testStore = { ...this.#cache.getAll(), [key]: value };
+      this.#validateFull(testStore);
+      this.#cache.set(key, value);
+    }
+    this.#notifyKeyChange(key, value, oldValue);
+    this.#notifyAnyChange(this.#cache.getAll(), oldStore);
+  }
+  delete(key) {
+    this.#ensureOpen();
+    const oldStore = this.#cache.getAll();
+    const oldValue = this.get(key);
+    if (this.#dotNotation && key.includes(".")) {
+      const full = this.#cache.getAll();
+      const updated = deleteByPath(full, key);
+      this.#cache.replaceAll(updated);
+    } else {
+      this.#cache.delete(key);
+    }
+    this.#notifyKeyChange(key, undefined, oldValue);
+    this.#notifyAnyChange(this.#cache.getAll(), oldStore);
+  }
+  clear() {
+    this.#ensureOpen();
+    const oldStore = this.#cache.getAll();
+    this.#cache.clear();
+    if (this.#defaults && Object.keys(this.#defaults).length > 0) {
+      this.#cache.setMany(Object.entries(this.#defaults));
+    }
+    this.#notifyAnyChange(this.#cache.getAll(), oldStore);
+  }
+  reset(...keys) {
+    this.#ensureOpen();
+    const oldStore = this.#cache.getAll();
+    for (const key of keys) {
+      if (key in this.#defaults) {
+        this.#cache.set(key, this.#defaults[key]);
+      } else {
+        this.#cache.delete(key);
+      }
+    }
+    this.#notifyAnyChange(this.#cache.getAll(), oldStore);
+  }
+  onDidChange(key, callback) {
+    if (!this.#listeners.has(key)) {
+      this.#listeners.set(key, new Set);
+    }
+    const set = this.#listeners.get(key);
+    set.add(callback);
+    return () => {
+      set.delete(callback);
+      if (set.size === 0)
+        this.#listeners.delete(key);
+    };
+  }
+  onDidAnyChange(callback) {
+    this.#anyListeners.add(callback);
+    return () => {
+      this.#anyListeners.delete(callback);
+    };
+  }
+  async flush() {
+    this.#ensureOpen();
+    await this.#cache.flush();
+  }
+  flushSync() {
+    this.#ensureOpen();
+    this.#cache.flushSync();
+  }
+  close() {
+    if (this.#closed)
+      return;
+    this.#stopWatching();
+    this.#cache.flushSync();
+    this.#store.close();
+    this.#closed = true;
+  }
+  *[Symbol.iterator]() {
+    this.#ensureOpen();
+    yield* this.#cache.entries();
+  }
+  #ensureOpen() {
+    if (this.#closed) {
+      throw new ConfigEngineError("This ConfigEngine instance has been closed. Create a new one with ConfigEngine.open().");
+    }
+  }
+  #validateFull(data) {
+    if (!this.#validator)
+      return;
+    const result = this.#validator.validate(data);
+    if (!result.success) {
+      throw new ValidationError(result.errors);
+    }
+  }
+  #notifyKeyChange(key, newValue, oldValue) {
+    if (newValue === oldValue)
+      return;
+    if (typeof newValue === "object" && typeof oldValue === "object" && JSON.stringify(newValue) === JSON.stringify(oldValue)) {
+      return;
+    }
+    const listeners = this.#listeners.get(key);
+    if (listeners) {
+      for (const cb of listeners) {
+        cb(newValue, oldValue);
+      }
+    }
+  }
+  #notifyAnyChange(newStore, oldStore) {
+    if (JSON.stringify(newStore) === JSON.stringify(oldStore))
+      return;
+    for (const cb of this.#anyListeners) {
+      cb(newStore, oldStore);
+    }
+  }
+  #startWatching() {
+    try {
+      this.#watcher = watch(dirname(this.#filePath), (_event, filename) => {
+        if (!filename)
+          return;
+        const expectedName = this.#filePath.split(/[\\/]/).pop();
+        if (filename !== expectedName)
+          return;
+        const currentWrite = this.#store.getLastWrite();
+        if (currentWrite > this.#lastKnownWrite) {
+          this.#lastKnownWrite = currentWrite;
+          const oldStore = this.#cache.getAll();
+          this.#cache.reload();
+          const newStore = this.#cache.getAll();
+          this.#notifyAnyChange(newStore, oldStore);
+        }
+      });
+      if (this.#watcher && "unref" in this.#watcher) {
+        this.#watcher.unref();
+      }
+    } catch {}
+  }
+  #stopWatching() {
+    if (this.#watcher) {
+      this.#watcher.close();
+      this.#watcher = null;
+    }
+  }
+}
+async function encryptStore(data, encryptor) {
+  const result = {};
+  for (const [key, value] of Object.entries(data)) {
+    result[key] = await encryptor.encrypt(JSON.stringify(value));
+  }
+  return result;
+}
+async function decryptStore(data, encryptor) {
+  const result = {};
+  for (const [key, value] of Object.entries(data)) {
+    if (typeof value === "string") {
+      try {
+        const decrypted = await encryptor.decrypt(value);
+        result[key] = JSON.parse(decrypted);
+      } catch {
+        result[key] = value;
+      }
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+export {
+  resolveValidator,
+  resolveConfigPath,
+  resolveConfigDir,
+  createZodValidator,
+  ValidationError,
+  ConfigEngineError,
+  ConfigEngine
+};
+
+//# debugId=61711D0C75DC415164756E2164756E21