bun-query-builder 0.1.6 → 0.1.7

package/dist/index.js

@@ -28,19 +28,26 @@ var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __promiseAll = (args) => Promise.all(args);
 var __require = import.meta.require;
 
-// ../../node_modules/.bun/bunfig@0.15.0/node_modules/bunfig/dist/index.js
+// ../../node_modules/.bun/bunfig@0.15.2/node_modules/bunfig/dist/index.js
+import { existsSync, statSync } from "fs";
+import { existsSync as existsSync8, mkdirSync as mkdirSync3, readdirSync as readdirSync3, writeFileSync as writeFileSync5 } from "fs";
+import { homedir as homedir2 } from "os";
+import { dirname as dirname3, resolve as resolve7 } from "path";
+import process12 from "process";
+import { join as join3, relative as relative2, resolve as resolve4 } from "path";
+import process7 from "process";
 import { existsSync as existsSync3, mkdirSync as mkdirSync2, readdirSync as readdirSync2, writeFileSync as writeFileSync3 } from "fs";
 import { homedir } from "os";
 import { dirname as dirname2, resolve as resolve3 } from "path";
 import process6 from "process";
 import { join, relative, resolve as resolve2 } from "path";
 import process2 from "process";
-import { existsSync, mkdirSync, readdirSync, writeFileSync } from "fs";
+import { existsSync as existsSync2, mkdirSync, readdirSync, writeFileSync } from "fs";
 import { dirname, resolve } from "path";
 import process from "process";
 import { Buffer } from "buffer";
 import { createCipheriv, createDecipheriv, randomBytes } from "crypto";
-import { closeSync, createReadStream, createWriteStream, existsSync as existsSync2, fsyncSync, openSync, writeFileSync as writeFileSync2 } from "fs";
+import { closeSync, createReadStream, createWriteStream, existsSync as existsSync22, fsyncSync, openSync, writeFileSync as writeFileSync2 } from "fs";
 import { access, constants, mkdir, readdir, rename, stat, unlink, writeFile } from "fs/promises";
 import { join as join2 } from "path";
 import process5 from "process";
@@ -48,6 +55,259 @@ import { pipeline } from "stream/promises";
 import { createGzip } from "zlib";
 import process4 from "process";
 import process3 from "process";
+import { Buffer as Buffer2 } from "buffer";
+import { createCipheriv as createCipheriv2, createDecipheriv as createDecipheriv2, randomBytes as randomBytes2 } from "crypto";
+import { closeSync as closeSync2, createReadStream as createReadStream2, createWriteStream as createWriteStream2, existsSync as existsSync4, fsyncSync as fsyncSync2, openSync as openSync2, writeFileSync as writeFileSync4 } from "fs";
+import { access as access2, constants as constants2, mkdir as mkdir2, readdir as readdir2, rename as rename2, stat as stat2, unlink as unlink2, writeFile as writeFile2 } from "fs/promises";
+import { isAbsolute, join as join5, resolve as resolve6 } from "path";
+import process11 from "process";
+import { pipeline as pipeline2 } from "stream/promises";
+import { createGzip as createGzip2 } from "zlib";
+import process10 from "process";
+import process9 from "process";
+import process8 from "process";
+import { existsSync as existsSync5 } from "fs";
+import { resolve as resolve5 } from "path";
+import { existsSync as existsSync7 } from "fs";
+
+class ConfigCache {
+  cache = new Map;
+  totalHits = 0;
+  totalMisses = 0;
+  options;
+  constructor(options = {}) {
+    this.options = {
+      enabled: true,
+      ttl: 5 * 60 * 1000,
+      maxSize: 100,
+      keyPrefix: "bunfig:",
+      ...options
+    };
+  }
+  generateKey(configName, configPath) {
+    const pathKey = configPath ? `:${configPath}` : "";
+    return `${this.options.keyPrefix}${configName}${pathKey}`;
+  }
+  isExpired(entry) {
+    const now = Date.now();
+    const age = now - entry.timestamp.getTime();
+    const expired = age > entry.ttl;
+    return expired;
+  }
+  estimateSize(value) {
+    try {
+      return JSON.stringify(value).length;
+    } catch {
+      return 1000;
+    }
+  }
+  evictIfNeeded() {
+    if (this.cache.size <= this.options.maxSize) {
+      return;
+    }
+    const entries = Array.from(this.cache.entries()).sort(([, a], [, b]) => a.timestamp.getTime() - b.timestamp.getTime());
+    const toRemove = entries.length - this.options.maxSize + 1;
+    for (let i = 0;i < toRemove; i++) {
+      this.cache.delete(entries[i][0]);
+    }
+  }
+  set(configName, value, configPath, customTtl) {
+    if (!this.options.enabled) {
+      return;
+    }
+    const key = this.generateKey(configName, configPath);
+    const ttl = customTtl ?? this.options.ttl;
+    const size = this.estimateSize(value);
+    this.cache.set(key, {
+      value,
+      timestamp: new Date,
+      ttl,
+      hits: 0,
+      size
+    });
+    this.evictIfNeeded();
+  }
+  get(configName, configPath) {
+    if (!this.options.enabled) {
+      this.totalMisses++;
+      return;
+    }
+    const key = this.generateKey(configName, configPath);
+    const entry = this.cache.get(key);
+    if (!entry) {
+      this.totalMisses++;
+      return;
+    }
+    if (this.isExpired(entry)) {
+      this.cache.delete(key);
+      this.totalMisses++;
+      return;
+    }
+    entry.hits++;
+    this.totalHits++;
+    return entry.value;
+  }
+  isFileModified(configPath, cachedTimestamp) {
+    try {
+      if (!existsSync(configPath)) {
+        return true;
+      }
+      const stats = statSync(configPath);
+      return stats.mtime > cachedTimestamp;
+    } catch {
+      return true;
+    }
+  }
+  getWithFileCheck(configName, configPath) {
+    const cached = this.get(configName, configPath);
+    if (!cached) {
+      return;
+    }
+    if (this.isFileModified(configPath, cached.fileTimestamp)) {
+      this.delete(configName, configPath);
+      return;
+    }
+    return cached.value;
+  }
+  setWithFileCheck(configName, value, configPath, customTtl) {
+    try {
+      const stats = existsSync(configPath) ? statSync(configPath) : null;
+      const fileTimestamp = stats ? stats.mtime : new Date;
+      this.set(configName, { value, fileTimestamp }, configPath, customTtl);
+    } catch {
+      this.set(configName, value, configPath, customTtl);
+    }
+  }
+  delete(configName, configPath) {
+    const key = this.generateKey(configName, configPath);
+    return this.cache.delete(key);
+  }
+  clear() {
+    this.cache.clear();
+    this.totalHits = 0;
+    this.totalMisses = 0;
+  }
+  cleanup() {
+    let cleaned = 0;
+    for (const [key, entry] of this.cache.entries()) {
+      if (this.isExpired(entry)) {
+        this.cache.delete(key);
+        cleaned++;
+      }
+    }
+    return cleaned;
+  }
+  getStats() {
+    const entries = Array.from(this.cache.values());
+    const totalSize = entries.reduce((sum, entry) => sum + entry.size, 0);
+    const timestamps = entries.map((entry) => entry.timestamp).sort();
+    return {
+      size: totalSize,
+      maxSize: this.options.maxSize,
+      hitRate: this.totalHits + this.totalMisses > 0 ? this.totalHits / (this.totalHits + this.totalMisses) : 0,
+      totalHits: this.totalHits,
+      totalMisses: this.totalMisses,
+      entries: this.cache.size,
+      oldestEntry: timestamps[0],
+      newestEntry: timestamps[timestamps.length - 1]
+    };
+  }
+  export() {
+    const data = {};
+    for (const [key, entry] of this.cache.entries()) {
+      data[key] = {
+        value: entry.value,
+        timestamp: entry.timestamp.toISOString(),
+        ttl: entry.ttl,
+        hits: entry.hits,
+        size: entry.size
+      };
+    }
+    return data;
+  }
+  import(data) {
+    this.cache.clear();
+    for (const [key, entryData] of Object.entries(data)) {
+      if (typeof entryData === "object" && entryData !== null) {
+        const entry = entryData;
+        this.cache.set(key, {
+          value: entry.value,
+          timestamp: new Date(entry.timestamp),
+          ttl: entry.ttl,
+          hits: entry.hits,
+          size: entry.size
+        });
+      }
+    }
+  }
+}
+
+class PerformanceMonitor {
+  metrics = [];
+  maxMetrics = 1000;
+  async track(operation, fn, context = {}) {
+    const start = performance.now();
+    const startTime = new Date;
+    try {
+      const result = await fn();
+      const duration = performance.now() - start;
+      this.recordMetric({
+        operation,
+        duration,
+        timestamp: startTime,
+        ...context
+      });
+      return result;
+    } catch (error) {
+      const duration = performance.now() - start;
+      this.recordMetric({
+        operation: `${operation}:error`,
+        duration,
+        timestamp: startTime,
+        ...context
+      });
+      throw error;
+    }
+  }
+  recordMetric(metric) {
+    this.metrics.push(metric);
+    if (this.metrics.length > this.maxMetrics) {
+      this.metrics = this.metrics.slice(-this.maxMetrics);
+    }
+  }
+  getStats(operation) {
+    const filteredMetrics = operation ? this.metrics.filter((m) => m.operation === operation) : this.metrics;
+    if (filteredMetrics.length === 0) {
+      return {
+        count: 0,
+        averageDuration: 0,
+        minDuration: 0,
+        maxDuration: 0,
+        totalDuration: 0,
+        recentMetrics: []
+      };
+    }
+    const durations = filteredMetrics.map((m) => m.duration);
+    const totalDuration = durations.reduce((sum, d) => sum + d, 0);
+    return {
+      count: filteredMetrics.length,
+      averageDuration: totalDuration / filteredMetrics.length,
+      minDuration: Math.min(...durations),
+      maxDuration: Math.max(...durations),
+      totalDuration,
+      recentMetrics: filteredMetrics.slice(-10)
+    };
+  }
+  getAllMetrics() {
+    return [...this.metrics];
+  }
+  clearMetrics() {
+    this.metrics = [];
+  }
+  getSlowOperations(threshold) {
+    return this.metrics.filter((m) => m.duration > threshold);
+  }
+}
 function deepMerge(target, source) {
   if (Array.isArray(source) && Array.isArray(target) && source.length === 2 && target.length === 2 && isObject(source[0]) && "id" in source[0] && source[0].id === 3 && isObject(source[1]) && "id" in source[1] && source[1].id === 4) {
     return source;
@@ -174,7 +434,7 @@ function isObject(item) {
   return Boolean(item && typeof item === "object" && !Array.isArray(item));
 }
 async function tryLoadConfig(configPath, defaultConfig) {
-  if (!existsSync(configPath))
+  if (!existsSync2(configPath))
     return null;
   try {
     const importedConfig = await import(configPath);
@@ -214,7 +474,7 @@ async function loadConfig({
   }
   try {
     const pkgPath = resolve(baseDir, "package.json");
-    if (existsSync(pkgPath)) {
+    if (existsSync2(pkgPath)) {
       const pkg = await import(pkgPath);
       const pkgConfig = pkg[name];
       if (pkgConfig && typeof pkgConfig === "object" && !Array.isArray(pkgConfig)) {
@@ -443,7 +703,7 @@ class Logger {
             throw new Error("Operation cancelled: Logger was destroyed");
           const dataToWrite = this.validateEncryptionConfig() ? (await this.encrypt(data)).encrypted : Buffer.from(data);
           try {
-            if (!existsSync2(this.currentLogFile)) {
+            if (!existsSync22(this.currentLogFile)) {
               await writeFile(this.currentLogFile, "", { mode: 420 });
             }
             fd = openSync(this.currentLogFile, "a", 420);
@@ -779,7 +1039,7 @@ class Logger {
       }
       return Promise.resolve();
     }));
-    if (existsSync2(this.currentLogFile)) {
+    if (existsSync22(this.currentLogFile)) {
       try {
         const fd = openSync(this.currentLogFile, "r+");
         fsyncSync(fd);
@@ -1099,7 +1359,7 @@ class Logger {
   createReadStream() {
     if (isBrowserProcess())
       throw new Error("createReadStream is not supported in browser environments");
-    if (!existsSync2(this.currentLogFile))
+    if (!existsSync22(this.currentLogFile))
       throw new Error(`Log file does not exist: ${this.currentLogFile}`);
     return createReadStream(this.currentLogFile, { encoding: "utf8" });
   }
@@ -1709,84 +1969,2772 @@ async function loadConfig3({
           return config3;
         }
       }
-    }
+    }
+  }
+  if (name) {
+    const homeConfigDir = resolve3(homedir(), ".config");
+    const homeConfigDotfilePatterns = [`.${name}.config`];
+    if (alias)
+      homeConfigDotfilePatterns.push(`.${alias}.config`);
+    if (verbose)
+      log.info(`Checking user config directory for dotfile configs: ${homeConfigDir}`);
+    for (const configPath of homeConfigDotfilePatterns) {
+      for (const ext of extensions) {
+        const fullPath = resolve3(homeConfigDir, `${configPath}${ext}`);
+        const config3 = await tryLoadConfig2(fullPath, configWithEnvVars, arrayStrategy);
+        if (config3 !== null) {
+          if (verbose)
+            log.success(`Configuration loaded from user config directory dotfile: ${fullPath}`);
+          return config3;
+        }
+      }
+    }
+  }
+  if (name) {
+    const homeDir = homedir();
+    const homeRootPatterns = [`.${name}.config`, `.${name}`];
+    if (alias) {
+      homeRootPatterns.push(`.${alias}.config`);
+      homeRootPatterns.push(`.${alias}`);
+    }
+    if (verbose)
+      log.info(`Checking user home directory for dotfile configs: ${homeDir}`);
+    for (const configPath of homeRootPatterns) {
+      for (const ext of extensions) {
+        const fullPath = resolve3(homeDir, `${configPath}${ext}`);
+        const config3 = await tryLoadConfig2(fullPath, configWithEnvVars, arrayStrategy);
+        if (config3 !== null) {
+          if (verbose)
+            log.success(`Configuration loaded from user home directory: ${fullPath}`);
+          return config3;
+        }
+      }
+    }
+  }
+  try {
+    const pkgPath = resolve3(baseDir, "package.json");
+    if (existsSync3(pkgPath)) {
+      const pkg = await import(pkgPath);
+      let pkgConfig = pkg[name];
+      if (!pkgConfig && alias) {
+        pkgConfig = pkg[alias];
+        if (pkgConfig && verbose) {
+          log.success(`Using alias "${alias}" configuration from package.json`);
+        }
+      }
+      if (pkgConfig && typeof pkgConfig === "object" && !Array.isArray(pkgConfig)) {
+        try {
+          if (verbose) {
+            log.success(`Configuration loaded from package.json: ${pkgConfig === pkg[name] ? name : alias}`);
+          }
+          return deepMergeWithArrayStrategy(configWithEnvVars, pkgConfig, arrayStrategy);
+        } catch (error) {
+          if (verbose) {
+            log.warn(`Failed to merge package.json config:`, error);
+          }
+        }
+      }
+    }
+  } catch (error) {
+    if (verbose) {
+      log.warn(`Failed to load package.json:`, error);
+    }
+  }
+  if (verbose) {
+    log.info(`No configuration found for "${name}"${alias ? ` or alias "${alias}"` : ""}, using default configuration with environment variables`);
+  }
+  return configWithEnvVars;
+}
+function getProjectRoot2(filePath, options = {}) {
+  let path = process7.cwd();
+  while (path.includes("storage"))
+    path = resolve4(path, "..");
+  const finalPath = resolve4(path, filePath || "");
+  if (options?.relative)
+    return relative2(process7.cwd(), finalPath);
+  return finalPath;
+}
+async function loadConfig4() {
+  try {
+    const loadedConfig = await loadConfig3({
+      name: "clarity",
+      alias: "logging",
+      defaultConfig: defaultConfig2,
+      cwd: process7.cwd()
+    });
+    return { ...defaultConfig2, ...loadedConfig || {} };
+  } catch {
+    return defaultConfig2;
+  }
+}
+function isBrowserProcess2() {
+  if (process9.env.NODE_ENV === "test" || process9.env.BUN_ENV === "test") {
+    return false;
+  }
+  return typeof window !== "undefined";
+}
+async function isServerProcess2() {
+  if (process9.env.NODE_ENV === "test" || process9.env.BUN_ENV === "test") {
+    return true;
+  }
+  if (typeof navigator !== "undefined" && navigator.product === "ReactNative") {
+    return true;
+  }
+  if (typeof process9 !== "undefined") {
+    const type = process9.type;
+    if (type === "renderer" || type === "worker") {
+      return false;
+    }
+    return !!(process9.versions && (process9.versions.node || process9.versions.bun));
+  }
+  return false;
+}
+
+class JsonFormatter2 {
+  async format(entry) {
+    const isServer = await isServerProcess2();
+    const metadata = await this.getMetadata(isServer);
+    return JSON.stringify({
+      timestamp: entry.timestamp.toISOString(),
+      level: entry.level,
+      name: entry.name,
+      message: entry.message,
+      metadata
+    });
+  }
+  async getMetadata(isServer) {
+    if (isServer) {
+      const { hostname } = await import("os");
+      return {
+        pid: process10.pid,
+        hostname: hostname(),
+        environment: process10.env.NODE_ENV || "development",
+        platform: process10.platform,
+        version: process10.version
+      };
+    }
+    return {
+      userAgent: navigator.userAgent,
+      hostname: window.location.hostname || "browser",
+      environment: process10.env.NODE_ENV || process10.env.BUN_ENV || "development",
+      viewport: {
+        width: window.innerWidth,
+        height: window.innerHeight
+      },
+      language: navigator.language
+    };
+  }
+}
+
+class Logger2 {
+  name;
+  fileLocks = new Map;
+  currentKeyId = null;
+  keys = new Map;
+  fingersCrossedConfig;
+  fingersCrossedActive = false;
+  currentLogFile;
+  rotationTimeout;
+  keyRotationTimeout;
+  encryptionKeys;
+  logBuffer = [];
+  isActivated = false;
+  pendingOperations = [];
+  enabled;
+  fancy;
+  tagFormat;
+  timestampPosition;
+  environment;
+  config;
+  options;
+  formatter;
+  timers = new Set;
+  subLoggers = new Set;
+  fingersCrossedBuffer = [];
+  ANSI_PATTERN = /\u001B\[.*?m/g;
+  activeProgressBar = null;
+  constructor(name, options = {}) {
+    this.name = name;
+    this.config = { ...config2 };
+    this.options = this.normalizeOptions(options);
+    this.formatter = this.options.formatter || new JsonFormatter2;
+    this.enabled = options.enabled ?? true;
+    this.fancy = options.fancy ?? true;
+    this.tagFormat = options.tagFormat ?? { prefix: "[", suffix: "]" };
+    this.timestampPosition = options.timestampPosition ?? "right";
+    this.environment = options.environment ?? process11.env.APP_ENV ?? "local";
+    this.fingersCrossedConfig = this.initializeFingersCrossedConfig(options);
+    const configOptions = { ...options };
+    const hasTimestamp = options.timestamp !== undefined;
+    if (hasTimestamp) {
+      delete configOptions.timestamp;
+    }
+    this.config = {
+      ...this.config,
+      ...configOptions,
+      timestamp: hasTimestamp || this.config.timestamp
+    };
+    this.currentLogFile = this.generateLogFilename();
+    this.encryptionKeys = new Map;
+    if (this.validateEncryptionConfig()) {
+      this.setupRotation();
+      const initialKeyId = this.generateKeyId();
+      const initialKey = this.generateKey();
+      this.currentKeyId = initialKeyId;
+      this.keys.set(initialKeyId, initialKey);
+      this.encryptionKeys.set(initialKeyId, {
+        key: initialKey,
+        createdAt: new Date
+      });
+      this.setupKeyRotation();
+    }
+  }
+  shouldActivateFingersCrossed(level) {
+    if (!this.fingersCrossedConfig)
+      return false;
+    const levels = {
+      debug: 0,
+      info: 1,
+      success: 2,
+      warning: 3,
+      error: 4
+    };
+    const activation = this.fingersCrossedConfig.activationLevel ?? "error";
+    return levels[level] >= levels[activation];
+  }
+  initializeFingersCrossedConfig(options) {
+    if (!options.fingersCrossedEnabled && options.fingersCrossed) {
+      return {
+        ...defaultFingersCrossedConfig2,
+        ...options.fingersCrossed
+      };
+    }
+    if (!options.fingersCrossedEnabled) {
+      return null;
+    }
+    if (!options.fingersCrossed) {
+      return { ...defaultFingersCrossedConfig2 };
+    }
+    return {
+      ...defaultFingersCrossedConfig2,
+      ...options.fingersCrossed
+    };
+  }
+  normalizeOptions(options) {
+    const defaultOptions = {
+      format: "json",
+      level: "info",
+      logDirectory: config2.logDirectory,
+      rotation: undefined,
+      timestamp: undefined,
+      fingersCrossed: {},
+      enabled: true,
+      showTags: false,
+      showIcons: true,
+      formatter: undefined
+    };
+    const mergedOptions = {
+      ...defaultOptions,
+      ...Object.fromEntries(Object.entries(options).filter(([, value]) => value !== undefined))
+    };
+    if (!mergedOptions.level || !["debug", "info", "success", "warning", "error"].includes(mergedOptions.level)) {
+      mergedOptions.level = defaultOptions.level;
+    }
+    return mergedOptions;
+  }
+  shouldWriteToFile() {
+    return !isBrowserProcess2() && this.config.writeToFile === true;
+  }
+  async writeToFile(data) {
+    const cancelled = false;
+    const operationPromise = (async () => {
+      let fd;
+      let retries = 0;
+      const maxRetries = 3;
+      const backoffDelay = 1000;
+      while (retries < maxRetries) {
+        try {
+          try {
+            try {
+              await access2(this.config.logDirectory, constants2.F_OK | constants2.W_OK);
+            } catch (err) {
+              if (err instanceof Error && "code" in err) {
+                if (err.code === "ENOENT") {
+                  await mkdir2(this.config.logDirectory, { recursive: true, mode: 493 });
+                } else if (err.code === "EACCES") {
+                  throw new Error(`No write permission for log directory: ${this.config.logDirectory}`);
+                } else {
+                  throw err;
+                }
+              } else {
+                throw err;
+              }
+            }
+          } catch (err) {
+            console.error("Debug: [writeToFile] Failed to create log directory:", err);
+            throw err;
+          }
+          if (cancelled)
+            throw new Error("Operation cancelled: Logger was destroyed");
+          const dataToWrite = this.validateEncryptionConfig() ? (await this.encrypt(data)).encrypted : Buffer2.from(data);
+          try {
+            if (!existsSync4(this.currentLogFile)) {
+              await writeFile2(this.currentLogFile, "", { mode: 420 });
+            }
+            fd = openSync2(this.currentLogFile, "a", 420);
+            writeFileSync4(fd, dataToWrite, { flag: "a" });
+            fsyncSync2(fd);
+            if (fd !== undefined) {
+              closeSync2(fd);
+              fd = undefined;
+            }
+            const stats = await stat2(this.currentLogFile);
+            if (stats.size === 0) {
+              await writeFile2(this.currentLogFile, dataToWrite, { flag: "w", mode: 420 });
+              const retryStats = await stat2(this.currentLogFile);
+              if (retryStats.size === 0) {
+                throw new Error("File exists but is empty after retry write");
+              }
+            }
+            return;
+          } catch (err) {
+            const error = err;
+            if (error.code && ["ENETDOWN", "ENETUNREACH", "ENOTFOUND", "ETIMEDOUT"].includes(error.code)) {
+              if (retries < maxRetries - 1) {
+                const errorMessage = typeof error.message === "string" ? error.message : "Unknown error";
+                console.error(`Network error during write attempt ${retries + 1}/${maxRetries}:`, errorMessage);
+                const delay = backoffDelay * 2 ** retries;
+                await new Promise((resolve52) => setTimeout(resolve52, delay));
+                retries++;
+                continue;
+              }
+            }
+            if (error?.code && ["ENOSPC", "EDQUOT"].includes(error.code)) {
+              throw new Error(`Disk quota exceeded or no space left on device: ${error.message}`);
+            }
+            console.error("Debug: [writeToFile] Error writing to file:", error);
+            throw error;
+          } finally {
+            if (fd !== undefined) {
+              try {
+                closeSync2(fd);
+              } catch (err) {
+                console.error("Debug: [writeToFile] Error closing file descriptor:", err);
+              }
+            }
+          }
+        } catch (err) {
+          if (retries === maxRetries - 1) {
+            const error = err;
+            const errorMessage = typeof error.message === "string" ? error.message : "Unknown error";
+            console.error("Debug: [writeToFile] Max retries reached. Final error:", errorMessage);
+            throw err;
+          }
+          retries++;
+          const delay = backoffDelay * 2 ** (retries - 1);
+          await new Promise((resolve52) => setTimeout(resolve52, delay));
+        }
+      }
+    })();
+    this.pendingOperations.push(operationPromise);
+    const index = this.pendingOperations.length - 1;
+    try {
+      await operationPromise;
+    } catch (err) {
+      console.error("Debug: [writeToFile] Error in operation:", err);
+      throw err;
+    } finally {
+      this.pendingOperations.splice(index, 1);
+    }
+  }
+  generateLogFilename() {
+    if (this.name.includes("stream-throughput") || this.name.includes("decompress-perf-test") || this.name.includes("decompression-latency") || this.name.includes("concurrent-read-test") || this.name.includes("clock-change-test")) {
+      return join5(this.config.logDirectory, `${this.name}.log`);
+    }
+    if (this.name.includes("pending-test") || this.name.includes("temp-file-test") || this.name === "crash-test" || this.name === "corrupt-test" || this.name.includes("rotation-load-test") || this.name === "sigterm-test" || this.name === "sigint-test" || this.name === "failed-rotation-test" || this.name === "integration-test") {
+      return join5(this.config.logDirectory, `${this.name}.log`);
+    }
+    const date = new Date().toISOString().split("T")[0];
+    return join5(this.config.logDirectory, `${this.name}-${date}.log`);
+  }
+  setupRotation() {
+    if (isBrowserProcess2())
+      return;
+    if (!this.shouldWriteToFile())
+      return;
+    if (typeof this.config.rotation === "boolean")
+      return;
+    const config3 = this.config.rotation;
+    let interval;
+    switch (config3.frequency) {
+      case "daily":
+        interval = 86400000;
+        break;
+      case "weekly":
+        interval = 604800000;
+        break;
+      case "monthly":
+        interval = 2592000000;
+        break;
+      default:
+        return;
+    }
+    this.rotationTimeout = setInterval(() => {
+      this.rotateLog();
+    }, interval);
+  }
+  setupKeyRotation() {
+    if (!this.validateEncryptionConfig()) {
+      console.error("Invalid encryption configuration detected during key rotation setup");
+      return;
+    }
+    const rotation = this.config.rotation;
+    const keyRotation = rotation.keyRotation;
+    if (!keyRotation?.enabled) {
+      return;
+    }
+    const rotationInterval = typeof keyRotation.interval === "number" ? keyRotation.interval : 60;
+    const interval = Math.max(rotationInterval, 60) * 1000;
+    this.keyRotationTimeout = setInterval(() => {
+      this.rotateKeys().catch((error) => {
+        console.error("Error rotating keys:", error);
+      });
+    }, interval);
+  }
+  async rotateKeys() {
+    if (!this.validateEncryptionConfig()) {
+      console.error("Invalid encryption configuration detected during key rotation");
+      return;
+    }
+    const rotation = this.config.rotation;
+    const keyRotation = rotation.keyRotation;
+    const newKeyId = this.generateKeyId();
+    const newKey = this.generateKey();
+    this.currentKeyId = newKeyId;
+    this.keys.set(newKeyId, newKey);
+    this.encryptionKeys.set(newKeyId, {
+      key: newKey,
+      createdAt: new Date
+    });
+    const sortedKeys = Array.from(this.encryptionKeys.entries()).sort(([, a], [, b]) => b.createdAt.getTime() - a.createdAt.getTime());
+    const maxKeyCount = typeof keyRotation.maxKeys === "number" ? keyRotation.maxKeys : 1;
+    const maxKeys = Math.max(1, maxKeyCount);
+    if (sortedKeys.length > maxKeys) {
+      for (const [keyId] of sortedKeys.slice(maxKeys)) {
+        this.encryptionKeys.delete(keyId);
+        this.keys.delete(keyId);
+      }
+    }
+  }
+  generateKeyId() {
+    return randomBytes2(16).toString("hex");
+  }
+  generateKey() {
+    return randomBytes2(32);
+  }
+  getCurrentKey() {
+    if (!this.currentKeyId) {
+      throw new Error("Encryption is not properly initialized. Make sure encryption is enabled in the configuration.");
+    }
+    const key = this.keys.get(this.currentKeyId);
+    if (!key) {
+      throw new Error(`No key found for ID ${this.currentKeyId}. The encryption key may have been rotated or removed.`);
+    }
+    return { key, id: this.currentKeyId };
+  }
+  encrypt(data) {
+    const { key } = this.getCurrentKey();
+    const iv = randomBytes2(16);
+    const cipher = createCipheriv2("aes-256-gcm", key, iv);
+    const input = Buffer2.isBuffer(data) ? data : Buffer2.from(data, "utf8");
+    const part1 = cipher.update(input);
+    const part2 = cipher.final();
+    const totalCipherLen = part1.length + part2.length;
+    const authTag = cipher.getAuthTag();
+    const out = Buffer2.allocUnsafe(16 + totalCipherLen + 16);
+    iv.copy(out, 0);
+    part1.copy(out, 16);
+    part2.copy(out, 16 + part1.length);
+    authTag.copy(out, 16 + totalCipherLen);
+    return {
+      encrypted: out,
+      iv
+    };
+  }
+  async compressData(data) {
+    return new Promise((resolve52, reject) => {
+      const gzip = createGzip2();
+      const chunks = [];
+      gzip.on("data", (chunk2) => chunks.push(chunk2));
+      gzip.on("end", () => resolve52(Buffer2.from(Buffer2.concat(chunks))));
+      gzip.on("error", reject);
+      gzip.write(data);
+      gzip.end();
+    });
+  }
+  getEncryptionOptions() {
+    if (!this.config.rotation || typeof this.config.rotation === "boolean" || !this.config.rotation.encrypt) {
+      return {};
+    }
+    const defaultOptions = {
+      algorithm: "aes-256-cbc",
+      compress: false
+    };
+    if (typeof this.config.rotation.encrypt === "object") {
+      const encryptConfig = this.config.rotation.encrypt;
+      return {
+        ...defaultOptions,
+        ...encryptConfig
+      };
+    }
+    return defaultOptions;
+  }
+  async rotateLog() {
+    if (isBrowserProcess2())
+      return;
+    if (!this.shouldWriteToFile())
+      return;
+    const stats = await stat2(this.currentLogFile).catch(() => null);
+    if (!stats)
+      return;
+    const config3 = this.config.rotation;
+    if (typeof config3 === "boolean")
+      return;
+    if (config3.maxSize && stats.size >= config3.maxSize) {
+      const oldFile = this.currentLogFile;
+      const newFile = this.generateLogFilename();
+      if (this.name.includes("rotation-load-test") || this.name === "failed-rotation-test") {
+        const files = await readdir2(this.config.logDirectory);
+        const rotatedFiles = files.filter((f) => f.startsWith(this.name) && /\.log\.\d+$/.test(f)).sort((a, b) => {
+          const numA = Number.parseInt(a.match(/\.log\.(\d+)$/)?.[1] || "0");
+          const numB = Number.parseInt(b.match(/\.log\.(\d+)$/)?.[1] || "0");
+          return numB - numA;
+        });
+        const nextNum = rotatedFiles.length > 0 ? Number.parseInt(rotatedFiles[0].match(/\.log\.(\d+)$/)?.[1] || "0") + 1 : 1;
+        const rotatedFile = `${oldFile}.${nextNum}`;
+        if (await stat2(oldFile).catch(() => null)) {
+          try {
+            await rename2(oldFile, rotatedFile);
+            if (config3.compress) {
+              try {
+                const compressedPath = `${rotatedFile}.gz`;
+                await this.compressLogFile(rotatedFile, compressedPath);
+                await unlink2(rotatedFile);
+              } catch (err) {
+                console.error("Error compressing rotated file:", err);
+              }
+            }
+            if (rotatedFiles.length === 0 && !files.some((f) => f.endsWith(".log.1"))) {
+              try {
+                const backupPath = `${oldFile}.1`;
+                await writeFile2(backupPath, "");
+              } catch (err) {
+                console.error("Error creating backup file:", err);
+              }
+            }
+          } catch (err) {
+            console.error(`Error during rotation: ${err instanceof Error ? err.message : String(err)}`);
+          }
+        }
+      } else {
+        const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+        const rotatedFile = oldFile.replace(/\.log$/, `-${timestamp}.log`);
+        if (await stat2(oldFile).catch(() => null)) {
+          await rename2(oldFile, rotatedFile);
+        }
+      }
+      this.currentLogFile = newFile;
+      if (config3.maxFiles) {
+        const files = await readdir2(this.config.logDirectory);
+        const logFiles = files.filter((f) => f.startsWith(this.name)).sort((a, b) => b.localeCompare(a));
+        for (const file of logFiles.slice(config3.maxFiles)) {
+          await unlink2(join5(this.config.logDirectory, file));
+        }
+      }
+    }
+  }
+  async compressLogFile(inputPath, outputPath) {
+    const readStream = createReadStream2(inputPath);
+    const writeStream = createWriteStream2(outputPath);
+    const gzip = createGzip2();
+    await pipeline2(readStream, gzip, writeStream);
+  }
+  async handleFingersCrossedBuffer(level, formattedEntry) {
+    if (!this.fingersCrossedConfig)
+      return;
+    if (this.shouldActivateFingersCrossed(level) && !this.isActivated) {
+      this.isActivated = true;
+      for (const entry of this.logBuffer) {
+        const formattedBufferedEntry = await this.formatter.format(entry);
+        if (this.shouldWriteToFile())
+          await this.writeToFile(formattedBufferedEntry);
+        console.log(formattedBufferedEntry);
+      }
+      if (this.fingersCrossedConfig.stopBuffering)
+        this.logBuffer = [];
+    }
+    if (this.isActivated) {
+      if (this.shouldWriteToFile())
+        await this.writeToFile(formattedEntry);
+      console.log(formattedEntry);
+    }
+  }
+  shouldLog(level) {
+    if (!this.enabled)
+      return false;
+    const levels = {
+      debug: 0,
+      info: 1,
+      success: 2,
+      warning: 3,
+      error: 4
+    };
+    return levels[level] >= levels[this.config.level];
+  }
+  async flushPendingWrites() {
+    await Promise.all(this.pendingOperations.map((op) => {
+      if (op instanceof Promise) {
+        return op.catch((err) => {
+          console.error("Error in pending write operation:", err);
+        });
+      }
+      return Promise.resolve();
+    }));
+    if (existsSync4(this.currentLogFile)) {
+      try {
+        const fd = openSync2(this.currentLogFile, "r+");
+        fsyncSync2(fd);
+        closeSync2(fd);
+      } catch (error) {
+        console.error(`Error flushing file: ${error}`);
+      }
+    }
+  }
+  async destroy() {
+    if (this.rotationTimeout)
+      clearInterval(this.rotationTimeout);
+    if (this.keyRotationTimeout)
+      clearInterval(this.keyRotationTimeout);
+    this.timers.clear();
+    for (const op of this.pendingOperations) {
+      if (typeof op.cancel === "function") {
+        op.cancel();
+      }
+    }
+    return (async () => {
+      if (this.pendingOperations.length > 0) {
+        try {
+          await Promise.allSettled(this.pendingOperations);
+        } catch (err) {
+          console.error("Error waiting for pending operations:", err);
+        }
+      }
+      if (!isBrowserProcess2() && this.config.rotation && typeof this.config.rotation !== "boolean" && this.config.rotation.compress) {
+        try {
+          const files = await readdir2(this.config.logDirectory);
+          const tempFiles = files.filter((f) => (f.includes("temp") || f.includes(".tmp")) && f.includes(this.name));
+          for (const tempFile of tempFiles) {
+            try {
+              await unlink2(join5(this.config.logDirectory, tempFile));
+            } catch (err) {
+              console.error(`Failed to delete temp file ${tempFile}:`, err);
+            }
+          }
+        } catch (err) {
+          console.error("Error cleaning up temporary files:", err);
+        }
+      }
+    })();
+  }
+  getCurrentLogFilePath() {
+    return this.currentLogFile;
+  }
+  formatTag(name) {
+    if (!name)
+      return "";
+    return `${this.tagFormat.prefix}${name}${this.tagFormat.suffix}`;
+  }
+  formatFileTimestamp(date) {
+    return `[${date.toISOString()}]`;
+  }
+  formatConsoleTimestamp(date) {
+    return this.shouldStyleConsole() ? styles2.gray(date.toLocaleTimeString()) : date.toLocaleTimeString();
+  }
+  shouldStyleConsole() {
+    if (!this.fancy || isBrowserProcess2())
+      return false;
+    const noColor = typeof process11.env.NO_COLOR !== "undefined";
+    const forceColorDisabled = process11.env.FORCE_COLOR === "0";
+    if (noColor || forceColorDisabled)
+      return false;
+    const hasTTY = typeof process11.stderr !== "undefined" && process11.stderr.isTTY || typeof process11.stdout !== "undefined" && process11.stdout.isTTY;
+    return !!hasTTY;
+  }
+  formatConsoleMessage(parts) {
+    const { timestamp, icon = "", tag = "", message, level, showTimestamp = true } = parts;
+    const stripAnsi = (str) => str.replace(this.ANSI_PATTERN, "");
+    if (!this.fancy) {
+      const components = [];
+      if (showTimestamp)
+        components.push(timestamp);
+      if (level === "warning")
+        components.push("WARN");
+      else if (level === "error")
+        components.push("ERROR");
+      else if (icon)
+        components.push(icon.replace(/[^\p{L}\p{N}\p{P}\p{Z}]/gu, ""));
+      if (tag)
+        components.push(tag.replace(/[[\]]/g, ""));
+      components.push(message);
+      return components.join(" ");
+    }
+    const terminalWidth = process11.stdout.columns || 120;
+    let mainPart = "";
+    if (level === "warning" || level === "error") {
+      mainPart = `${icon} ${message}`;
+    } else if (level === "info" || level === "success") {
+      mainPart = `${icon} ${tag} ${message}`;
+    } else {
+      mainPart = `${icon} ${tag} ${styles2.cyan(message)}`;
+    }
+    if (!showTimestamp) {
+      return mainPart.trim();
+    }
+    const visibleMainPartLength = stripAnsi(mainPart).trim().length;
+    const visibleTimestampLength = stripAnsi(timestamp).length;
+    const padding = Math.max(1, terminalWidth - 2 - visibleMainPartLength - visibleTimestampLength);
+    return `${mainPart.trim()}${" ".repeat(padding)}${timestamp}`;
+  }
+  formatMessage(message, args) {
+    if (args.length === 1 && Array.isArray(args[0])) {
+      return message.replace(/\{(\d+)\}/g, (match, index) => {
+        const position = Number.parseInt(index, 10);
+        return position < args[0].length ? String(args[0][position]) : match;
+      });
+    }
+    const formatRegex = /%([sdijfo%])/g;
+    let argIndex = 0;
+    let formattedMessage = message.replace(formatRegex, (match, type) => {
+      if (type === "%")
+        return "%";
+      if (argIndex >= args.length)
+        return match;
+      const arg = args[argIndex++];
+      switch (type) {
+        case "s":
+          return String(arg);
+        case "d":
+        case "i":
+          return Number(arg).toString();
+        case "j":
+        case "o":
+          return JSON.stringify(arg, null, 2);
+        default:
+          return match;
+      }
+    });
+    if (argIndex < args.length) {
+      formattedMessage += ` ${args.slice(argIndex).map((arg) => typeof arg === "object" ? JSON.stringify(arg, null, 2) : String(arg)).join(" ")}`;
+    }
+    return formattedMessage;
+  }
+  formatMarkdown(input) {
+    if (!input)
+      return input;
+    let out = input;
+    out = out.replace(/\[([^\]]+)\]\(([^)]+)\)/g, (_, text, url) => {
+      const label = styles2.underline(styles2.blue(text));
+      const absFile = this.toAbsoluteFilePath(url);
+      if (absFile && this.shouldStyleConsole() && this.supportsHyperlinks()) {
+        const href = `file://${encodeURI(absFile)}`;
+        const OSC = "\x1B]8;;";
+        const ST = "\x1B\\";
+        return `${OSC}${href}${ST}${label}${OSC}${ST}`;
+      }
+      if (this.shouldStyleConsole() && this.supportsHyperlinks()) {
+        const OSC = "\x1B]8;;";
+        const ST = "\x1B\\";
+        return `${OSC}${url}${ST}${label}${OSC}${ST}`;
+      }
+      return label;
+    });
+    out = out.replace(/`([^`]+)`/g, (_, m) => styles2.bgGray(m));
+    out = out.replace(/\*\*([^*]+)\*\*/g, (_, m) => styles2.bold(m));
+    out = out.replace(/(?<!\*)\*([^*]+)\*(?!\*)/g, (_, m) => styles2.italic(m));
+    out = out.replace(/(?<!_)_([^_]+)_(?!_)/g, (_, m) => styles2.italic(m));
+    out = out.replace(/~([^~]+)~/g, (_, m) => styles2.strikethrough(m));
+    return out;
+  }
+  supportsHyperlinks() {
+    if (isBrowserProcess2())
+      return false;
+    const env = process11.env;
+    if (!env)
+      return false;
+    if (env.TERM_PROGRAM === "iTerm.app" || env.TERM_PROGRAM === "vscode" || env.TERM_PROGRAM === "WezTerm")
+      return true;
+    if (env.WT_SESSION)
+      return true;
+    if (env.TERM === "xterm-kitty")
+      return true;
+    const vte = env.VTE_VERSION ? Number.parseInt(env.VTE_VERSION, 10) : 0;
+    if (!Number.isNaN(vte) && vte >= 5000)
+      return true;
+    return false;
+  }
+  toAbsoluteFilePath(input) {
+    try {
+      let p = input;
+      if (p.startsWith("file://")) {
+        p = p.replace(/^file:\/\//, "");
+      }
+      if (p.startsWith("~")) {
+        const home = process11.env.HOME || "";
+        if (home)
+          p = p.replace(/^~(?=$|\/)/, home);
+      }
+      if (isAbsolute(p) || p.startsWith("./") || p.startsWith("../")) {
+        p = resolve6(p);
+      } else {
+        return null;
+      }
+      return existsSync4(p) ? p : null;
+    } catch {
+      return null;
+    }
+  }
+  buildOutputTexts(input) {
+    const consoleText = this.shouldStyleConsole() ? this.formatMarkdown(input) : input;
+    const fileText = input.replace(this.ANSI_PATTERN, "");
+    return { consoleText, fileText };
+  }
+  async log(level, message, ...args) {
+    const timestamp = new Date;
+    const consoleTime = this.formatConsoleTimestamp(timestamp);
+    const fileTime = this.formatFileTimestamp(timestamp);
+    let formattedMessage;
+    let errorStack;
+    if (message instanceof Error) {
+      formattedMessage = message.message;
+      errorStack = message.stack;
+    } else {
+      formattedMessage = this.formatMessage(message, args);
+    }
+    const { consoleText: baseConsoleText, fileText } = this.buildOutputTexts(formattedMessage);
+    if (this.shouldStyleConsole()) {
+      const icon = this.options.showIcons === false ? "" : levelIcons2[level];
+      const tag = this.options.showTags !== false && this.name ? styles2.gray(this.formatTag(this.name)) : "";
+      let consoleMessage;
+      switch (level) {
+        case "debug":
+          consoleMessage = this.formatConsoleMessage({
+            timestamp: consoleTime,
+            icon,
+            tag,
+            message: styles2.gray(baseConsoleText),
+            level
+          });
+          console.error(consoleMessage);
+          break;
+        case "info":
+          consoleMessage = this.formatConsoleMessage({
+            timestamp: consoleTime,
+            icon,
+            tag,
+            message: baseConsoleText,
+            level
+          });
+          console.warn(consoleMessage);
+          break;
+        case "success":
+          consoleMessage = this.formatConsoleMessage({
+            timestamp: consoleTime,
+            icon,
+            tag,
+            message: styles2.green(baseConsoleText),
+            level
+          });
+          console.error(consoleMessage);
+          break;
+        case "warning":
+          consoleMessage = this.formatConsoleMessage({
+            timestamp: consoleTime,
+            icon,
+            tag,
+            message: baseConsoleText,
+            level
+          });
+          console.warn(consoleMessage);
+          break;
+        case "error":
+          consoleMessage = this.formatConsoleMessage({
+            timestamp: consoleTime,
+            icon,
+            tag,
+            message: baseConsoleText,
+            level
+          });
+          console.error(consoleMessage);
+          if (errorStack) {
+            const stackLines = errorStack.split(`
+`);
+            for (const line of stackLines) {
+              if (line.trim() && !line.includes(formattedMessage)) {
+                console.error(this.formatConsoleMessage({
+                  timestamp: consoleTime,
+                  message: styles2.gray(`  ${line}`),
+                  level,
+                  showTimestamp: false
+                }));
+              }
+            }
+          }
+          break;
+      }
+    } else if (!isBrowserProcess2()) {
+      console.error(`${fileTime} ${this.environment}.${level.toUpperCase()}: ${formattedMessage}`);
+      if (errorStack) {
+        console.error(errorStack);
+      }
+    }
+    if (!this.shouldLog(level))
+      return;
+    let logEntry = `${fileTime} ${this.environment}.${level.toUpperCase()}: ${fileText}
+`;
+    if (errorStack) {
+      logEntry += `${errorStack}
+`;
+    }
+    logEntry = logEntry.replace(this.ANSI_PATTERN, "");
+    if (this.shouldWriteToFile())
+      await this.writeToFile(logEntry);
+  }
+  progress(total, initialMessage = "") {
+    const noop = {
+      update: (_current, _message) => {},
+      finish: (_message) => {},
+      interrupt: (_message, _level) => {}
+    };
+    if (!this.enabled)
+      return noop;
+    const barLength = 30;
+    this.activeProgressBar = {
+      total: Math.max(1, total || 1),
+      current: 0,
+      message: initialMessage || "",
+      barLength,
+      lastRenderedLine: ""
+    };
+    if (this.shouldStyleConsole() && !isBrowserProcess2() && process11.stdout.isTTY) {
+      this.renderProgressBar(this.activeProgressBar);
+    }
+    const update = (current, message) => {
+      if (!this.enabled || !this.activeProgressBar)
+        return;
+      this.activeProgressBar.current = Math.min(Math.max(0, current), this.activeProgressBar.total);
+      if (message !== undefined)
+        this.activeProgressBar.message = message;
+      if (this.shouldStyleConsole() && !isBrowserProcess2() && process11.stdout.isTTY)
+        this.renderProgressBar(this.activeProgressBar);
+    };
+    const finish = (message) => {
+      if (!this.activeProgressBar)
+        return;
+      this.finishProgressBar(this.activeProgressBar, message);
+    };
+    const interrupt = (message, level = "info") => {
+      if (!isBrowserProcess2() && process11.stdout.isTTY)
+        process11.stdout.write(`
+`);
+      const method = level === "warning" ? "warn" : level;
+      this[method](message);
+      if (this.activeProgressBar && this.shouldStyleConsole() && !isBrowserProcess2() && process11.stdout.isTTY)
+        this.renderProgressBar(this.activeProgressBar);
+    };
+    return { update, finish, interrupt };
+  }
+  time(label) {
+    const start = performance.now();
+    if (this.shouldStyleConsole()) {
+      const tag = this.options.showTags !== false && this.name ? styles2.gray(this.formatTag(this.name)) : "";
+      const consoleTime = this.formatConsoleTimestamp(new Date);
+      console.error(this.formatConsoleMessage({
+        timestamp: consoleTime,
+        icon: this.options.showIcons === false ? "" : styles2.blue("\u25D0"),
+        tag,
+        message: `${styles2.cyan(label)}...`
+      }));
+    }
+    return async (metadata) => {
+      if (!this.enabled)
+        return;
+      const end = performance.now();
+      const elapsed = Math.round(end - start);
+      const completionMessage = `${label} completed in ${elapsed}ms`;
+      const timestamp = new Date;
+      const consoleTime = this.formatConsoleTimestamp(timestamp);
+      const fileTime = this.formatFileTimestamp(timestamp);
+      let logEntry = `${fileTime} ${this.environment}.INFO: ${completionMessage}`;
+      if (metadata) {
+        logEntry += ` ${JSON.stringify(metadata)}`;
+      }
+      logEntry += `
+`;
+      logEntry = logEntry.replace(this.ANSI_PATTERN, "");
+      if (this.shouldStyleConsole()) {
+        const tag = this.options.showTags !== false && this.name ? styles2.gray(this.formatTag(this.name)) : "";
+        console.error(this.formatConsoleMessage({
+          timestamp: consoleTime,
+          icon: this.options.showIcons === false ? "" : styles2.green("\u2713"),
+          tag,
+          message: `${completionMessage}${metadata ? ` ${JSON.stringify(metadata)}` : ""}`
+        }));
+      } else if (!isBrowserProcess2()) {
+        console.error(logEntry.trim());
+      }
+      if (this.shouldWriteToFile())
+        await this.writeToFile(logEntry);
+    };
+  }
+  async debug(message, ...args) {
+    await this.log("debug", message, ...args);
+  }
+  async info(message, ...args) {
+    await this.log("info", message, ...args);
+  }
+  async success(message, ...args) {
+    await this.log("success", message, ...args);
+  }
+  async warn(message, ...args) {
+    await this.log("warning", message, ...args);
+  }
+  async error(message, ...args) {
+    await this.log("error", message, ...args);
+  }
+  validateEncryptionConfig() {
+    if (!this.config.rotation)
+      return false;
+    if (typeof this.config.rotation === "boolean")
+      return false;
+    const rotation = this.config.rotation;
+    const { encrypt } = rotation;
+    return !!encrypt;
+  }
+  async only(fn) {
+    if (!this.enabled)
+      return;
+    return await fn();
+  }
+  isEnabled() {
+    return this.enabled;
+  }
+  setEnabled(enabled) {
+    this.enabled = enabled;
+  }
+  extend(namespace) {
+    const childName = `${this.name}:${namespace}`;
+    const childLogger = new Logger2(childName, {
+      ...this.options,
+      logDirectory: this.config.logDirectory,
+      level: this.config.level,
+      format: this.config.format,
+      rotation: typeof this.config.rotation === "boolean" ? undefined : this.config.rotation,
+      timestamp: typeof this.config.timestamp === "boolean" ? undefined : this.config.timestamp
+    });
+    this.subLoggers.add(childLogger);
+    return childLogger;
+  }
+  createReadStream() {
+    if (isBrowserProcess2())
+      throw new Error("createReadStream is not supported in browser environments");
+    if (!existsSync4(this.currentLogFile))
+      throw new Error(`Log file does not exist: ${this.currentLogFile}`);
+    return createReadStream2(this.currentLogFile, { encoding: "utf8" });
+  }
+  async decrypt(data) {
+    if (!this.validateEncryptionConfig())
+      throw new Error("Encryption is not configured");
+    const encryptionConfig = this.config.rotation;
+    if (!encryptionConfig.encrypt || typeof encryptionConfig.encrypt === "boolean")
+      throw new Error("Invalid encryption configuration");
+    if (!this.currentKeyId || !this.keys.has(this.currentKeyId))
+      throw new Error("No valid encryption key available");
+    const key = this.keys.get(this.currentKeyId);
+    try {
+      const encryptedData = Buffer2.isBuffer(data) ? data : Buffer2.from(data, "base64");
+      const iv = encryptedData.subarray(0, 16);
+      const authTag = encryptedData.subarray(encryptedData.length - 16);
+      const ciphertext = encryptedData.subarray(16, encryptedData.length - 16);
+      const decipher = createDecipheriv2("aes-256-gcm", key, iv);
+      decipher.setAuthTag(authTag);
+      const d1 = decipher.update(ciphertext);
+      const d2 = decipher.final();
+      const totalLen = d1.length + d2.length;
+      const out = Buffer2.allocUnsafe(totalLen);
+      d1.copy(out, 0);
+      d2.copy(out, d1.length);
+      return out.toString("utf8");
+    } catch (err) {
+      throw new Error(`Decryption failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  getLevel() {
+    return this.config.level;
+  }
+  getLogDirectory() {
+    return this.config.logDirectory;
+  }
+  getFormat() {
+    return this.config.format;
+  }
+  getRotationConfig() {
+    return this.config.rotation;
+  }
+  isBrowserMode() {
+    return isBrowserProcess2();
+  }
+  isServerMode() {
+    return !isBrowserProcess2();
+  }
+  setTestEncryptionKey(keyId, key) {
+    this.currentKeyId = keyId;
+    this.keys.set(keyId, key);
+  }
+  getTestCurrentKey() {
+    if (!this.currentKeyId || !this.keys.has(this.currentKeyId)) {
+      return null;
+    }
+    return {
+      id: this.currentKeyId,
+      key: this.keys.get(this.currentKeyId)
+    };
+  }
+  getConfig() {
+    return this.config;
+  }
+  async box(message) {
+    if (!this.enabled)
+      return;
+    const timestamp = new Date;
+    const consoleTime = this.formatConsoleTimestamp(timestamp);
+    const fileTime = this.formatFileTimestamp(timestamp);
+    const { consoleText, fileText } = this.buildOutputTexts(message);
+    if (this.shouldStyleConsole()) {
+      const lines = consoleText.split(`
+`);
+      const width = Math.max(...lines.map((line) => line.length)) + 2;
+      const top = `\u250C${"\u2500".repeat(width)}\u2510`;
+      const bottom = `\u2514${"\u2500".repeat(width)}\u2518`;
+      const boxedLines = lines.map((line) => {
+        return this.formatConsoleMessage({
+          timestamp: consoleTime,
+          message: styles2.cyan(line),
+          showTimestamp: false
+        });
+      });
+      console.error(this.formatConsoleMessage({
+        timestamp: consoleTime,
+        message: styles2.cyan(top),
+        showTimestamp: false
+      }));
+      boxedLines.forEach((line) => console.error(line));
+      console.error(this.formatConsoleMessage({
+        timestamp: consoleTime,
+        message: styles2.cyan(bottom),
+        showTimestamp: false
+      }));
+    } else if (!isBrowserProcess2()) {
+      console.error(`${fileTime} ${this.environment}.INFO: [BOX] ${fileText}`);
+    }
+    const logEntry = `${fileTime} ${this.environment}.INFO: [BOX] ${fileText}
+`.replace(this.ANSI_PATTERN, "");
+    if (this.shouldWriteToFile())
+      await this.writeToFile(logEntry);
+  }
+  async prompt(message) {
+    if (isBrowserProcess2()) {
+      return Promise.resolve(true);
+    }
+    return new Promise((resolve52) => {
+      console.error(`${styles2.cyan("?")} ${message} (y/n) `);
+      const onData = (data) => {
+        const input = data.toString().trim().toLowerCase();
+        process11.stdin.removeListener("data", onData);
+        try {
+          if (typeof process11.stdin.setRawMode === "function") {
+            process11.stdin.setRawMode(false);
+          }
+        } catch {}
+        process11.stdin.pause();
+        console.error("");
+        resolve52(input === "y" || input === "yes");
+      };
+      try {
+        if (typeof process11.stdin.setRawMode === "function") {
+          process11.stdin.setRawMode(true);
+        }
+      } catch {}
+      process11.stdin.resume();
+      process11.stdin.once("data", onData);
+    });
+  }
+  setFancy(enabled) {
+    this.fancy = enabled;
+  }
+  isFancy() {
+    return this.fancy;
+  }
+  pause() {
+    this.enabled = false;
+  }
+  resume() {
+    this.enabled = true;
+  }
+  async start(message, ...args) {
+    if (!this.enabled)
+      return;
+    let formattedMessage = message;
+    if (args && args.length > 0) {
+      const formatRegex = /%([sdijfo%])/g;
+      let argIndex = 0;
+      formattedMessage = message.replace(formatRegex, (match, type) => {
+        if (type === "%")
+          return "%";
+        if (argIndex >= args.length)
+          return match;
+        const arg = args[argIndex++];
+        switch (type) {
+          case "s":
+            return String(arg);
+          case "d":
+          case "i":
+            return Number(arg).toString();
+          case "j":
+          case "o":
+            return JSON.stringify(arg, null, 2);
+          default:
+            return match;
+        }
+      });
+      if (argIndex < args.length) {
+        formattedMessage += ` ${args.slice(argIndex).map((arg) => typeof arg === "object" ? JSON.stringify(arg, null, 2) : String(arg)).join(" ")}`;
+      }
+    }
+    const { consoleText, fileText } = this.buildOutputTexts(formattedMessage);
+    if (this.shouldStyleConsole()) {
+      const tag = this.options.showTags !== false && this.name ? styles2.gray(this.formatTag(this.name)) : "";
+      const spinnerPrefix = this.options.showIcons === false ? "" : `${styles2.blue("\u25D0")} `;
+      console.error(`${spinnerPrefix}${tag} ${styles2.cyan(consoleText)}`);
+    }
+    const timestamp = new Date;
+    const formattedDate = timestamp.toISOString();
+    const logEntry = `[${formattedDate}] ${this.environment}.INFO: [START] ${fileText}
+`.replace(this.ANSI_PATTERN, "");
+    if (this.shouldWriteToFile())
+      await this.writeToFile(logEntry);
+  }
+  renderProgressBar(barState, isFinished = false) {
+    if (!this.enabled || !this.shouldStyleConsole() || !process11.stdout.isTTY)
+      return;
+    const percent = Math.min(100, Math.max(0, Math.round(barState.current / barState.total * 100)));
+    const filledLength = Math.round(barState.barLength * percent / 100);
+    const emptyLength = barState.barLength - filledLength;
+    const filledBar = styles2.green("\u2501".repeat(filledLength));
+    const emptyBar = styles2.gray("\u2501".repeat(emptyLength));
+    const bar = `[${filledBar}${emptyBar}]`;
+    const percentageText = `${percent}%`.padStart(4);
+    const messageText = barState.message ? ` ${barState.message}` : "";
+    const icon = this.options.showIcons === false ? "" : isFinished || percent === 100 ? styles2.green("\u2713") : styles2.blue("\u25B6");
+    const tag = this.options.showTags !== false && this.name ? ` ${styles2.gray(this.formatTag(this.name))}` : "";
+    const line = `\r${icon}${tag} ${bar} ${percentageText}${messageText}`;
+    const terminalWidth = process11.stdout.columns || 80;
+    const clearLine = " ".repeat(Math.max(0, terminalWidth - line.replace(this.ANSI_PATTERN, "").length));
+    barState.lastRenderedLine = `${line}${clearLine}`;
+    process11.stdout.write(barState.lastRenderedLine);
+    if (isFinished) {
+      process11.stdout.write(`
+`);
+    }
+  }
+  finishProgressBar(barState, finalMessage) {
+    if (!this.enabled || !this.fancy || isBrowserProcess2() || !process11.stdout.isTTY) {
+      this.activeProgressBar = null;
+      return;
+    }
+    if (barState.current < barState.total) {
+      barState.current = barState.total;
+    }
+    if (finalMessage)
+      barState.message = finalMessage;
+    this.renderProgressBar(barState, true);
+    this.activeProgressBar = null;
+  }
+  async clear(filters = {}) {
+    if (isBrowserProcess2()) {
+      console.warn("Log clearing is not supported in browser environments.");
+      return;
+    }
+    try {
+      console.warn("Clearing logs...", this.config.logDirectory);
+      const files = await readdir2(this.config.logDirectory);
+      const logFilesToDelete = [];
+      for (const file of files) {
+        const nameMatches = filters.name ? new RegExp(filters.name.replace("*", ".*")).test(file) : file.startsWith(this.name);
+        if (!nameMatches || !file.endsWith(".log")) {
+          continue;
+        }
+        const filePath = join5(this.config.logDirectory, file);
+        if (filters.before) {
+          try {
+            const fileStats = await stat2(filePath);
+            if (fileStats.mtime >= filters.before) {
+              continue;
+            }
+          } catch (statErr) {
+            console.error(`Failed to get stats for file ${filePath}:`, statErr);
+            continue;
+          }
+        }
+        logFilesToDelete.push(filePath);
+      }
+      if (logFilesToDelete.length === 0) {
+        console.warn("No log files matched the criteria for clearing.");
+        return;
+      }
+      console.warn(`Preparing to delete ${logFilesToDelete.length} log file(s)...`);
+      for (const filePath of logFilesToDelete) {
+        try {
+          await unlink2(filePath);
+          console.warn(`Deleted log file: ${filePath}`);
+        } catch (unlinkErr) {
+          console.error(`Failed to delete log file ${filePath}:`, unlinkErr);
+        }
+      }
+      console.warn("Log clearing process finished.");
+    } catch (err) {
+      console.error("Error during log clearing process:", err);
+    }
+  }
+}
+async function withErrorRecovery(fn, options = {}) {
+  const {
+    maxRetries = 3,
+    retryDelay = 1000,
+    isRetryable = () => true,
+    fallback
+  } = options;
+  let lastError = new Error("Unknown error occurred");
+  for (let attempt = 0;attempt <= maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error instanceof Error ? error : new Error(String(error));
+      if (attempt === maxRetries || !isRetryable(lastError)) {
+        break;
+      }
+      if (retryDelay > 0) {
+        await new Promise((resolve52) => setTimeout(resolve52, retryDelay));
+      }
+    }
+  }
+  if (fallback !== undefined) {
+    return fallback;
+  }
+  throw lastError instanceof Error ? lastError : new Error(`Unknown error: ${String(lastError)}`);
+}
+
+class EnvProcessor {
+  defaultParsers;
+  constructor() {
+    this.defaultParsers = [
+      {
+        name: "boolean",
+        canParse: (value, expectedType) => expectedType === "boolean" || ["true", "false", "1", "0", "yes", "no"].includes(value.toLowerCase()),
+        parse: (value) => {
+          const lower = value.toLowerCase();
+          return ["true", "1", "yes"].includes(lower);
+        }
+      },
+      {
+        name: "number",
+        canParse: (value, expectedType) => expectedType === "number" || !Number.isNaN(Number(value)) && !Number.isNaN(Number.parseFloat(value)),
+        parse: (value) => {
+          const num = Number(value);
+          if (Number.isNaN(num)) {
+            throw new TypeError(`Cannot parse "${value}" as number`);
+          }
+          return num;
+        }
+      },
+      {
+        name: "array",
+        canParse: (value, expectedType) => expectedType === "array" || value.startsWith("[") || value.includes(","),
+        parse: (value) => {
+          try {
+            const parsed = JSON.parse(value);
+            if (Array.isArray(parsed)) {
+              return parsed;
+            }
+          } catch {}
+          return value.split(",").map((item) => item.trim());
+        }
+      },
+      {
+        name: "json",
+        canParse: (value, expectedType) => expectedType === "object" || (value.startsWith("{") && value.endsWith("}") || value.startsWith("[") && value.endsWith("]")),
+        parse: (value) => {
+          try {
+            return JSON.parse(value);
+          } catch (error) {
+            throw new Error(`Cannot parse "${value}" as JSON: ${error}`);
+          }
+        }
+      }
+    ];
+  }
+  async applyEnvironmentVariables(configName, config3, options = {}) {
+    const {
+      prefix,
+      useCamelCase = true,
+      useBackwardCompatibility = true,
+      customParsers = {},
+      verbose = false,
+      trackPerformance = true
+    } = options;
+    const operation = async () => {
+      if (!configName) {
+        return {
+          config: config3,
+          source: { type: "environment", priority: 50, timestamp: new Date }
+        };
+      }
+      const envPrefix = prefix || this.generateEnvPrefix(configName);
+      const result = { ...config3 };
+      this.processObject(result, [], envPrefix, {
+        useCamelCase,
+        useBackwardCompatibility,
+        customParsers,
+        verbose,
+        configName
+      });
+      const source = {
+        type: "environment",
+        priority: 50,
+        timestamp: new Date
+      };
+      return { config: result, source };
+    };
+    if (trackPerformance) {
+      return globalPerformanceMonitor.track("applyEnvironmentVariables", operation, { configName });
+    }
+    return operation();
+  }
+  generateEnvPrefix(configName) {
+    return configName.toUpperCase().replace(/-/g, "_");
+  }
+  formatEnvKey(key, useCamelCase) {
+    if (!useCamelCase) {
+      return key.toUpperCase();
+    }
+    return key.replace(/([A-Z])/g, "_$1").toUpperCase();
+  }
+  processObject(obj, path, envPrefix, options) {
+    for (const [key, value] of Object.entries(obj)) {
+      const envPath = [...path, key];
+      const formattedKeys = envPath.map((k) => this.formatEnvKey(k, options.useCamelCase));
+      const envKey = `${envPrefix}_${formattedKeys.join("_")}`;
+      const oldEnvKey = options.useBackwardCompatibility ? `${envPrefix}_${envPath.map((p) => p.toUpperCase()).join("_")}` : null;
+      if (options.verbose) {}
+      if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+        this.processObject(value, envPath, envPrefix, options);
+      } else {
+        const envValue = process8.env[envKey] || (oldEnvKey ? process8.env[oldEnvKey] : undefined);
+        if (envValue !== undefined) {
+          if (options.verbose) {
+            const _usedKey = process8.env[envKey] ? envKey : oldEnvKey;
+          }
+          try {
+            obj[key] = this.parseEnvironmentValue(envValue, typeof value, envKey, options.customParsers, options.configName);
+          } catch (error) {
+            if (error instanceof EnvVarError) {
+              throw error;
+            }
+            throw ErrorFactory.envVar(envKey, envValue, typeof value, options.configName);
+          }
+        }
+      }
+    }
+  }
+  parseEnvironmentValue(envValue, expectedType, envKey, customParsers, configName) {
+    for (const [_parserName, parser] of Object.entries(customParsers)) {
+      try {
+        return parser(envValue);
+      } catch {
+        continue;
+      }
+    }
+    for (const parser of this.defaultParsers) {
+      if (parser.canParse(envValue, expectedType)) {
+        try {
+          return parser.parse(envValue);
+        } catch {
+          throw ErrorFactory.envVar(envKey, envValue, `${expectedType} (via ${parser.name} parser)`, configName);
+        }
+      }
+    }
+    return envValue;
+  }
+  getEnvironmentVariables(prefix) {
+    const envVars = {};
+    const upperPrefix = prefix.toUpperCase();
+    for (const [key, value] of Object.entries(process8.env)) {
+      if (key.startsWith(upperPrefix) && value !== undefined) {
+        envVars[key] = value;
+      }
+    }
+    return envVars;
+  }
+  validateEnvironmentVariable(key, value, expectedType) {
+    const errors = [];
+    if (!/^[A-Z_][A-Z0-9_]*$/.test(key)) {
+      errors.push(`Environment variable key "${key}" should only contain uppercase letters, numbers, and underscores`);
+    }
+    if (expectedType) {
+      try {
+        this.parseEnvironmentValue(key, value, expectedType, {});
+      } catch (error) {
+        errors.push(`Cannot parse value "${value}" as ${expectedType}: ${error}`);
+      }
+    }
+    return {
+      isValid: errors.length === 0,
+      errors
+    };
+  }
+  generateEnvVarDocs(configName, defaultConfig3, options = {}) {
+    const { prefix, format = "text" } = options;
+    const envPrefix = prefix || this.generateEnvPrefix(configName);
+    const envVars = [];
+    this.extractEnvVarInfo(defaultConfig3, [], envPrefix, envVars);
+    switch (format) {
+      case "markdown":
+        return this.formatAsMarkdown(envVars, configName);
+      case "json":
+        return JSON.stringify(envVars, null, 2);
+      default:
+        return this.formatAsText(envVars, configName);
+    }
+  }
+  extractEnvVarInfo(obj, path, prefix, envVars) {
+    for (const [key, value] of Object.entries(obj)) {
+      const envPath = [...path, key];
+      const envKey = `${prefix}_${envPath.map((k) => this.formatEnvKey(k, true)).join("_")}`;
+      if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+        this.extractEnvVarInfo(value, envPath, prefix, envVars);
+      } else {
+        envVars.push({
+          key: envKey,
+          type: Array.isArray(value) ? "array" : typeof value,
+          description: `Configuration for ${envPath.join(".")}`,
+          example: this.generateExample(value)
+        });
+      }
+    }
+  }
+  generateExample(value) {
+    if (Array.isArray(value)) {
+      return JSON.stringify(value);
+    }
+    if (typeof value === "object" && value !== null) {
+      return JSON.stringify(value);
+    }
+    return String(value);
+  }
+  formatAsText(envVars, configName) {
+    let result = `Environment Variables for ${configName}:
+
+`;
+    for (const envVar of envVars) {
+      result += `${envVar.key}
+`;
+      result += `  Type: ${envVar.type}
+`;
+      result += `  Description: ${envVar.description}
+`;
+      result += `  Example: ${envVar.example}
+
+`;
+    }
+    return result;
+  }
+  formatAsMarkdown(envVars, configName) {
+    let result = `# Environment Variables for ${configName}
+
+`;
+    result += `| Variable | Type | Description | Example |
+`;
+    result += `|----------|------|-------------|----------|
+`;
+    for (const envVar of envVars) {
+      result += `| \`${envVar.key}\` | ${envVar.type} | ${envVar.description} | \`${envVar.example}\` |
+`;
+    }
+    return result;
+  }
+}
+function deepMerge3(target, source, options = {}) {
+  const visited = new WeakMap;
+  return deepMergeWithVisited(target, source, options, visited);
+}
+function deepMergeWithVisited(target, source, options, visited) {
+  const {
+    arrayMergeMode = "replace",
+    skipNullish = false,
+    customMerger
+  } = options;
+  if (source === null || source === undefined) {
+    return skipNullish ? target : source;
+  }
+  if (customMerger) {
+    const customResult = customMerger(target, source);
+    if (customResult !== undefined) {
+      return customResult;
+    }
+  }
+  if (Array.isArray(source) || Array.isArray(target)) {
+    return mergeArraysWithVisited(target, source, arrayMergeMode, visited);
+  }
+  if (!isObject3(source) || !isObject3(target)) {
+    return source;
+  }
+  return mergeObjectsWithVisited(target, source, options, visited);
+}
+function mergeArraysWithVisited(target, source, mode, visited) {
+  if (Array.isArray(source) && !Array.isArray(target)) {
+    return source;
+  }
+  if (Array.isArray(target) && !Array.isArray(source)) {
+    return source;
+  }
+  if (Array.isArray(source) && Array.isArray(target)) {
+    switch (mode) {
+      case "replace":
+        return source;
+      case "concat":
+        return concatArraysWithDedup(target, source);
+      case "smart":
+        return smartMergeArraysWithVisited(target, source, visited);
+      default:
+        return source;
+    }
+  }
+  return source;
+}
+function concatArraysWithDedup(target, source) {
+  const result = [...source];
+  for (const item of target) {
+    if (!result.some((existingItem) => deepEquals3(existingItem, item))) {
+      result.push(item);
+    }
+  }
+  return result;
+}
+function smartMergeArraysWithVisited(target, source, visited) {
+  if (source.length === 0)
+    return target;
+  if (target.length === 0)
+    return source;
+  if (isObject3(source[0]) && isObject3(target[0])) {
+    return mergeObjectArraysWithVisited(target, source, visited);
+  }
+  if (source.every((item) => typeof item === "string") && target.every((item) => typeof item === "string")) {
+    const result = [...source];
+    for (const item of target) {
+      if (!result.includes(item)) {
+        result.push(item);
+      }
+    }
+    return result;
+  }
+  return source;
+}
+function mergeObjectArraysWithVisited(target, source, _visited) {
+  const result = [...source];
+  for (const targetItem of target) {
+    if (!isObject3(targetItem)) {
+      result.push(targetItem);
+      continue;
+    }
+    const identifierKeys = ["id", "name", "key", "path", "type"];
+    let hasMatch = false;
+    for (const key of identifierKeys) {
+      if (key in targetItem) {
+        const existingItem = result.find((item) => isObject3(item) && (key in item) && item[key] === targetItem[key]);
+        if (existingItem) {
+          hasMatch = true;
+          break;
+        }
+      }
+    }
+    if (!hasMatch) {
+      result.push(targetItem);
+    }
+  }
+  return result;
+}
+function mergeObjectsWithVisited(target, source, options, visited) {
+  const sourceObj = source;
+  if (isObject3(sourceObj) && visited.has(sourceObj)) {
+    return visited.get(sourceObj);
+  }
+  const merged = { ...target };
+  if (isObject3(sourceObj)) {
+    visited.set(sourceObj, merged);
+  }
+  for (const key in sourceObj) {
+    if (!Object.prototype.hasOwnProperty.call(sourceObj, key)) {
+      continue;
+    }
+    const sourceValue = sourceObj[key];
+    const targetValue = merged[key];
+    if (options.skipNullish && (sourceValue === null || sourceValue === undefined)) {
+      continue;
+    }
+    if (sourceValue === null || sourceValue === undefined) {
+      merged[key] = sourceValue;
+      continue;
+    }
+    if (isObject3(sourceValue) && isObject3(targetValue)) {
+      merged[key] = deepMergeWithVisited(targetValue, sourceValue, options, visited);
+    } else if (Array.isArray(sourceValue) || Array.isArray(targetValue)) {
+      merged[key] = mergeArraysWithVisited(targetValue, sourceValue, options.arrayMergeMode || "smart", visited);
+    } else {
+      merged[key] = sourceValue;
+    }
+  }
+  return merged;
+}
+function deepMergeWithArrayStrategy2(target, source, strategy = "replace") {
+  const arrayMergeMode = strategy === "replace" ? "replace" : "smart";
+  return deepMerge3(target, source, {
+    arrayMergeMode,
+    skipNullish: true
+  });
+}
+function deepEquals3(a, b) {
+  if (a === b)
+    return true;
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length)
+      return false;
+    for (let i = 0;i < a.length; i++) {
+      if (!deepEquals3(a[i], b[i]))
+        return false;
+    }
+    return true;
+  }
+  if (isObject3(a) && isObject3(b)) {
+    const keysA = Object.keys(a);
+    const keysB = Object.keys(b);
+    if (keysA.length !== keysB.length)
+      return false;
+    for (const key of keysA) {
+      if (!Object.prototype.hasOwnProperty.call(b, key))
+        return false;
+      if (!deepEquals3(a[key], b[key]))
+        return false;
+    }
+    return true;
+  }
+  return false;
+}
+function isObject3(item) {
+  return Boolean(item && typeof item === "object" && !Array.isArray(item));
+}
+
+class ConfigFileLoader {
+  extensions = [".ts", ".js", ".mjs", ".cjs", ".json", ".mts", ".cts"];
+  async loadFromPath(configPath, defaultConfig3, options = {}) {
+    const {
+      arrayStrategy = "replace",
+      useCache = true,
+      cacheTtl,
+      trackPerformance = true,
+      verbose = false
+    } = options;
+    if (useCache) {
+      const cached = globalCache.getWithFileCheck("file", configPath);
+      if (cached) {
+        if (verbose) {
+          console.log(`Configuration loaded from cache: ${configPath}`);
+        }
+        return cached;
+      }
+    }
+    const loadOperation = async () => {
+      if (!existsSync5(configPath)) {
+        return null;
+      }
+      try {
+        const cacheBuster = `?t=${Date.now()}`;
+        const importedConfig = await import(configPath + cacheBuster);
+        const loadedConfig = importedConfig.default || importedConfig;
+        const hasDefaultExport = "default" in importedConfig;
+        const hasNamedExports = Object.keys(importedConfig).length > 0;
+        if (!hasDefaultExport && !hasNamedExports) {
+          throw new ConfigLoadError(configPath, new Error("Configuration file is empty and exports nothing"), "unknown");
+        }
+        if (typeof loadedConfig !== "object" || loadedConfig === null || Array.isArray(loadedConfig)) {
+          throw new ConfigLoadError(configPath, new Error("Configuration must export a valid object"), "unknown");
+        }
+        const mergedConfig = deepMergeWithArrayStrategy2(defaultConfig3, loadedConfig, arrayStrategy);
+        const source = {
+          type: "file",
+          path: configPath,
+          priority: 100,
+          timestamp: new Date
+        };
+        const result = { config: mergedConfig, source };
+        if (useCache) {
+          globalCache.setWithFileCheck("file", result, configPath, cacheTtl);
+        }
+        return result;
+      } catch (error) {
+        const bunfigError = error instanceof Error ? ErrorFactory.configLoad(configPath, error) : ErrorFactory.configLoad(configPath, new Error(String(error)));
+        throw bunfigError;
+      }
+    };
+    if (trackPerformance) {
+      return globalPerformanceMonitor.track("loadFromPath", loadOperation, { path: configPath });
+    }
+    return loadOperation();
+  }
+  async tryLoadFromPaths(configPaths, defaultConfig3, options = {}) {
+    for (const configPath of configPaths) {
+      try {
+        const result = await this.loadFromPath(configPath, defaultConfig3, options);
+        if (result) {
+          return result;
+        }
+      } catch (error) {
+        if (error instanceof Error && error.name === "ConfigLoadError") {
+          throw error;
+        }
+        if (options.verbose) {
+          console.warn(`Failed to load config from ${configPath}:`, error);
+        }
+      }
+    }
+    return null;
+  }
+  generateConfigPaths(configName, directory, alias) {
+    const patterns = this.generateNamePatterns(configName, alias);
+    const paths = [];
+    for (const pattern of patterns) {
+      for (const ext of this.extensions) {
+        paths.push(resolve5(directory, `${pattern}${ext}`));
+      }
+    }
+    return paths;
+  }
+  generateNamePatterns(configName, alias) {
+    const patterns = [];
+    patterns.push("config", ".config");
+    if (configName) {
+      patterns.push(configName, `.${configName}.config`, `${configName}.config`, `.${configName}`);
+    }
+    if (alias) {
+      patterns.push(alias, `.${alias}.config`, `${alias}.config`, `.${alias}`);
+      if (configName) {
+        patterns.push(`${configName}.${alias}.config`, `.${configName}.${alias}.config`);
+      }
+    }
+    return patterns.filter(Boolean);
+  }
+  checkFileAccess(filePath) {
+    return withErrorRecovery(async () => {
+      return existsSync5(filePath);
+    }, {
+      maxRetries: 2,
+      retryDelay: 100,
+      fallback: false
+    });
+  }
+  async discoverConfigFiles(directory, configName, alias) {
+    const discoveredFiles = [];
+    if (!existsSync5(directory)) {
+      return discoveredFiles;
+    }
+    if (configName || alias) {
+      const patterns = this.generateNamePatterns(configName || "", alias);
+      for (const pattern of patterns) {
+        for (const ext of this.extensions) {
+          const filePath = resolve5(directory, `${pattern}${ext}`);
+          if (await this.checkFileAccess(filePath)) {
+            discoveredFiles.push(filePath);
+          }
+        }
+      }
+    } else {
+      try {
+        const { readdirSync: readdirSync32 } = await import("fs");
+        const files = readdirSync32(directory);
+        for (const file of files) {
+          if (this.looksLikeConfigFile(file)) {
+            const filePath = resolve5(directory, file);
+            if (await this.checkFileAccess(filePath)) {
+              discoveredFiles.push(filePath);
+            }
+          }
+        }
+      } catch {
+        return [];
+      }
+    }
+    return discoveredFiles;
+  }
+  looksLikeConfigFile(filename) {
+    const configPatterns = [
+      /\.config\.(ts|js|mjs|cjs|json|mts|cts)$/,
+      /^\..*\.(ts|js|mjs|cjs|json|mts|cts)$/,
+      /config\.(ts|js|mjs|cjs|json|mts|cts)$/
+    ];
+    return configPatterns.some((pattern) => pattern.test(filename));
+  }
+  async validateConfigFile(filePath) {
+    const errors = [];
+    try {
+      if (!existsSync5(filePath)) {
+        errors.push("Configuration file does not exist");
+        return errors;
+      }
+      const imported = await import(filePath);
+      const config3 = imported.default || imported;
+      if (config3 === undefined) {
+        errors.push("Configuration file must export a default value or named exports");
+      } else if (typeof config3 !== "object" || config3 === null) {
+        errors.push("Configuration must be an object");
+      } else if (Array.isArray(config3)) {
+        errors.push("Configuration cannot be an array at the root level");
+      }
+      if (filePath.endsWith(".json")) {
+        try {
+          const { readFileSync } = await import("fs");
+          const content = readFileSync(filePath, "utf8");
+          JSON.parse(content);
+        } catch (jsonError) {
+          errors.push(`Invalid JSON syntax: ${jsonError}`);
+        }
+      }
+    } catch (error) {
+      errors.push(`Failed to load configuration file: ${error}`);
+    }
+    return errors;
+  }
+  async getFileModificationTime(filePath) {
+    try {
+      const { statSync: statSync2 } = await import("fs");
+      const stats = statSync2(filePath);
+      return stats.mtime;
+    } catch {
+      return null;
+    }
+  }
+  async preloadConfigurations(configPaths, options = {}) {
+    const preloaded = new Map;
+    await Promise.allSettled(configPaths.map(async (path) => {
+      try {
+        const result = await this.loadFromPath(path, {}, options);
+        if (result) {
+          preloaded.set(path, result.config);
+        }
+      } catch (error) {
+        if (options.verbose) {
+          console.warn(`Failed to preload ${path}:`, error);
+        }
+      }
+    }));
+    return preloaded;
+  }
+}
+
+class ConfigValidator {
+  async validateConfiguration(config3, schema, options = {}) {
+    const {
+      stopOnFirstError = false,
+      validateRequired = true,
+      validateTypes = true,
+      customRules = [],
+      trackPerformance = true,
+      verbose = false
+    } = options;
+    const operation = async () => {
+      const errors = [];
+      const warnings = [];
+      const resolvedOptions = {
+        stopOnFirstError,
+        validateRequired,
+        validateTypes,
+        customRules,
+        trackPerformance,
+        verbose
+      };
+      try {
+        if (typeof schema === "string") {
+          return await this.validateWithSchemaFile(config3, schema, resolvedOptions);
+        } else if (Array.isArray(schema)) {
+          return this.validateWithRules(config3, [...schema, ...customRules], resolvedOptions);
+        } else {
+          return this.validateWithJSONSchema(config3, schema, resolvedOptions);
+        }
+      } catch (error) {
+        errors.push({
+          path: "",
+          message: `Validation failed: ${error}`,
+          rule: "system"
+        });
+        return { isValid: false, errors, warnings };
+      }
+    };
+    if (trackPerformance) {
+      const result = await globalPerformanceMonitor.track("validateConfiguration", operation);
+      return result;
+    }
+    return operation();
+  }
+  async validateWithSchemaFile(config3, schemaPath, options) {
+    try {
+      if (!existsSync7(schemaPath)) {
+        throw new SchemaValidationError(schemaPath, [{ path: "", message: "Schema file does not exist" }]);
+      }
+      const schemaModule = await import(schemaPath);
+      const schema = schemaModule.default || schemaModule;
+      if (Array.isArray(schema)) {
+        return this.validateWithRules(config3, schema, options);
+      } else {
+        return this.validateWithJSONSchema(config3, schema, options);
+      }
+    } catch (error) {
+      throw new SchemaValidationError(schemaPath, [{ path: "", message: `Failed to load schema: ${error}` }]);
+    }
+  }
+  validateWithJSONSchema(config3, schema, options) {
+    const errors = [];
+    const warnings = [];
+    this.validateObjectAgainstSchema(config3, schema, "", errors, warnings, options);
+    return {
+      isValid: errors.length === 0,
+      errors,
+      warnings
+    };
+  }
+  validateObjectAgainstSchema(value, schema, path, errors, warnings, options) {
+    if (options.validateTypes && schema.type) {
+      const actualType = Array.isArray(value) ? "array" : typeof value;
+      const expectedTypes = Array.isArray(schema.type) ? schema.type : [schema.type];
+      if (!expectedTypes.includes(actualType)) {
+        errors.push({
+          path,
+          message: `Expected type ${expectedTypes.join(" or ")}, got ${actualType}`,
+          expected: expectedTypes.join(" or "),
+          actual: actualType,
+          rule: "type"
+        });
+        if (options.stopOnFirstError)
+          return;
+      }
+    }
+    if (schema.enum && !schema.enum.includes(value)) {
+      errors.push({
+        path,
+        message: `Value must be one of: ${schema.enum.join(", ")}`,
+        expected: schema.enum.join(", "),
+        actual: value,
+        rule: "enum"
+      });
+      if (options.stopOnFirstError)
+        return;
+    }
+    if (typeof value === "string") {
+      if (schema.minLength !== undefined && value.length < schema.minLength) {
+        errors.push({
+          path,
+          message: `String length must be at least ${schema.minLength}`,
+          expected: `>= ${schema.minLength}`,
+          actual: value.length,
+          rule: "minLength"
+        });
+      }
+      if (schema.maxLength !== undefined && value.length > schema.maxLength) {
+        errors.push({
+          path,
+          message: `String length must not exceed ${schema.maxLength}`,
+          expected: `<= ${schema.maxLength}`,
+          actual: value.length,
+          rule: "maxLength"
+        });
+      }
+      if (schema.pattern) {
+        const regex = new RegExp(schema.pattern);
+        if (!regex.test(value)) {
+          errors.push({
+            path,
+            message: `String does not match pattern ${schema.pattern}`,
+            expected: schema.pattern,
+            actual: value,
+            rule: "pattern"
+          });
+        }
+      }
+    }
+    if (typeof value === "number") {
+      if (schema.minimum !== undefined && value < schema.minimum) {
+        errors.push({
+          path,
+          message: `Value must be at least ${schema.minimum}`,
+          expected: `>= ${schema.minimum}`,
+          actual: value,
+          rule: "minimum"
+        });
+      }
+      if (schema.maximum !== undefined && value > schema.maximum) {
+        errors.push({
+          path,
+          message: `Value must not exceed ${schema.maximum}`,
+          expected: `<= ${schema.maximum}`,
+          actual: value,
+          rule: "maximum"
+        });
+      }
+    }
+    if (Array.isArray(value) && schema.items) {
+      for (let i = 0;i < value.length; i++) {
+        const itemPath = path ? `${path}[${i}]` : `[${i}]`;
+        this.validateObjectAgainstSchema(value[i], schema.items, itemPath, errors, warnings, options);
+        if (options.stopOnFirstError && errors.length > 0)
+          return;
+      }
+    }
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+      const obj = value;
+      if (options.validateRequired && schema.required) {
+        for (const requiredProp of schema.required) {
+          if (!(requiredProp in obj)) {
+            errors.push({
+              path: path ? `${path}.${requiredProp}` : requiredProp,
+              message: `Missing required property '${requiredProp}'`,
+              expected: "required",
+              rule: "required"
+            });
+            if (options.stopOnFirstError)
+              return;
+          }
+        }
+      }
+      if (schema.properties) {
+        for (const [propName, propSchema] of Object.entries(schema.properties)) {
+          if (propName in obj) {
+            const propPath = path ? `${path}.${propName}` : propName;
+            this.validateObjectAgainstSchema(obj[propName], propSchema, propPath, errors, warnings, options);
+            if (options.stopOnFirstError && errors.length > 0)
+              return;
+          }
+        }
+      }
+      if (schema.additionalProperties === false) {
+        const allowedProps = new Set(Object.keys(schema.properties || {}));
+        for (const propName of Object.keys(obj)) {
+          if (!allowedProps.has(propName)) {
+            warnings.push({
+              path: path ? `${path}.${propName}` : propName,
+              message: `Additional property '${propName}' is not allowed`,
+              rule: "additionalProperties"
+            });
+          }
+        }
+      }
+    }
+  }
+  validateWithRules(config3, rules, options) {
+    const errors = [];
+    const warnings = [];
+    for (const rule of rules) {
+      try {
+        const value = this.getValueByPath(config3, rule.path);
+        const ruleErrors = this.validateWithRule(value, rule, rule.path);
+        errors.push(...ruleErrors);
+        if (options.stopOnFirstError && errors.length > 0) {
+          break;
+        }
+      } catch (error) {
+        errors.push({
+          path: rule.path,
+          message: `Rule validation failed: ${error}`,
+          rule: "system"
+        });
+      }
+    }
+    return {
+      isValid: errors.length === 0,
+      errors,
+      warnings
+    };
+  }
+  validateWithRule(value, rule, path) {
+    const errors = [];
+    if (rule.required && (value === undefined || value === null)) {
+      errors.push({
+        path,
+        message: rule.message || `Property '${path}' is required`,
+        expected: "required",
+        rule: "required"
+      });
+      return errors;
+    }
+    if (value === undefined || value === null) {
+      return errors;
+    }
+    if (rule.type) {
+      const actualType = Array.isArray(value) ? "array" : typeof value;
+      if (actualType !== rule.type) {
+        errors.push({
+          path,
+          message: rule.message || `Expected type ${rule.type}, got ${actualType}`,
+          expected: rule.type,
+          actual: actualType,
+          rule: "type"
+        });
+      }
+    }
+    if (rule.min !== undefined) {
+      const length = Array.isArray(value) ? value.length : typeof value === "string" ? value.length : typeof value === "number" ? value : 0;
+      if (length < rule.min) {
+        errors.push({
+          path,
+          message: rule.message || `Value must be at least ${rule.min}`,
+          expected: `>= ${rule.min}`,
+          actual: length,
+          rule: "min"
+        });
+      }
+    }
+    if (rule.max !== undefined) {
+      const length = Array.isArray(value) ? value.length : typeof value === "string" ? value.length : typeof value === "number" ? value : 0;
+      if (length > rule.max) {
+        errors.push({
+          path,
+          message: rule.message || `Value must not exceed ${rule.max}`,
+          expected: `<= ${rule.max}`,
+          actual: length,
+          rule: "max"
+        });
+      }
+    }
+    if (rule.pattern && typeof value === "string") {
+      if (!rule.pattern.test(value)) {
+        errors.push({
+          path,
+          message: rule.message || `Value does not match pattern ${rule.pattern}`,
+          expected: rule.pattern.toString(),
+          actual: value,
+          rule: "pattern"
+        });
+      }
+    }
+    if (rule.enum && !rule.enum.includes(value)) {
+      errors.push({
+        path,
+        message: rule.message || `Value must be one of: ${rule.enum.join(", ")}`,
+        expected: rule.enum.join(", "),
+        actual: value,
+        rule: "enum"
+      });
+    }
+    if (rule.validator) {
+      const customError = rule.validator(value);
+      if (customError) {
+        errors.push({
+          path,
+          message: rule.message || customError,
+          rule: "custom"
+        });
+      }
+    }
+    return errors;
+  }
+  getValueByPath(obj, path) {
+    if (!path)
+      return obj;
+    const keys = path.split(".");
+    let current = obj;
+    for (const key of keys) {
+      if (current && typeof current === "object" && key in current) {
+        current = current[key];
+      } else {
+        return;
+      }
+    }
+    return current;
+  }
+  generateRulesFromInterface(interfaceCode) {
+    const rules = [];
+    const propertyMatches = interfaceCode.matchAll(/(\w+)(\?)?:\s*(\w+)/g);
+    for (const match of propertyMatches) {
+      const [, propName, optional, typeName] = match;
+      rules.push({
+        path: propName,
+        required: !optional,
+        type: this.mapTypeScriptType(typeName)
+      });
+    }
+    return rules;
+  }
+  mapTypeScriptType(tsType) {
+    switch (tsType.toLowerCase()) {
+      case "string":
+        return "string";
+      case "number":
+        return "number";
+      case "boolean":
+        return "boolean";
+      case "array":
+        return "array";
+      case "object":
+        return "object";
+      default:
+        return "object";
+    }
+  }
+  static createCommonRules() {
+    return {
+      server: [
+        { path: "port", required: true, type: "number", min: 1, max: 65535 },
+        { path: "host", required: true, type: "string", min: 1 },
+        { path: "ssl", type: "boolean" }
+      ],
+      database: [
+        { path: "url", required: true, type: "string", min: 1 },
+        { path: "pool", type: "number", min: 1, max: 100 },
+        { path: "timeout", type: "number", min: 0 }
+      ],
+      api: [
+        { path: "baseUrl", required: true, type: "string", pattern: /^https?:\/\// },
+        { path: "timeout", type: "number", min: 0 },
+        { path: "retries", type: "number", min: 0, max: 10 }
+      ]
+    };
+  }
+}
+
+class ConfigLoader {
+  fileLoader = new ConfigFileLoader;
+  envProcessor = new EnvProcessor;
+  validator = new ConfigValidator;
+  async loadConfig(options) {
+    const startTime = Date.now();
+    const {
+      cache,
+      performance: performance2,
+      schema,
+      validate: customValidator,
+      ...baseOptions
+    } = options;
+    try {
+      if (cache?.enabled) {
+        const cached = this.checkCache(baseOptions.name || "", baseOptions);
+        if (cached) {
+          return cached;
+        }
+      }
+      let result;
+      try {
+        result = await this.loadConfigurationStrategies(baseOptions, true, cache);
+      } catch (error) {
+        const isStrictMode = baseOptions.__strictErrorHandling;
+        if (error instanceof Error && error.name === "ConfigNotFoundError") {
+          if (isStrictMode) {
+            throw error;
+          }
+          const envResult = await this.applyEnvironmentVariables(baseOptions.name || "", baseOptions.defaultConfig, baseOptions.checkEnv !== false, baseOptions.verbose || false);
+          result = {
+            ...envResult,
+            warnings: [`No configuration file found for "${baseOptions.name || "config"}", using defaults with environment variables`]
+          };
+        } else if (error instanceof Error && error.name === "ConfigLoadError") {
+          const isPermissionError = error.message.includes("EACCES") || error.message.includes("EPERM") || error.message.includes("permission denied");
+          const isSyntaxError = !isPermissionError && (error.message.includes("syntax") || error.message.includes("Expected") || error.message.includes("Unexpected") || error.message.includes("BuildMessage") || error.message.includes("errors building"));
+          const isStructureError = error.message.includes("Configuration must export a valid object") || error.message.includes("Configuration file is empty and exports nothing");
+          if (isStrictMode && (isStructureError || isPermissionError)) {
+            throw error;
+          }
+          if (isSyntaxError && (!isStrictMode || !isStructureError)) {
+            const envResult = await this.applyEnvironmentVariables(baseOptions.name || "", baseOptions.defaultConfig, baseOptions.checkEnv !== false, baseOptions.verbose || false);
+            result = {
+              ...envResult,
+              warnings: [`Configuration file has syntax errors, using defaults with environment variables`]
+            };
+          } else if (!isStrictMode) {
+            const envResult = await this.applyEnvironmentVariables(baseOptions.name || "", baseOptions.defaultConfig, baseOptions.checkEnv !== false, baseOptions.verbose || false);
+            result = {
+              ...envResult,
+              warnings: [`Configuration loading error, using defaults: ${error.message}`]
+            };
+          } else {
+            throw error;
+          }
+        } else {
+          const envResult = await this.applyEnvironmentVariables(baseOptions.name || "", baseOptions.defaultConfig, baseOptions.checkEnv !== false, baseOptions.verbose || false);
+          result = {
+            ...envResult,
+            warnings: [`Configuration loading failed, using defaults: ${error instanceof Error ? error.message : String(error)}`]
+          };
+        }
+      }
+      if (schema || customValidator) {
+        await this.validateConfiguration(result.config, schema, customValidator, baseOptions.name);
+      }
+      if (cache?.enabled && result) {
+        this.cacheResult(baseOptions.name || "", result, cache, baseOptions);
+      }
+      if (performance2?.enabled) {
+        const metrics = {
+          operation: "loadConfig",
+          duration: Date.now() - startTime,
+          configName: baseOptions.name,
+          timestamp: new Date
+        };
+        if (performance2.onMetrics) {
+          performance2.onMetrics(metrics);
+        }
+        if (performance2.slowThreshold && metrics.duration > performance2.slowThreshold) {
+          log2.warn(`Slow configuration loading detected: ${metrics.duration}ms for ${baseOptions.name}`);
+        }
+        result.metrics = metrics;
+      }
+      return result;
+    } catch (error) {
+      const duration = Date.now() - startTime;
+      log2.error(`Configuration loading failed after ${duration}ms:`, [error instanceof Error ? error : new Error(String(error))]);
+      throw error;
+    }
+  }
+  async loadConfigurationStrategies(options, throwOnNotFound = false, cacheOptions) {
+    const {
+      name = "",
+      alias,
+      cwd,
+      configDir,
+      defaultConfig: defaultConfig3,
+      checkEnv = true,
+      arrayStrategy = "replace",
+      verbose = false
+    } = options;
+    const baseDir = cwd || process12.cwd();
+    const searchPaths = [];
+    const localResult = await this.loadLocalConfiguration(name, alias, baseDir, configDir, defaultConfig3, arrayStrategy, verbose, checkEnv, cacheOptions);
+    if (localResult) {
+      searchPaths.push(...this.getLocalSearchPaths(name, alias, baseDir, configDir));
+      return this.finalizeResult(localResult, searchPaths, checkEnv, name, verbose);
+    }
+    const homeResult = await this.loadHomeConfiguration(name, alias, defaultConfig3, arrayStrategy, verbose, checkEnv);
+    if (homeResult) {
+      searchPaths.push(...this.getHomeSearchPaths(name, alias));
+      return this.finalizeResult(homeResult, searchPaths, checkEnv, name, verbose);
+    }
+    const packageResult = await this.loadPackageJsonConfiguration(name, alias, baseDir, defaultConfig3, arrayStrategy, verbose, checkEnv);
+    if (packageResult) {
+      searchPaths.push(resolve7(baseDir, "package.json"));
+      return this.finalizeResult(packageResult, searchPaths, checkEnv, name, verbose);
+    }
+    searchPaths.push(...this.getAllSearchPaths(name, alias, baseDir, configDir));
+    if (throwOnNotFound) {
+      throw ErrorFactory.configNotFound(name, searchPaths, alias);
+    }
+    const envResult = await this.applyEnvironmentVariables(name, defaultConfig3, checkEnv, verbose);
+    return {
+      ...envResult,
+      warnings: [`No configuration file found for "${name}"${alias ? ` or alias "${alias}"` : ""}, using defaults with environment variables`]
+    };
   }
-  if (name) {
-    const homeConfigDir = resolve3(homedir(), ".config");
-    const homeConfigDotfilePatterns = [`.${name}.config`];
-    if (alias)
-      homeConfigDotfilePatterns.push(`.${alias}.config`);
-    if (verbose)
-      log.info(`Checking user config directory for dotfile configs: ${homeConfigDir}`);
-    for (const configPath of homeConfigDotfilePatterns) {
-      for (const ext of extensions) {
-        const fullPath = resolve3(homeConfigDir, `${configPath}${ext}`);
-        const config3 = await tryLoadConfig2(fullPath, configWithEnvVars, arrayStrategy);
-        if (config3 !== null) {
-          if (verbose)
-            log.success(`Configuration loaded from user config directory dotfile: ${fullPath}`);
-          return config3;
+  async loadLocalConfiguration(name, alias, baseDir, configDir, defaultConfig3, arrayStrategy, verbose, checkEnv, cacheOptions) {
+    const envDefaultConfig = checkEnv ? applyEnvVarsToConfig2(name, defaultConfig3, verbose) : defaultConfig3;
+    const searchDirectories = this.getLocalDirectories(baseDir, configDir);
+    for (const directory of searchDirectories) {
+      if (verbose) {
+        log2.info(`Searching for configuration in: ${directory}`);
+      }
+      const configPaths = this.fileLoader.generateConfigPaths(name, directory, alias);
+      const result = await this.fileLoader.tryLoadFromPaths(configPaths, envDefaultConfig, {
+        arrayStrategy,
+        verbose,
+        cacheTtl: cacheOptions?.ttl,
+        useCache: !cacheOptions?.ttl || cacheOptions.ttl > 100
+      });
+      if (result) {
+        if (verbose) {
+          log2.success(`Configuration loaded from: ${result.source.path}`);
         }
+        return result;
       }
     }
+    return null;
   }
-  if (name) {
-    const homeDir = homedir();
-    const homeRootPatterns = [`.${name}.config`, `.${name}`];
-    if (alias) {
-      homeRootPatterns.push(`.${alias}.config`);
-      homeRootPatterns.push(`.${alias}`);
-    }
-    if (verbose)
-      log.info(`Checking user home directory for dotfile configs: ${homeDir}`);
-    for (const configPath of homeRootPatterns) {
-      for (const ext of extensions) {
-        const fullPath = resolve3(homeDir, `${configPath}${ext}`);
-        const config3 = await tryLoadConfig2(fullPath, configWithEnvVars, arrayStrategy);
-        if (config3 !== null) {
-          if (verbose)
-            log.success(`Configuration loaded from user home directory: ${fullPath}`);
-          return config3;
+  async loadHomeConfiguration(name, alias, defaultConfig3, arrayStrategy, verbose, checkEnv) {
+    if (!name)
+      return null;
+    const envDefaultConfig = checkEnv ? applyEnvVarsToConfig2(name, defaultConfig3, verbose) : defaultConfig3;
+    const homeDirectories = [
+      resolve7(homedir2(), ".config", name),
+      resolve7(homedir2(), ".config"),
+      homedir2()
+    ];
+    for (const directory of homeDirectories) {
+      if (verbose) {
+        log2.info(`Checking home directory: ${directory}`);
+      }
+      const configPaths = this.fileLoader.generateConfigPaths(name, directory, alias);
+      const result = await this.fileLoader.tryLoadFromPaths(configPaths, envDefaultConfig, { arrayStrategy, verbose });
+      if (result) {
+        if (verbose) {
+          log2.success(`Configuration loaded from home directory: ${result.source.path}`);
         }
+        return result;
       }
     }
+    return null;
   }
-  try {
-    const pkgPath = resolve3(baseDir, "package.json");
-    if (existsSync3(pkgPath)) {
+  async loadPackageJsonConfiguration(name, alias, baseDir, defaultConfig3, arrayStrategy, verbose, checkEnv) {
+    const envDefaultConfig = checkEnv ? applyEnvVarsToConfig2(name, defaultConfig3, verbose) : defaultConfig3;
+    try {
+      const pkgPath = resolve7(baseDir, "package.json");
+      if (!existsSync8(pkgPath)) {
+        return null;
+      }
       const pkg = await import(pkgPath);
       let pkgConfig = pkg[name];
+      let usedName = name;
       if (!pkgConfig && alias) {
         pkgConfig = pkg[alias];
-        if (pkgConfig && verbose) {
-          log.success(`Using alias "${alias}" configuration from package.json`);
-        }
+        usedName = alias;
       }
       if (pkgConfig && typeof pkgConfig === "object" && !Array.isArray(pkgConfig)) {
-        try {
-          if (verbose) {
-            log.success(`Configuration loaded from package.json: ${pkgConfig === pkg[name] ? name : alias}`);
-          }
-          return deepMergeWithArrayStrategy(configWithEnvVars, pkgConfig, arrayStrategy);
-        } catch (error) {
-          if (verbose) {
-            log.warn(`Failed to merge package.json config:`, error);
+        if (verbose) {
+          log2.success(`Configuration loaded from package.json: ${usedName}`);
+        }
+        const mergedConfig = deepMergeWithArrayStrategy2(envDefaultConfig, pkgConfig, arrayStrategy);
+        return {
+          config: mergedConfig,
+          source: {
+            type: "package.json",
+            path: pkgPath,
+            priority: 30,
+            timestamp: new Date
           }
+        };
+      }
+    } catch (error) {
+      if (verbose) {
+        log2.warn(`Failed to load package.json:`, [error instanceof Error ? error : new Error(String(error))]);
+      }
+    }
+    return null;
+  }
+  async applyEnvironmentVariables(name, config3, checkEnv, verbose) {
+    if (!checkEnv || !name || typeof config3 !== "object" || config3 === null || Array.isArray(config3)) {
+      return {
+        config: config3,
+        source: {
+          type: "default",
+          priority: 10,
+          timestamp: new Date
         }
+      };
+    }
+    const processedConfig = applyEnvVarsToConfig2(name, config3, verbose);
+    return {
+      config: processedConfig,
+      source: {
+        type: "environment",
+        priority: 20,
+        timestamp: new Date
       }
+    };
+  }
+  async finalizeResult(result, _searchPaths, _checkEnv, _name, _verbose) {
+    return {
+      config: result.config,
+      source: result.source,
+      path: result.source.path
+    };
+  }
+  async validateConfiguration(config3, schema, customValidator, configName) {
+    const errors = [];
+    if (customValidator) {
+      const customErrors = customValidator(config3);
+      if (customErrors) {
+        errors.push(...customErrors);
+      }
+    }
+    if (schema) {
+      const validationResult = await this.validator.validateConfiguration(config3, schema);
+      if (!validationResult.isValid) {
+        errors.push(...validationResult.errors.map((e) => e.path ? `${e.path}: ${e.message}` : e.message));
+      }
+    }
+    if (errors.length > 0) {
+      throw ErrorFactory.configValidation(configName || "unknown", errors, configName);
+    }
+  }
+  checkCache(configName, options) {
+    const cacheKey = this.generateCacheKey(configName, options);
+    const result = globalCache.get(cacheKey);
+    return result || null;
+  }
+  cacheResult(configName, result, cacheOptions, options) {
+    const cacheKey = this.generateCacheKey(configName, options);
+    globalCache.set(cacheKey, result, undefined, cacheOptions.ttl);
+  }
+  generateCacheKey(configName, options) {
+    const keyParts = [configName];
+    if (options.alias)
+      keyParts.push(`alias:${options.alias}`);
+    if (options.cwd)
+      keyParts.push(`cwd:${options.cwd}`);
+    if (options.configDir)
+      keyParts.push(`configDir:${options.configDir}`);
+    if ("checkEnv" in options)
+      keyParts.push(`checkEnv:${options.checkEnv}`);
+    return keyParts.join("|");
+  }
+  getLocalDirectories(baseDir, configDir) {
+    return Array.from(new Set([
+      baseDir,
+      resolve7(baseDir, "config"),
+      resolve7(baseDir, ".config"),
+      configDir ? resolve7(baseDir, configDir) : undefined
+    ].filter(Boolean)));
+  }
+  getAllSearchPaths(name, alias, baseDir, configDir) {
+    const paths = [];
+    paths.push(...this.getLocalSearchPaths(name, alias, baseDir, configDir));
+    paths.push(...this.getHomeSearchPaths(name, alias));
+    paths.push(resolve7(baseDir, "package.json"));
+    return paths;
+  }
+  getLocalSearchPaths(name, alias, baseDir, configDir) {
+    const directories = this.getLocalDirectories(baseDir, configDir);
+    const paths = [];
+    for (const directory of directories) {
+      paths.push(...this.fileLoader.generateConfigPaths(name, directory, alias));
+    }
+    return paths;
+  }
+  getHomeSearchPaths(name, alias) {
+    if (!name)
+      return [];
+    const homeDirectories = [
+      resolve7(homedir2(), ".config", name),
+      resolve7(homedir2(), ".config"),
+      homedir2()
+    ];
+    const paths = [];
+    for (const directory of homeDirectories) {
+      paths.push(...this.fileLoader.generateConfigPaths(name, directory, alias));
+    }
+    return paths;
+  }
+  async loadConfigWithResult(options) {
+    return this.loadConfig(options);
+  }
+}
+async function loadConfig5(options) {
+  const defaultConfig3 = "defaultConfig" in options && options.defaultConfig !== undefined ? options.defaultConfig : {};
+  const isEnhanced = "cache" in options || "performance" in options || "schema" in options || "validate" in options;
+  try {
+    let result;
+    if (isEnhanced) {
+      result = await globalConfigLoader.loadConfig(options);
+    } else {
+      result = await globalConfigLoader.loadConfig({
+        ...options,
+        defaultConfig: defaultConfig3,
+        cache: { enabled: true },
+        performance: { enabled: false }
+      });
     }
+    return result?.config ?? defaultConfig3;
   } catch (error) {
-    if (verbose) {
-      log.warn(`Failed to load package.json:`, error);
+    const errorName = error instanceof Error ? error.name : "UnknownError";
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    const isConfigError = errorName === "ConfigNotFoundError" || errorName === "ConfigLoadError" || errorName === "ConfigValidationError" || errorMessage.includes("config");
+    if (!isConfigError && options.verbose) {
+      log2.warn(`Unexpected error loading config, using defaults:`, [error instanceof Error ? error : new Error(String(error))]);
+    }
+    const configOptions = isEnhanced ? { ...options, defaultConfig: defaultConfig3 } : {
+      ...options,
+      defaultConfig: defaultConfig3,
+      cache: { enabled: true },
+      performance: { enabled: false }
+    };
+    const shouldCheckEnv = "checkEnv" in options ? options.checkEnv !== false : true;
+    if (shouldCheckEnv) {
+      const envResult = await globalConfigLoader.applyEnvironmentVariables(configOptions.name || "", defaultConfig3, true, configOptions.verbose || false);
+      return envResult?.config ?? defaultConfig3;
     }
+    return defaultConfig3;
   }
-  if (verbose) {
-    log.info(`No configuration found for "${name}"${alias ? ` or alias "${alias}"` : ""}, using default configuration with environment variables`);
+}
+function applyEnvVarsToConfig2(name, config4, verbose = false) {
+  const _envProcessor = new EnvProcessor;
+  const envPrefix = name.toUpperCase().replace(/[^A-Z0-9]/g, "_");
+  function processConfigLevel(obj, path = []) {
+    const result = { ...obj };
+    for (const [key, value] of Object.entries(obj)) {
+      const currentPath = [...path, key];
+      const envKeys = [
+        `${envPrefix}_${currentPath.join("_").toUpperCase()}`,
+        `${envPrefix}_${currentPath.map((k) => k.toUpperCase()).join("")}`,
+        `${envPrefix}_${currentPath.map((k) => k.replace(/([A-Z])/g, "_$1").toUpperCase()).join("")}`
+      ];
+      let envValue;
+      let usedKey;
+      for (const envKey of envKeys) {
+        envValue = process12.env[envKey];
+        if (envValue !== undefined) {
+          usedKey = envKey;
+          break;
+        }
+      }
+      if (envValue !== undefined && usedKey) {
+        if (verbose) {}
+        if (typeof value === "boolean") {
+          result[key] = ["true", "1", "yes"].includes(envValue.toLowerCase());
+        } else if (typeof value === "number") {
+          const parsed = Number(envValue);
+          if (!Number.isNaN(parsed)) {
+            result[key] = parsed;
+          }
+        } else if (Array.isArray(value)) {
+          try {
+            result[key] = JSON.parse(envValue);
+          } catch {
+            result[key] = envValue.split(",").map((s) => s.trim());
+          }
+        } else {
+          result[key] = envValue;
+        }
+      } else if (value && typeof value === "object" && !Array.isArray(value)) {
+        result[key] = processConfigLevel(value, currentPath);
+      }
+    }
+    return result;
   }
-  return configWithEnvVars;
+  return processConfigLevel(config4);
 }
-var defaultConfigDir, defaultGeneratedDir, defaultLogDirectory, defaultConfig, config, terminalStyles, styles, red, green, yellow, blue, magenta, cyan, white, gray, bgRed, bgYellow, bold, dim, italic, underline, reset, defaultFingersCrossedConfig, levelIcons, logger, log, defaultConfigDir2, defaultGeneratedDir2;
+var globalCache, globalPerformanceMonitor, defaultConfigDir, defaultGeneratedDir, defaultLogDirectory, defaultConfig, config, terminalStyles, styles, red, green, yellow, blue, magenta, cyan, white, gray, bgRed, bgYellow, bold, dim, italic, underline, reset, defaultFingersCrossedConfig, levelIcons, logger, log, defaultConfigDir2, defaultGeneratedDir2, defaultLogDirectory2, defaultConfig2, config2, terminalStyles2, styles2, red2, green2, yellow2, blue2, magenta2, cyan2, white2, gray2, bgRed2, bgYellow2, bgGray, bold2, dim2, italic2, underline2, strikethrough, reset2, defaultFingersCrossedConfig2, levelIcons2, logger2, BunfigError, ConfigNotFoundError, ConfigLoadError, ConfigValidationError, ConfigMergeError, EnvVarError, FileSystemError, TypeGenerationError, SchemaValidationError, BrowserConfigError, PluginError, ErrorFactory, log2, globalConfigLoader, defaultConfigDir3, defaultGeneratedDir3;
 var init_dist = __esm(async () => {
+  globalCache = new ConfigCache;
+  globalPerformanceMonitor = new PerformanceMonitor;
   defaultConfigDir = resolve(process.cwd(), "config");
   defaultGeneratedDir = resolve(process.cwd(), "src/generated");
   defaultLogDirectory = process2.env.CLARITY_LOG_DIR || join(getProjectRoot(), "logs");
@@ -1865,13 +4813,271 @@ var init_dist = __esm(async () => {
   });
   defaultConfigDir2 = resolve3(process6.cwd(), "config");
   defaultGeneratedDir2 = resolve3(process6.cwd(), "src/generated");
+  defaultLogDirectory2 = process7.env.CLARITY_LOG_DIR || join3(getProjectRoot2(), "logs");
+  defaultConfig2 = {
+    level: "info",
+    defaultName: "clarity",
+    timestamp: true,
+    colors: true,
+    format: "text",
+    maxLogSize: 10485760,
+    logDatePattern: "YYYY-MM-DD",
+    logDirectory: defaultLogDirectory2,
+    rotation: {
+      frequency: "daily",
+      maxSize: 10485760,
+      maxFiles: 5,
+      compress: false,
+      rotateHour: 0,
+      rotateMinute: 0,
+      rotateDayOfWeek: 0,
+      rotateDayOfMonth: 1,
+      encrypt: false
+    },
+    verbose: false,
+    writeToFile: false
+  };
+  config2 = await loadConfig4();
+  terminalStyles2 = {
+    red: (text) => `\x1B[31m${text}\x1B[0m`,
+    green: (text) => `\x1B[32m${text}\x1B[0m`,
+    yellow: (text) => `\x1B[33m${text}\x1B[0m`,
+    blue: (text) => `\x1B[34m${text}\x1B[0m`,
+    magenta: (text) => `\x1B[35m${text}\x1B[0m`,
+    cyan: (text) => `\x1B[36m${text}\x1B[0m`,
+    white: (text) => `\x1B[37m${text}\x1B[0m`,
+    gray: (text) => `\x1B[90m${text}\x1B[0m`,
+    bgRed: (text) => `\x1B[41m${text}\x1B[0m`,
+    bgYellow: (text) => `\x1B[43m${text}\x1B[0m`,
+    bgGray: (text) => `\x1B[100m${text}\x1B[0m`,
+    bold: (text) => `\x1B[1m${text}\x1B[0m`,
+    dim: (text) => `\x1B[2m${text}\x1B[0m`,
+    italic: (text) => `\x1B[3m${text}\x1B[0m`,
+    underline: (text) => `\x1B[4m${text}\x1B[0m`,
+    strikethrough: (text) => `\x1B[9m${text}\x1B[0m`,
+    reset: "\x1B[0m"
+  };
+  styles2 = terminalStyles2;
+  red2 = terminalStyles2.red;
+  green2 = terminalStyles2.green;
+  yellow2 = terminalStyles2.yellow;
+  blue2 = terminalStyles2.blue;
+  magenta2 = terminalStyles2.magenta;
+  cyan2 = terminalStyles2.cyan;
+  white2 = terminalStyles2.white;
+  gray2 = terminalStyles2.gray;
+  bgRed2 = terminalStyles2.bgRed;
+  bgYellow2 = terminalStyles2.bgYellow;
+  bgGray = terminalStyles2.bgGray;
+  bold2 = terminalStyles2.bold;
+  dim2 = terminalStyles2.dim;
+  italic2 = terminalStyles2.italic;
+  underline2 = terminalStyles2.underline;
+  strikethrough = terminalStyles2.strikethrough;
+  reset2 = terminalStyles2.reset;
+  defaultFingersCrossedConfig2 = {
+    activationLevel: "error",
+    bufferSize: 50,
+    flushOnDeactivation: true,
+    stopBuffering: false
+  };
+  levelIcons2 = {
+    debug: "\uD83D\uDD0D",
+    info: blue2("\u2139"),
+    success: green2("\u2713"),
+    warning: bgYellow2(white2(bold2(" WARN "))),
+    error: bgRed2(white2(bold2(" ERROR ")))
+  };
+  logger2 = new Logger2("stacks");
+  BunfigError = class BunfigError extends Error {
+    timestamp;
+    context;
+    constructor(message, context = {}) {
+      super(message);
+      this.name = this.constructor.name;
+      this.timestamp = new Date;
+      this.context = context;
+      if (Error.captureStackTrace) {
+        Error.captureStackTrace(this, this.constructor);
+      }
+    }
+    toJSON() {
+      return {
+        name: this.name,
+        code: this.code,
+        message: this.message,
+        timestamp: this.timestamp.toISOString(),
+        context: this.context,
+        stack: this.stack
+      };
+    }
+    toString() {
+      const contextStr = Object.keys(this.context).length > 0 ? ` (${Object.entries(this.context).map(([k, v]) => `${k}: ${v}`).join(", ")})` : "";
+      return `${this.name} [${this.code}]: ${this.message}${contextStr}`;
+    }
+  };
+  ConfigNotFoundError = class ConfigNotFoundError extends BunfigError {
+    code = "CONFIG_NOT_FOUND";
+    constructor(configName, searchPaths, alias) {
+      const aliasStr = alias ? ` or alias "${alias}"` : "";
+      super(`Configuration "${configName}"${aliasStr} not found`, {
+        configName,
+        alias,
+        searchPaths,
+        searchPathCount: searchPaths.length
+      });
+    }
+  };
+  ConfigLoadError = class ConfigLoadError extends BunfigError {
+    code = "CONFIG_LOAD_ERROR";
+    constructor(configPath, cause, configName) {
+      super(`Failed to load configuration from "${configPath}": ${cause.message}`, {
+        configPath,
+        configName,
+        originalError: cause.name,
+        originalMessage: cause.message
+      });
+      this.cause = cause;
+    }
+  };
+  ConfigValidationError = class ConfigValidationError extends BunfigError {
+    code = "CONFIG_VALIDATION_ERROR";
+    constructor(configPath, validationErrors, configName) {
+      super(`Configuration validation failed for "${configPath}"`, {
+        configPath,
+        configName,
+        validationErrors,
+        errorCount: validationErrors.length
+      });
+    }
+  };
+  ConfigMergeError = class ConfigMergeError extends BunfigError {
+    code = "CONFIG_MERGE_ERROR";
+    constructor(sourcePath, targetPath, cause, configName) {
+      super(`Failed to merge configuration from "${sourcePath}" with "${targetPath}": ${cause.message}`, {
+        sourcePath,
+        targetPath,
+        configName,
+        originalError: cause.name,
+        originalMessage: cause.message
+      });
+      this.cause = cause;
+    }
+  };
+  EnvVarError = class EnvVarError extends BunfigError {
+    code = "ENV_VAR_ERROR";
+    constructor(envKey, envValue, expectedType, configName) {
+      super(`Failed to parse environment variable "${envKey}" with value "${envValue}" as ${expectedType}`, {
+        envKey,
+        envValue,
+        expectedType,
+        configName
+      });
+    }
+  };
+  FileSystemError = class FileSystemError extends BunfigError {
+    code = "FILE_SYSTEM_ERROR";
+    constructor(operation, path, cause) {
+      super(`File system ${operation} failed for "${path}": ${cause.message}`, {
+        operation,
+        path,
+        originalError: cause.name,
+        originalMessage: cause.message
+      });
+      this.cause = cause;
+    }
+  };
+  TypeGenerationError = class TypeGenerationError extends BunfigError {
+    code = "TYPE_GENERATION_ERROR";
+    constructor(configDir, outputPath, cause) {
+      super(`Failed to generate types from "${configDir}" to "${outputPath}": ${cause.message}`, {
+        configDir,
+        outputPath,
+        originalError: cause.name,
+        originalMessage: cause.message
+      });
+      this.cause = cause;
+    }
+  };
+  SchemaValidationError = class SchemaValidationError extends BunfigError {
+    code = "SCHEMA_VALIDATION_ERROR";
+    constructor(schemaPath, validationErrors, configName) {
+      super(`Schema validation failed${configName ? ` for config "${configName}"` : ""}`, {
+        schemaPath,
+        configName,
+        validationErrors,
+        errorCount: validationErrors.length
+      });
+    }
+  };
+  BrowserConfigError = class BrowserConfigError extends BunfigError {
+    code = "BROWSER_CONFIG_ERROR";
+    constructor(endpoint, status, statusText, configName) {
+      super(`Failed to fetch configuration from "${endpoint}": ${status} ${statusText}`, {
+        endpoint,
+        status,
+        statusText,
+        configName
+      });
+    }
+  };
+  PluginError = class PluginError extends BunfigError {
+    code = "PLUGIN_ERROR";
+    constructor(pluginName, operation, cause) {
+      super(`Plugin "${pluginName}" failed during ${operation}: ${cause.message}`, {
+        pluginName,
+        operation,
+        originalError: cause.name,
+        originalMessage: cause.message
+      });
+      this.cause = cause;
+    }
+  };
+  ErrorFactory = {
+    configNotFound(configName, searchPaths, alias) {
+      return new ConfigNotFoundError(configName, searchPaths, alias);
+    },
+    configLoad(configPath, cause, configName) {
+      return new ConfigLoadError(configPath, cause, configName);
+    },
+    configValidation(configPath, errors, configName) {
+      return new ConfigValidationError(configPath, errors, configName);
+    },
+    configMerge(sourcePath, targetPath, cause, configName) {
+      return new ConfigMergeError(sourcePath, targetPath, cause, configName);
+    },
+    envVar(envKey, envValue, expectedType, configName) {
+      return new EnvVarError(envKey, envValue, expectedType, configName);
+    },
+    fileSystem(operation, path, cause) {
+      return new FileSystemError(operation, path, cause);
+    },
+    typeGeneration(configDir, outputPath, cause) {
+      return new TypeGenerationError(configDir, outputPath, cause);
+    },
+    schemaValidation(schemaPath, errors, configName) {
+      return new SchemaValidationError(schemaPath, errors, configName);
+    },
+    browserConfig(endpoint, status, statusText, configName) {
+      return new BrowserConfigError(endpoint, status, statusText, configName);
+    },
+    plugin(pluginName, operation, cause) {
+      return new PluginError(pluginName, operation, cause);
+    }
+  };
+  log2 = new Logger2("bunfig", {
+    showTags: true
+  });
+  globalConfigLoader = new ConfigLoader;
+  defaultConfigDir3 = resolve7(process12.cwd(), "config");
+  defaultGeneratedDir3 = resolve7(process12.cwd(), "src/generated");
 });
 
 // src/config.ts
-var defaultConfig2, config2;
+var defaultConfig3, config3;
 var init_config = __esm(async () => {
   await init_dist();
-  defaultConfig2 = {
+  defaultConfig3 = {
     verbose: true,
     dialect: "postgres",
     database: {
@@ -1928,16 +5134,16 @@ var init_config = __esm(async () => {
       defaultFilter: true
     }
   };
-  config2 = await loadConfig3({
+  config3 = await loadConfig5({
     name: "query-builder",
     alias: "qb",
-    defaultConfig: defaultConfig2
+    defaultConfig: defaultConfig3
   });
 });
 
 // src/db.ts
 var {SQL } = globalThis.Bun;
-import process7 from "process";
+import process13 from "process";
 function createConnectionString(dialect, dbConfig) {
   if (dbConfig.url) {
     return dbConfig.url;
@@ -1958,12 +5164,12 @@ function createConnectionString(dialect, dbConfig) {
   }
 }
 function getBunSql() {
-  const connectionString = createConnectionString(config2.dialect, config2.database);
+  const connectionString = createConnectionString(config3.dialect, config3.database);
   try {
     const sql = new SQL(connectionString);
     if (sql && typeof sql.catch === "function") {
       sql.catch((error) => {
-        if (config2.verbose && !error.message.includes("database") && !error.message.includes("does not exist")) {
+        if (config3.verbose && !error.message.includes("database") && !error.message.includes("does not exist")) {
           console.warn(`[query-builder] Database connection error: ${error.message}`);
         }
       });
@@ -2007,14 +5213,14 @@ var _bunSqlInstance = null, bunSql;
 var init_db = __esm(async () => {
   await init_config();
   bunSql = getOrCreateBunSql();
-  if (typeof process7 !== "undefined" && process7.on) {
-    const existingHandler = process7.listeners("unhandledRejection").find((h) => h.name === "sqlConnectionErrorHandler");
+  if (typeof process13 !== "undefined" && process13.on) {
+    const existingHandler = process13.listeners("unhandledRejection").find((h) => h.name === "sqlConnectionErrorHandler");
     if (!existingHandler) {
       let sqlConnectionErrorHandler = function(reason) {
         if (reason && (reason.message?.includes("database") || reason.message?.includes("does not exist") || reason.code === "ERR_POSTGRES_SERVER_ERROR" || reason.code === "3D000")) {}
       };
       Object.defineProperty(sqlConnectionErrorHandler, "name", { value: "sqlConnectionErrorHandler" });
-      process7.on("unhandledRejection", sqlConnectionErrorHandler);
+      process13.on("unhandledRejection", sqlConnectionErrorHandler);
     }
   }
 });
@@ -2233,7 +5439,7 @@ function matchesSqlState(err, states) {
   return states.includes(code);
 }
 function sleep(ms) {
-  return new Promise((resolve4) => setTimeout(resolve4, ms));
+  return new Promise((resolve8) => setTimeout(resolve8, ms));
 }
 function computeBackoffMs(attempt, cfg) {
   const base = Math.max(1, cfg?.baseMs ?? 50);
@@ -2313,16 +5519,16 @@ function createQueryBuilder(state) {
     return _sql`${q} WHERE ${condition}`;
   }
   function computeSqlText(q) {
-    const prev = config2.debug?.captureText;
-    if (config2.debug)
-      config2.debug.captureText = true;
+    const prev = config3.debug?.captureText;
+    if (config3.debug)
+      config3.debug.captureText = true;
     const s = String(q);
-    if (config2.debug)
-      config2.debug.captureText = prev;
+    if (config3.debug)
+      config3.debug.captureText = prev;
     return s;
   }
   function runWithHooks(q, kind, opts) {
-    const hooks = config2.hooks;
+    const hooks = config3.hooks;
     const hasHooks = hooks && (hooks.onQueryStart || hooks.onQueryEnd || hooks.onQueryError || hooks.startSpan);
     const hasTimeoutOrSignal = opts?.timeoutMs && opts.timeoutMs > 0 || opts?.signal;
     if (!hasHooks && !hasTimeoutOrSignal) {
@@ -2671,7 +5877,7 @@ function createQueryBuilder(state) {
         }
         if (normalizedRelations.length === 0)
           return this;
-        const maxEagerLoad = config2.relations.maxEagerLoad ?? 50;
+        const maxEagerLoad = config3.relations.maxEagerLoad ?? 50;
         if (normalizedRelations.length > maxEagerLoad) {
           throw new Error(`[query-builder] Too many relationships to eager load (${normalizedRelations.length}). Maximum allowed: ${maxEagerLoad}`);
         }
@@ -2680,7 +5886,7 @@ function createQueryBuilder(state) {
         const loadedRelationships = new Set;
         const relationConditions = new Map;
         const singularize = (name) => {
-          if (config2.relations.singularizeStrategy === "none")
+          if (config3.relations.singularizeStrategy === "none")
             return name;
           return name.endsWith("s") ? name.slice(0, -1) : name;
         };
@@ -2702,7 +5908,7 @@ function createQueryBuilder(state) {
           ];
         };
         const addJoin = (fromTable, relationKey, depth = 0, condition) => {
-          const maxDepth = config2.relations.maxDepth ?? 10;
+          const maxDepth = config3.relations.maxDepth ?? 10;
           if (depth >= maxDepth) {
             throw new Error(`[query-builder] Maximum relationship depth (${maxDepth}) exceeded at '${relationKey}'. Consider using separate queries or increasing maxDepth.`);
           }
@@ -2712,8 +5918,8 @@ function createQueryBuilder(state) {
           }
           const _buildConditionalJoin = (baseJoinCondition, targetTable2) => {
             let joinCondition = baseJoinCondition;
-            if (config2.softDeletes?.enabled && config2.softDeletes?.defaultFilter) {
-              const softDeleteColumn = config2.softDeletes.column || "deleted_at";
+            if (config3.softDeletes?.enabled && config3.softDeletes?.defaultFilter) {
+              const softDeleteColumn = config3.softDeletes.column || "deleted_at";
               joinCondition = `${joinCondition} AND ${targetTable2}.${softDeleteColumn} IS NULL`;
             }
             if (!condition)
@@ -2733,8 +5939,8 @@ function createQueryBuilder(state) {
             return joinCondition;
           };
           const addSoftDeleteCheck = (table2) => {
-            if (config2.softDeletes?.enabled && config2.softDeletes?.defaultFilter) {
-              const softDeleteColumn = config2.softDeletes.column || "deleted_at";
+            if (config3.softDeletes?.enabled && config3.softDeletes?.defaultFilter) {
+              const softDeleteColumn = config3.softDeletes.column || "deleted_at";
               return ` AND ${table2}.${softDeleteColumn} IS NULL`;
             }
             return "";
@@ -2759,7 +5965,7 @@ function createQueryBuilder(state) {
               throw new Error(`[query-builder] Relationship '${relationKey}' not found on table '${fromTable}'.${suggestion}`);
             }
           }
-          if (config2.relations.detectCycles !== false) {
+          if (config3.relations.detectCycles !== false) {
             const cycleKey = `${fromTable}->${childTable}`;
             if (visitedTables.has(cycleKey)) {
               throw new Error(`[query-builder] Circular relationship detected: ${cycleKey}. This would cause an infinite loop.`);
@@ -3168,7 +6374,7 @@ function createQueryBuilder(state) {
         return this;
       },
       whereJsonPath(path, op, value) {
-        const dialect = config2.dialect;
+        const dialect = config3.dialect;
         if (dialect === "postgres") {
           built = sql`${built} WHERE ${sql(path)} ${op} ${value}`;
         } else if (dialect === "mysql") {
@@ -3185,7 +6391,7 @@ function createQueryBuilder(state) {
         return this;
       },
       whereILike(column, pattern) {
-        if (config2.dialect === "postgres") {
+        if (config3.dialect === "postgres") {
           built = sql`${built} WHERE ${sql(String(column))} ILIKE ${pattern}`;
           addWhereText("WHERE", `${String(column)} ILIKE ?`);
         } else {
@@ -3202,7 +6408,7 @@ function createQueryBuilder(state) {
         return this;
       },
       orWhereILike(column, pattern) {
-        if (config2.dialect === "postgres") {
+        if (config3.dialect === "postgres") {
           built = sql`${built} OR ${sql(String(column))} ILIKE ${pattern}`;
           addWhereText("OR", `${String(column)} ILIKE ?`);
         } else {
@@ -3219,7 +6425,7 @@ function createQueryBuilder(state) {
         return this;
       },
       whereNotILike(column, pattern) {
-        if (config2.dialect === "postgres") {
+        if (config3.dialect === "postgres") {
           built = sql`${built} WHERE ${sql(String(column))} NOT ILIKE ${pattern}`;
           addWhereText("WHERE", `${String(column)} NOT ILIKE ?`);
         } else {
@@ -3236,7 +6442,7 @@ function createQueryBuilder(state) {
         return this;
       },
       orWhereNotILike(column, pattern) {
-        if (config2.dialect === "postgres") {
+        if (config3.dialect === "postgres") {
           built = sql`${built} OR ${sql(String(column))} NOT ILIKE ${pattern}`;
           addWhereText("OR", `${String(column)} NOT ILIKE ?`);
         } else {
@@ -3448,7 +6654,7 @@ function createQueryBuilder(state) {
         return this;
       },
       inRandomOrder() {
-        const rnd = config2.sql.randomFunction === "RAND()" ? sql`RAND()` : sql`RANDOM()`;
+        const rnd = config3.sql.randomFunction === "RAND()" ? sql`RAND()` : sql`RANDOM()`;
         built = sql`${built} ORDER BY ${rnd}`;
         return this;
       },
@@ -3457,12 +6663,12 @@ function createQueryBuilder(state) {
         return this;
       },
       latest(column) {
-        const col = column ?? config2.timestamps.defaultOrderColumn;
+        const col = column ?? config3.timestamps.defaultOrderColumn;
         built = sql`${built} ORDER BY ${sql(String(col))} DESC`;
         return this;
       },
       oldest(column) {
-        const col = column ?? config2.timestamps.defaultOrderColumn;
+        const col = column ?? config3.timestamps.defaultOrderColumn;
         built = sql`${built} ORDER BY ${sql(String(col))} ASC`;
         return this;
       },
@@ -3529,7 +6735,7 @@ function createQueryBuilder(state) {
         for (const jt of joinedTables) {
           const cols = Object.keys(schema[jt]?.columns ?? {});
           for (const c of cols) {
-            const alias = config2.aliasing.relationColumnAliasFormat === "camelCase" ? `${jt}_${c}`.replace(/_([a-z])/g, (_, ch) => ch.toUpperCase()) : config2.aliasing.relationColumnAliasFormat === "table.dot.column" ? `${jt}.${c}` : `${jt}_${c}`;
+            const alias = config3.aliasing.relationColumnAliasFormat === "camelCase" ? `${jt}_${c}`.replace(/_([a-z])/g, (_, ch) => ch.toUpperCase()) : config3.aliasing.relationColumnAliasFormat === "table.dot.column" ? `${jt}.${c}` : `${jt}_${c}`;
             parts.push(sql`${sql(`${jt}.${c}`)} AS ${sql(alias)}`);
           }
         }
@@ -3717,7 +6923,7 @@ function createQueryBuilder(state) {
       onlyTrashed() {
         includeTrashed = true;
         onlyTrashed = true;
-        const softDeleteColumn = config2.softDeletes?.column || "deleted_at";
+        const softDeleteColumn = config3.softDeletes?.column || "deleted_at";
         if (text.includes("WHERE")) {
           text = text.replace(/WHERE/, `WHERE ${table}.${softDeleteColumn} IS NOT NULL AND`);
         } else {
@@ -3777,7 +6983,7 @@ function createQueryBuilder(state) {
       },
       async get() {
         built = whereParams.length > 0 ? _sql.unsafe(text, whereParams) : _sql.unsafe(text);
-        if (!config2.softDeletes?.enabled && !useCache && !timeoutMs && !abortSignal && !config2.hooks) {
+        if (!config3.softDeletes?.enabled && !useCache && !timeoutMs && !abortSignal && !config3.hooks) {
           const stmt = built._stmt;
           const params = built._params;
           if (stmt) {
@@ -3785,12 +6991,12 @@ function createQueryBuilder(state) {
           }
           return built.execute();
         }
-        if (!config2.softDeletes?.enabled && !useCache && !timeoutMs && !abortSignal) {
+        if (!config3.softDeletes?.enabled && !useCache && !timeoutMs && !abortSignal) {
           return runWithHooks(built, "select");
         }
         let finalQuery = built;
-        if (config2.softDeletes?.enabled && config2.softDeletes.defaultFilter && !includeTrashed) {
-          const col = config2.softDeletes.column;
+        if (config3.softDeletes?.enabled && config3.softDeletes.defaultFilter && !includeTrashed) {
+          const col = config3.softDeletes.column;
           const tbl = String(table);
           const hasCol = schema ? Boolean(schema[tbl]?.columns?.[col]) : true;
           if (hasCol && !SQL_PATTERNS.DELETED_AT.test(text)) {
@@ -3921,7 +7127,7 @@ function createQueryBuilder(state) {
         return this;
       },
       sharedLock() {
-        const syntax = config2.sql.sharedLockSyntax === "LOCK IN SHARE MODE" ? sql`LOCK IN SHARE MODE` : sql`FOR SHARE`;
+        const syntax = config3.sql.sharedLockSyntax === "LOCK IN SHARE MODE" ? sql`LOCK IN SHARE MODE` : sql`FOR SHARE`;
         built = sql`${built} ${syntax}`;
         return this;
       },
@@ -3989,7 +7195,7 @@ function createQueryBuilder(state) {
   }
   return {
     configure(opts) {
-      Object.assign(config2, opts);
+      Object.assign(config3, opts);
       return this;
     },
     id(name) {
@@ -4417,13 +7623,13 @@ function createQueryBuilder(state) {
         },
         async execute() {
           try {
-            await config2.hooks?.beforeDelete?.({ table: String(table), where: whereCondition });
+            await config3.hooks?.beforeDelete?.({ table: String(table), where: whereCondition });
           } catch (err) {
             throw err;
           }
           const result = await runWithHooks(built, "delete");
           try {
-            await config2.hooks?.afterDelete?.({ table: String(table), where: whereCondition, result });
+            await config3.hooks?.afterDelete?.({ table: String(table), where: whereCondition, result });
           } catch {}
           return result;
         }
@@ -4457,7 +7663,7 @@ function createQueryBuilder(state) {
       return _sql(strings, ...values).simple();
     },
     async advisoryLock(key) {
-      if (config2.dialect !== "postgres")
+      if (config3.dialect !== "postgres")
         return;
       const s = String(key);
       let hash = 7;
@@ -4468,7 +7674,7 @@ function createQueryBuilder(state) {
       await runWithHooks(q, "raw");
     },
     async tryAdvisoryLock(key) {
-      if (config2.dialect !== "postgres")
+      if (config3.dialect !== "postgres")
         return false;
       const s = String(key);
       let hash = 7;
@@ -4520,7 +7726,7 @@ function createQueryBuilder(state) {
       for (let i = 0;i < attempts; i++) {
         if (await this.ping())
           return;
-        await new Promise((resolve4) => setTimeout(resolve4, delay));
+        await new Promise((resolve8) => setTimeout(resolve8, delay));
       }
       throw new Error("Database not ready after waiting");
     },
@@ -4610,7 +7816,7 @@ function createQueryBuilder(state) {
       return built.execute();
     },
     async insertGetId(table, values, idColumn = "id") {
-      if (config2.dialect === "mysql") {
+      if (config3.dialect === "mysql") {
         const insertQuery = bunSql`INSERT INTO ${bunSql(String(table))} ${bunSql(values)}`;
         const result = await insertQuery.execute();
         if (result && typeof result === "object" && "insertId" in result) {
@@ -4685,23 +7891,23 @@ function createQueryBuilder(state) {
     async rawQuery(query) {
       const start = Date.now();
       try {
-        config2.hooks?.onQueryStart?.({ sql: query, kind: "raw" });
+        config3.hooks?.onQueryStart?.({ sql: query, kind: "raw" });
         const res = await bunSql.unsafe(query);
-        config2.hooks?.onQueryEnd?.({ sql: query, durationMs: Date.now() - start, kind: "raw" });
+        config3.hooks?.onQueryEnd?.({ sql: query, durationMs: Date.now() - start, kind: "raw" });
         return res;
       } catch (err) {
-        config2.hooks?.onQueryError?.({ sql: query, error: err, durationMs: Date.now() - start, kind: "raw" });
+        config3.hooks?.onQueryError?.({ sql: query, error: err, durationMs: Date.now() - start, kind: "raw" });
         throw err;
       }
     },
     async create(table, values) {
       const pk = meta?.primaryKeys[String(table)] ?? "id";
       try {
-        await config2.hooks?.beforeCreate?.({ table: String(table), data: values });
+        await config3.hooks?.beforeCreate?.({ table: String(table), data: values });
       } catch (err) {
         throw err;
       }
-      if (config2.dialect === "postgres") {
+      if (config3.dialect === "postgres") {
         const q = bunSql`INSERT INTO ${bunSql(String(table))} ${bunSql(values)} RETURNING ${bunSql(String(pk))} as id`;
         const [result] = await q.execute();
         console.log("resultId", result);
@@ -4717,7 +7923,7 @@ function createQueryBuilder(state) {
           throw new Error(`create() failed to retrieve inserted row for table ${String(table)} with id ${result.id}`);
         }
         try {
-          await config2.hooks?.afterCreate?.({ table: String(table), data: values, result: row });
+          await config3.hooks?.afterCreate?.({ table: String(table), data: values, result: row });
         } catch {}
         return row;
       } else {
@@ -4732,7 +7938,7 @@ function createQueryBuilder(state) {
           throw new Error(`create() failed to retrieve inserted row for table ${String(table)} with id ${id}`);
         }
         try {
-          await config2.hooks?.afterCreate?.({ table: String(table), data: values, result: row });
+          await config3.hooks?.afterCreate?.({ table: String(table), data: values, result: row });
         } catch {}
         return row;
       }
@@ -4995,7 +8201,7 @@ var init_cache = __esm(async () => {
 });
 
 // src/actions/console.ts
-import process9 from "process";
+import process15 from "process";
 import { createInterface } from "readline";
 async function startConsole() {
   console.log("-- Query Builder Interactive Console");
@@ -5004,8 +8210,8 @@ async function startConsole() {
   console.log();
   const qb = createQueryBuilder();
   const rl = createInterface({
-    input: process9.stdin,
-    output: process9.stdout,
+    input: process15.stdin,
+    output: process15.stdout,
     prompt: "qb> "
   });
   let multilineBuffer = "";
@@ -5056,7 +8262,7 @@ Tips:
       if (cmd === ".exit" || cmd === ".quit") {
         console.log("Goodbye!");
         rl.close();
-        process9.exit(0);
+        process15.exit(0);
       } else if (cmd === ".help") {
         console.log(helpText);
       } else if (cmd === ".clear") {
@@ -5127,7 +8333,7 @@ Tips:
   rl.on("close", () => {
     console.log(`
 Goodbye!`);
-    process9.exit(0);
+    process15.exit(0);
   });
   rl.prompt();
 }
@@ -5139,7 +8345,7 @@ var init_console = __esm(async () => {
 });
 
 // src/actions/data.ts
-import { existsSync as existsSync4, readFileSync, writeFileSync as writeFileSync4 } from "fs";
+import { existsSync as existsSync6, readFileSync, writeFileSync as writeFileSync6 } from "fs";
 async function exportData(tableName, options = {}) {
   const format = options.format || "json";
   const output = options.output || `${tableName}.${format}`;
@@ -5160,11 +8366,11 @@ async function exportData(tableName, options = {}) {
     const data = await query.execute();
     console.log(`-- Retrieved ${data.length} rows`);
     if (format === "json") {
-      writeFileSync4(output, JSON.stringify(data, null, 2));
+      writeFileSync6(output, JSON.stringify(data, null, 2));
       console.log(`-- \u2713 Exported to JSON: ${output}`);
     } else if (format === "csv") {
       if (data.length === 0) {
-        writeFileSync4(output, "");
+        writeFileSync6(output, "");
         console.log(`-- \u2713 Exported to CSV: ${output} (empty)`);
         return;
       }
@@ -5185,7 +8391,7 @@ async function exportData(tableName, options = {}) {
         });
         csvLines.push(values.join(","));
       }
-      writeFileSync4(output, csvLines.join(`
+      writeFileSync6(output, csvLines.join(`
 `));
       console.log(`-- \u2713 Exported to CSV: ${output}`);
     } else if (format === "sql") {
@@ -5204,7 +8410,7 @@ async function exportData(tableName, options = {}) {
         });
         sqlLines.push(`INSERT INTO ${tableName} (${columns.join(", ")}) VALUES (${values.join(", ")});`);
       }
-      writeFileSync4(output, sqlLines.join(`
+      writeFileSync6(output, sqlLines.join(`
 `));
       console.log(`-- \u2713 Exported to SQL: ${output}`);
     }
@@ -5214,7 +8420,7 @@ async function exportData(tableName, options = {}) {
   }
 }
 async function importData(tableName, filePath, options = {}) {
-  if (!existsSync4(filePath)) {
+  if (!existsSync6(filePath)) {
     console.error(`-- File not found: ${filePath}`);
     throw new Error(`File not found: ${filePath}`);
   }
@@ -5283,7 +8489,7 @@ async function importData(tableName, filePath, options = {}) {
   }
 }
 async function dumpDatabase(options = {}) {
-  const dialect = config2.dialect || "postgres";
+  const dialect = config3.dialect || "postgres";
   const output = options.output || `dump-${Date.now()}.sql`;
   const tablesToDump = options.tables?.split(",").map((t) => t.trim());
   console.log("-- Dumping database");
@@ -5358,7 +8564,7 @@ async function dumpDatabase(options = {}) {
       }
       sqlLines.push("");
     }
-    writeFileSync4(output, sqlLines.join(`
+    writeFileSync6(output, sqlLines.join(`
 `));
     console.log();
     console.log(`-- \u2713 Database dump saved to: ${output}`);
@@ -5376,8 +8582,8 @@ var init_data = __esm(async () => {
 
 // src/actions/db-info.ts
 async function dbInfo() {
-  const dialect = config2.dialect || "postgres";
-  const database = config2.database?.database || "unknown";
+  const dialect = config3.dialect || "postgres";
+  const database = config3.database?.database || "unknown";
   console.log("-- Database Information");
   console.log(`-- Dialect: ${dialect}`);
   console.log(`-- Database: ${database}`);
@@ -5508,9 +8714,9 @@ var init_db_info = __esm(async () => {
 });
 
 // src/actions/db-optimize.ts
-import process10 from "process";
+import process16 from "process";
 async function dbOptimize(options = {}) {
-  const dialect = options.dialect || process10.env.DB_DIALECT || "postgres";
+  const dialect = options.dialect || process16.env.DB_DIALECT || "postgres";
   const aggressive = options.aggressive || false;
   if (options.verbose) {
     console.log(`Optimizing ${dialect} database${aggressive ? " (aggressive mode)" : ""}...`);
@@ -5550,7 +8756,7 @@ async function dbOptimize(options = {}) {
           await bunSql`ANALYZE TABLE ${bunSql(table)}`;
         }
       } else {
-        const dbName = process10.env.DB_NAME || "test";
+        const dbName = process16.env.DB_NAME || "test";
         const tables = await bunSql`
           SELECT table_name
           FROM information_schema.tables
@@ -5602,9 +8808,9 @@ var init_db_optimize = __esm(async () => {
 });
 
 // src/actions/db-wipe.ts
-import process11 from "process";
+import process17 from "process";
 async function dbWipe(options = {}) {
-  const dialect = options.dialect || process11.env.DB_DIALECT || "postgres";
+  const dialect = options.dialect || process17.env.DB_DIALECT || "postgres";
   if (options.verbose) {
     console.log(`Wiping all tables from ${dialect} database...`);
   }
@@ -5618,7 +8824,7 @@ async function dbWipe(options = {}) {
       `;
       tables = result.map((row) => row.tablename);
     } else if (dialect === "mysql") {
-      const dbName = process11.env.DB_NAME || "test";
+      const dbName = process17.env.DB_NAME || "test";
       const result = await bunSql`
         SELECT table_name
         FROM information_schema.tables
@@ -5703,7 +8909,7 @@ var init_file = __esm(async () => {
 
 // src/actions/inspect.ts
 async function inspectTable(tableName, options = {}) {
-  const dialect = config2.dialect || "postgres";
+  const dialect = config3.dialect || "postgres";
   const verbose = options.verbose ?? true;
   if (verbose) {
     console.log(`-- Inspecting table: ${tableName}`);
@@ -5912,31 +9118,31 @@ var init_introspect = __esm(async () => {
 });
 
 // src/actions/make-model.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync3, writeFileSync as writeFileSync6 } from "fs";
-import { dirname as dirname3, join as join3 } from "path";
-import process12 from "process";
+import { existsSync as existsSync9, mkdirSync as mkdirSync4, writeFileSync as writeFileSync8 } from "fs";
+import { dirname as dirname4, join as join4 } from "path";
+import process18 from "process";
 function findWorkspaceRoot(startPath) {
   let currentPath = startPath;
-  while (currentPath !== dirname3(currentPath)) {
-    if (existsSync6(join3(currentPath, "package.json"))) {
+  while (currentPath !== dirname4(currentPath)) {
+    if (existsSync9(join4(currentPath, "package.json"))) {
       return currentPath;
     }
-    currentPath = dirname3(currentPath);
+    currentPath = dirname4(currentPath);
   }
-  return process12.cwd();
+  return process18.cwd();
 }
 async function makeModel(name, options = {}) {
-  const workspaceRoot = findWorkspaceRoot(process12.cwd());
-  const modelsDir = options.dir || join3(workspaceRoot, "app/Models");
-  if (!existsSync6(modelsDir)) {
-    mkdirSync3(modelsDir, { recursive: true });
+  const workspaceRoot = findWorkspaceRoot(process18.cwd());
+  const modelsDir = options.dir || join4(workspaceRoot, "app/Models");
+  if (!existsSync9(modelsDir)) {
+    mkdirSync4(modelsDir, { recursive: true });
     console.log(`-- Created models directory: ${modelsDir}`);
   }
   const className = name.charAt(0).toUpperCase() + name.slice(1);
   const tableName = options.table || `${name.toLowerCase()}s`;
   const fileName = `${className}.ts`;
-  const filePath = join3(modelsDir, fileName);
-  if (existsSync6(filePath)) {
+  const filePath = join4(modelsDir, fileName);
+  if (existsSync9(filePath)) {
     console.error(`-- Model already exists: ${filePath}`);
     throw new Error(`Model already exists: ${filePath}`);
   }
@@ -5963,7 +9169,7 @@ ${timestampFields}
 
 export default model
 `;
-  writeFileSync6(filePath, template);
+  writeFileSync8(filePath, template);
   console.log(`-- \u2713 Created model: ${filePath}`);
   console.log(`-- Table: ${tableName}`);
 }
@@ -6441,42 +9647,42 @@ __export(exports_migrate, {
   deleteMigrationFiles: () => deleteMigrationFiles,
   copyModelsToGenerated: () => copyModelsToGenerated
 });
-import { copyFileSync, existsSync as existsSync7, mkdirSync as mkdirSync5, mkdtempSync, readdirSync as readdirSync3, readFileSync as readFileSync2, unlinkSync, writeFileSync as writeFileSync7 } from "fs";
+import { copyFileSync, existsSync as existsSync11, mkdirSync as mkdirSync6, mkdtempSync, readdirSync as readdirSync4, readFileSync as readFileSync2, unlinkSync, writeFileSync as writeFileSync9 } from "fs";
 import { tmpdir } from "os";
-import { join as join5 } from "path";
-import process13 from "process";
+import { join as join6 } from "path";
+import process19 from "process";
 function getWorkspaceRoot() {
-  return process13.cwd();
+  return process19.cwd();
 }
 function ensureSqlDirectory(workspaceRoot) {
   const sqlDir = getSqlDirectory(workspaceRoot);
-  if (!existsSync7(sqlDir)) {
-    mkdirSync5(sqlDir, { recursive: true });
+  if (!existsSync11(sqlDir)) {
+    mkdirSync6(sqlDir, { recursive: true });
     console.log(`-- Created SQL directory: ${sqlDir}`);
   }
   return sqlDir;
 }
 async function generateMigration(dir, opts = {}) {
   if (!dir) {
-    dir = join5(process13.cwd(), "app/Models");
+    dir = join6(process19.cwd(), "app/Models");
   }
-  const dialect = opts.dialect || config2.dialect || "postgres";
+  const dialect = opts.dialect || config3.dialect || "postgres";
   const workspaceRoot = getWorkspaceRoot();
   const models = await loadModels({ modelsDir: dir });
   const plan = buildMigrationPlan(models, { dialect });
-  const defaultStatePath = join5(dir, `.qb-migrations.${dialect}.json`);
+  const defaultStatePath = join6(dir, `.qb-migrations.${dialect}.json`);
   const statePath = String(opts.state || defaultStatePath);
   let previous;
   if (!opts.full) {
-    const generatedDir = join5(workspaceRoot, "generated");
-    if (existsSync7(generatedDir)) {
+    const generatedDir = join6(workspaceRoot, "generated");
+    if (existsSync11(generatedDir)) {
       try {
         const oldModels = await loadModels({ modelsDir: generatedDir });
         previous = buildMigrationPlan(oldModels, { dialect });
         console.log("-- Comparing with models from generated/ directory");
       } catch (err) {
         console.log("-- No previous models found in generated/ directory, checking state file", err);
-        if (existsSync7(statePath)) {
+        if (existsSync11(statePath)) {
           try {
             const raw = readFileSync2(statePath, "utf8");
             const parsed = JSON.parse(raw);
@@ -6484,7 +9690,7 @@ async function generateMigration(dir, opts = {}) {
           } catch {}
         }
       }
-    } else if (existsSync7(statePath)) {
+    } else if (existsSync11(statePath)) {
       try {
         const raw = readFileSync2(statePath, "utf8");
         const parsed = JSON.parse(raw);
@@ -6497,16 +9703,16 @@ async function generateMigration(dir, opts = {}) {
 `);
   const hasChanges = sqlStatements.some((stmt) => /\b(?:CREATE|ALTER)\b/i.test(stmt));
   if (opts.apply) {
-    const dirPath = mkdtempSync(join5(tmpdir(), "qb-migrate-"));
-    const filePath = join5(dirPath, "migration.sql");
+    const dirPath = mkdtempSync(join6(tmpdir(), "qb-migrate-"));
+    const filePath = join6(dirPath, "migration.sql");
     try {
       if (hasChanges) {
-        writeFileSync7(filePath, sql);
+        writeFileSync9(filePath, sql);
         console.log("-- Migration applied");
       } else {
         console.log("-- No changes; nothing to apply");
       }
-      writeFileSync7(statePath, JSON.stringify({ plan, hash: hashMigrationPlan(plan), updatedAt: new Date().toISOString() }, null, 2));
+      writeFileSync9(statePath, JSON.stringify({ plan, hash: hashMigrationPlan(plan), updatedAt: new Date().toISOString() }, null, 2));
     } catch (err) {
       console.error("-- Migration failed:", err);
       throw err;
@@ -6517,12 +9723,12 @@ async function generateMigration(dir, opts = {}) {
 }
 async function executeMigration(dir) {
   if (!dir) {
-    dir = join5(process13.cwd(), "app/Models");
+    dir = join6(process19.cwd(), "app/Models");
   }
   const workspaceRoot = getWorkspaceRoot();
   const sqlDir = ensureSqlDirectory(workspaceRoot);
-  const dialect = config2.dialect || "postgres";
-  const files = readdirSync3(sqlDir);
+  const dialect = config3.dialect || "postgres";
+  const files = readdirSync4(sqlDir);
   const scriptFiles = files.filter((file2) => file2.endsWith(".sql")).sort();
   if (scriptFiles.length === 0) {
     console.log("-- No migration files found to execute");
@@ -6549,7 +9755,7 @@ async function executeMigration(dir) {
     }
     console.log(`-- Executing ${totalPending} migrations (${permanentMigrations.length} permanent, ${transientMigrations.length} transient)`);
     for (const file2 of permanentMigrations) {
-      const filePath = join5(sqlDir, file2);
+      const filePath = join6(sqlDir, file2);
       console.log(`-- Executing: ${file2}`);
       try {
         await qb.file(filePath);
@@ -6561,7 +9767,7 @@ async function executeMigration(dir) {
       }
     }
     for (const file2 of transientMigrations) {
-      const filePath = join5(sqlDir, file2);
+      const filePath = join6(sqlDir, file2);
       console.log(`-- Executing: ${file2} (transient)`);
       try {
         await qb.file(filePath);
@@ -6582,7 +9788,7 @@ async function executeMigration(dir) {
 }
 async function resetDatabase(dir, opts = {}) {
   if (!dir) {
-    dir = join5(process13.cwd(), "app/Models");
+    dir = join6(process19.cwd(), "app/Models");
   }
   const dialect = opts.dialect || "postgres";
   const driver = getDialectDriver(dialect);
@@ -6669,24 +9875,24 @@ async function resetDatabase(dir, opts = {}) {
 }
 async function deleteMigrationFiles(dir, workspaceRoot, opts = {}) {
   if (!dir) {
-    dir = join5(process13.cwd(), "app/Models");
+    dir = join6(process19.cwd(), "app/Models");
   }
   if (!workspaceRoot) {
     workspaceRoot = getWorkspaceRoot();
   }
   const dialect = String(opts.dialect || "postgres");
-  const defaultStatePath = join5(dir, `.qb-migrations.${dialect}.json`);
+  const defaultStatePath = join6(dir, `.qb-migrations.${dialect}.json`);
   const statePath = String(opts.state || defaultStatePath);
-  if (existsSync7(statePath)) {
+  if (existsSync11(statePath)) {
     unlinkSync(statePath);
     console.log(`-- Removed migration state file: ${statePath}`);
   }
   const sqlDir = getSqlDirectory(workspaceRoot);
-  if (existsSync7(sqlDir)) {
-    const sqlFiles = readdirSync3(sqlDir);
+  if (existsSync11(sqlDir)) {
+    const sqlFiles = readdirSync4(sqlDir);
     const migrationFiles = sqlFiles.filter((file2) => file2.endsWith(".sql"));
     for (const file2 of migrationFiles) {
-      const filePath = join5(sqlDir, file2);
+      const filePath = join6(sqlDir, file2);
       unlinkSync(filePath);
       console.log(`-- Removed migration file: ${file2}`);
     }
@@ -6695,26 +9901,26 @@ async function deleteMigrationFiles(dir, workspaceRoot, opts = {}) {
 }
 async function copyModelsToGenerated(dir, workspaceRoot) {
   if (!dir) {
-    dir = join5(process13.cwd(), "app/Models");
+    dir = join6(process19.cwd(), "app/Models");
   }
   if (!workspaceRoot) {
     workspaceRoot = getWorkspaceRoot();
   }
   try {
-    const generatedDir = join5(workspaceRoot, "generated");
-    if (!existsSync7(generatedDir)) {
-      mkdirSync5(generatedDir, { recursive: true });
+    const generatedDir = join6(workspaceRoot, "generated");
+    if (!existsSync11(generatedDir)) {
+      mkdirSync6(generatedDir, { recursive: true });
       console.log("-- Created generated directory");
     }
-    const files = readdirSync3(dir);
+    const files = readdirSync4(dir);
     const modelFiles = files.filter((file2) => file2.endsWith(".ts") || file2.endsWith(".js"));
     if (modelFiles.length === 0) {
       console.log("-- No model files found to copy");
       return;
     }
     for (const file2 of modelFiles) {
-      const sourcePath = join5(dir, file2);
-      const destPath = join5(generatedDir, file2);
+      const sourcePath = join6(dir, file2);
+      const destPath = join6(generatedDir, file2);
       copyFileSync(sourcePath, destPath);
     }
     console.log("-- Model files copied successfully");
@@ -6727,7 +9933,7 @@ function getSqlDirectory(workspaceRoot) {
   if (!workspaceRoot) {
     workspaceRoot = getWorkspaceRoot();
   }
-  return join5(workspaceRoot, "database", "sql");
+  return join6(workspaceRoot, "database", "sql");
 }
 async function createMigrationsTable(qb, dialect) {
   const driver = getDialectDriver(dialect);
@@ -6779,24 +9985,24 @@ var init_migrate_generate = __esm(async () => {
 });
 
 // src/actions/migrate-rollback.ts
-import { existsSync as existsSync8, unlinkSync as unlinkSync2 } from "fs";
-import { dirname as dirname5, join as join6 } from "path";
-import process14 from "process";
+import { existsSync as existsSync12, unlinkSync as unlinkSync2 } from "fs";
+import { dirname as dirname6, join as join7 } from "path";
+import process20 from "process";
 function findWorkspaceRoot2(startPath) {
   let currentPath = startPath;
-  while (currentPath !== dirname5(currentPath)) {
-    if (existsSync8(join6(currentPath, "package.json"))) {
+  while (currentPath !== dirname6(currentPath)) {
+    if (existsSync12(join7(currentPath, "package.json"))) {
       return currentPath;
     }
-    currentPath = dirname5(currentPath);
+    currentPath = dirname6(currentPath);
   }
-  return process14.cwd();
+  return process20.cwd();
 }
 function getSqlDirectory2(workspaceRoot) {
   if (!workspaceRoot) {
-    workspaceRoot = findWorkspaceRoot2(process14.cwd());
+    workspaceRoot = findWorkspaceRoot2(process20.cwd());
   }
-  return join6(workspaceRoot, "sql");
+  return join7(workspaceRoot, "sql");
 }
 async function migrateRollback(options = {}) {
   const steps = options.steps || 1;
@@ -6835,8 +10041,8 @@ async function migrateRollback(options = {}) {
         await qb.unsafe(deleteSql, [migration.migration]);
         console.log(`-- \u2713 Removed migration record: ${migration.migration}`);
         const sqlDir = getSqlDirectory2();
-        const filePath = join6(sqlDir, migration.migration);
-        if (existsSync8(filePath)) {
+        const filePath = join7(sqlDir, migration.migration);
+        if (existsSync12(filePath)) {
           unlinkSync2(filePath);
           console.log(`-- \uD83D\uDDD1\uFE0F  Deleted migration file: ${migration.migration}`);
         }
@@ -6861,38 +10067,38 @@ var init_migrate_rollback = __esm(async () => {
 });
 
 // src/actions/migrate-status.ts
-import { existsSync as existsSync9, readdirSync as readdirSync5 } from "fs";
-import { dirname as dirname6, join as join7 } from "path";
-import process15 from "process";
+import { existsSync as existsSync13, readdirSync as readdirSync6 } from "fs";
+import { dirname as dirname7, join as join8 } from "path";
+import process21 from "process";
 function findWorkspaceRoot3(startPath) {
   let currentPath = startPath;
-  while (currentPath !== dirname6(currentPath)) {
-    if (existsSync9(join7(currentPath, "package.json"))) {
+  while (currentPath !== dirname7(currentPath)) {
+    if (existsSync13(join8(currentPath, "package.json"))) {
       return currentPath;
     }
-    currentPath = dirname6(currentPath);
+    currentPath = dirname7(currentPath);
   }
-  return process15.cwd();
+  return process21.cwd();
 }
 function getSqlDirectory3(workspaceRoot) {
   if (!workspaceRoot) {
-    workspaceRoot = findWorkspaceRoot3(process15.cwd());
+    workspaceRoot = findWorkspaceRoot3(process21.cwd());
   }
-  return join7(workspaceRoot, "sql");
+  return join8(workspaceRoot, "sql");
 }
 async function migrateStatus() {
-  const dialect = config2.dialect || "postgres";
+  const dialect = config3.dialect || "postgres";
   const driver = getDialectDriver(dialect);
   const sqlDir = getSqlDirectory3();
   console.log("-- Migration Status");
   console.log(`-- Dialect: ${dialect}`);
   console.log(`-- SQL directory: ${sqlDir}`);
   console.log();
-  if (!existsSync9(sqlDir)) {
+  if (!existsSync13(sqlDir)) {
     console.log("-- No SQL directory found. No migrations have been created yet.");
     return [];
   }
-  const files = readdirSync5(sqlDir);
+  const files = readdirSync6(sqlDir);
   const migrationFiles = files.filter((file2) => file2.endsWith(".sql")).sort();
   if (migrationFiles.length === 0) {
     console.log("-- No migration files found");
@@ -6970,13 +10176,13 @@ var init_migrate_status = __esm(async () => {
 });
 
 // src/actions/model-show.ts
-import { readdirSync as readdirSync6 } from "fs";
-import { extname, join as join8 } from "path";
-import process16 from "process";
+import { readdirSync as readdirSync7 } from "fs";
+import { extname, join as join9 } from "path";
+import process22 from "process";
 async function modelShow(modelName, options = {}) {
-  const dir = options.dir || join8(process16.cwd(), "app/Models");
+  const dir = options.dir || join9(process22.cwd(), "app/Models");
   try {
-    const files = readdirSync6(dir);
+    const files = readdirSync7(dir);
     const modelFile = files.find((f) => {
       const name = f.replace(extname(f), "");
       return name.toLowerCase() === modelName.toLowerCase();
@@ -6986,7 +10192,7 @@ async function modelShow(modelName, options = {}) {
       console.log(`Available models: ${files.filter((f) => [".ts", ".js"].includes(extname(f))).map((f) => f.replace(extname(f), "")).join(", ")}`);
       return;
     }
-    const modelPath = join8(dir, modelFile);
+    const modelPath = join9(dir, modelFile);
     const module = await import(modelPath);
     const model = module.default || module[Object.keys(module)[0]];
     if (!model || !model.name) {
@@ -7093,17 +10299,17 @@ var init_ping = __esm(async () => {
 });
 
 // src/actions/query-explain-all.ts
-import { readdirSync as readdirSync7, readFileSync as readFileSync3, statSync } from "fs";
-import { extname as extname2, join as join9 } from "path";
+import { readdirSync as readdirSync8, readFileSync as readFileSync3, statSync as statSync2 } from "fs";
+import { extname as extname2, join as join10 } from "path";
 async function queryExplainAll(path, options = {}) {
   const results = [];
   try {
-    const stat2 = statSync(path);
+    const stat3 = statSync2(path);
     let files = [];
-    if (stat2.isDirectory()) {
-      const allFiles = readdirSync7(path);
-      files = allFiles.filter((f) => extname2(f) === ".sql").map((f) => join9(path, f));
-    } else if (stat2.isFile() && extname2(path) === ".sql") {
+    if (stat3.isDirectory()) {
+      const allFiles = readdirSync8(path);
+      files = allFiles.filter((f) => extname2(f) === ".sql").map((f) => join10(path, f));
+    } else if (stat3.isFile() && extname2(path) === ".sql") {
       files = [path];
     } else {
       console.error("Path must be a .sql file or directory containing .sql files");
@@ -7186,11 +10392,11 @@ var init_query_explain_all = __esm(async () => {
 });
 
 // src/actions/relation-diagram.ts
-import { writeFileSync as writeFileSync8 } from "fs";
-import { join as join10 } from "path";
-import process17 from "process";
+import { writeFileSync as writeFileSync10 } from "fs";
+import { join as join11 } from "path";
+import process23 from "process";
 async function relationDiagram(options = {}) {
-  const dir = options.dir || join10(process17.cwd(), "app/Models");
+  const dir = options.dir || join11(process23.cwd(), "app/Models");
   const format = options.format || "mermaid";
   try {
     const models = await loadModels({ modelsDir: dir });
@@ -7208,7 +10414,7 @@ async function relationDiagram(options = {}) {
       return "";
     }
     if (options.output) {
-      writeFileSync8(options.output, diagram, "utf8");
+      writeFileSync10(options.output, diagram, "utf8");
       console.log(`\u2713 Diagram written to: ${options.output}`);
     } else {
       console.log(diagram);
@@ -7310,29 +10516,29 @@ var init_relation_diagram = __esm(async () => {
 });
 
 // src/actions/seed.ts
-import { existsSync as existsSync10, mkdirSync as mkdirSync6, readdirSync as readdirSync8, writeFileSync as writeFileSync9 } from "fs";
-import { dirname as dirname7, join as join11 } from "path";
-import process18 from "process";
+import { existsSync as existsSync14, mkdirSync as mkdirSync7, readdirSync as readdirSync9, writeFileSync as writeFileSync11 } from "fs";
+import { dirname as dirname8, join as join12 } from "path";
+import process24 from "process";
 function findWorkspaceRoot4(startPath) {
   let currentPath = startPath;
-  while (currentPath !== dirname7(currentPath)) {
-    if (existsSync10(join11(currentPath, "package.json"))) {
+  while (currentPath !== dirname8(currentPath)) {
+    if (existsSync14(join12(currentPath, "package.json"))) {
       return currentPath;
     }
-    currentPath = dirname7(currentPath);
+    currentPath = dirname8(currentPath);
   }
-  return process18.cwd();
+  return process24.cwd();
 }
 async function loadSeeders(seedersDir) {
-  if (!existsSync10(seedersDir)) {
+  if (!existsSync14(seedersDir)) {
     console.log(`-- Seeders directory not found: ${seedersDir}`);
     return [];
   }
-  const files = readdirSync8(seedersDir);
+  const files = readdirSync9(seedersDir);
   const seederFiles = files.filter((file2) => (file2.endsWith(".ts") || file2.endsWith(".js")) && file2 !== "index.ts" && file2 !== "index.js");
   const seeders = [];
   for (const file2 of seederFiles) {
-    const filePath = join11(seedersDir, file2);
+    const filePath = join12(seedersDir, file2);
     try {
       const module = await import(filePath);
       const SeederClass = module.default || module[Object.keys(module)[0]];
@@ -7352,10 +10558,10 @@ async function loadSeeders(seedersDir) {
   seeders.sort((a, b) => a.instance.order - b.instance.order);
   return seeders;
 }
-async function runSeeders(config3 = {}) {
-  const workspaceRoot = findWorkspaceRoot4(process18.cwd());
-  const seedersDir = config3.seedersDir || join11(workspaceRoot, "database/seeders");
-  const verbose = config3.verbose ?? true;
+async function runSeeders(config4 = {}) {
+  const workspaceRoot = findWorkspaceRoot4(process24.cwd());
+  const seedersDir = config4.seedersDir || join12(workspaceRoot, "database/seeders");
+  const verbose = config4.verbose ?? true;
   if (verbose) {
     console.log("-- Running seeders...");
     console.log(`-- Seeders directory: ${seedersDir}`);
@@ -7388,8 +10594,8 @@ async function runSeeders(config3 = {}) {
   }
 }
 async function runSeeder(className, options = {}) {
-  const workspaceRoot = findWorkspaceRoot4(process18.cwd());
-  const seedersDir = join11(workspaceRoot, "database/seeders");
+  const workspaceRoot = findWorkspaceRoot4(process24.cwd());
+  const seedersDir = join12(workspaceRoot, "database/seeders");
   const verbose = options.verbose ?? true;
   if (verbose) {
     console.log(`-- Running seeder: ${className}`);
@@ -7412,17 +10618,17 @@ async function runSeeder(className, options = {}) {
   }
 }
 async function makeSeeder(name) {
-  const workspaceRoot = findWorkspaceRoot4(process18.cwd());
-  const seedersDir = join11(workspaceRoot, "database/seeders");
-  if (!existsSync10(seedersDir)) {
-    mkdirSync6(seedersDir, { recursive: true });
+  const workspaceRoot = findWorkspaceRoot4(process24.cwd());
+  const seedersDir = join12(workspaceRoot, "database/seeders");
+  if (!existsSync14(seedersDir)) {
+    mkdirSync7(seedersDir, { recursive: true });
     console.log(`-- Created seeders directory: ${seedersDir}`);
   }
   const baseName = name.replace(/Seeder$/i, "");
   const className = `${baseName}Seeder`;
   const fileName = `${className}.ts`;
-  const filePath = join11(seedersDir, fileName);
-  if (existsSync10(filePath)) {
+  const filePath = join12(seedersDir, fileName);
+  if (existsSync14(filePath)) {
     console.error(`-- Seeder already exists: ${filePath}`);
     throw new Error(`Seeder already exists: ${filePath}`);
   }
@@ -7472,13 +10678,13 @@ export default class ${className} extends Seeder {
   }
 }
 `;
-  writeFileSync9(filePath, template);
+  writeFileSync11(filePath, template);
   console.log(`-- \u2713 Created seeder: ${filePath}`);
 }
 async function freshDatabase(options = {}) {
-  const workspaceRoot = findWorkspaceRoot4(process18.cwd());
-  const modelsDir = options.modelsDir || join11(workspaceRoot, "app/Models");
-  const seedersDir = options.seedersDir || join11(workspaceRoot, "database/seeders");
+  const workspaceRoot = findWorkspaceRoot4(process24.cwd());
+  const modelsDir = options.modelsDir || join12(workspaceRoot, "app/Models");
+  const seedersDir = options.seedersDir || join12(workspaceRoot, "database/seeders");
   const verbose = options.verbose ?? true;
   try {
     const { resetDatabase: resetDatabase2, generateMigration: generateMigration2, executeMigration: executeMigration2 } = await init_migrate().then(() => exports_migrate);
@@ -7511,8 +10717,8 @@ var init_seed = __esm(async () => {
 function sql(dir, table, opts = {}) {
   const models = loadModels({ modelsDir: dir });
   const dbSchema = buildDatabaseSchema(models);
-  if (config2.debug)
-    config2.debug.captureText = true;
+  if (config3.debug)
+    config3.debug.captureText = true;
   const qb = createQueryBuilder({ schema: dbSchema });
   const s = qb.selectFrom(table).limit(Number(opts.limit || 10)).toText?.() ?? "";
   console.log(s || "[query]");
@@ -7538,24 +10744,24 @@ var init_unsafe = __esm(async () => {
 });
 
 // src/actions/validate.ts
-import { existsSync as existsSync11 } from "fs";
-import { dirname as dirname8, join as join12 } from "path";
-import process19 from "process";
+import { existsSync as existsSync15 } from "fs";
+import { dirname as dirname9, join as join13 } from "path";
+import process25 from "process";
 function findWorkspaceRoot5(startPath) {
   let currentPath = startPath;
-  while (currentPath !== dirname8(currentPath)) {
-    if (existsSync11(join12(currentPath, "package.json"))) {
+  while (currentPath !== dirname9(currentPath)) {
+    if (existsSync15(join13(currentPath, "package.json"))) {
       return currentPath;
     }
-    currentPath = dirname8(currentPath);
+    currentPath = dirname9(currentPath);
   }
-  return process19.cwd();
+  return process25.cwd();
 }
 async function validateSchema(dir) {
   if (!dir) {
-    dir = join12(findWorkspaceRoot5(process19.cwd()), "app/Models");
+    dir = join13(findWorkspaceRoot5(process25.cwd()), "app/Models");
   }
-  const dialect = config2.dialect || "postgres";
+  const dialect = config3.dialect || "postgres";
   console.log("-- Validating Schema");
   console.log(`-- Models directory: ${dir}`);
   console.log(`-- Dialect: ${dialect}`);
@@ -7811,17 +11017,17 @@ function buildDatabaseSchema(models) {
 }
 
 // src/loader.ts
-import { readdirSync as readdirSync9, statSync as statSync2 } from "fs";
+import { readdirSync as readdirSync10, statSync as statSync3 } from "fs";
 import { basename, extname as extname3 } from "path";
-import process20 from "process";
+import process26 from "process";
 async function loadModels(options) {
-  const cwd = options.cwd ?? process20.cwd();
+  const cwd = options.cwd ?? process26.cwd();
   const dir = options.modelsDir.startsWith("/") ? options.modelsDir : `${cwd}/${options.modelsDir}`;
   const result = {};
-  const entries = readdirSync9(dir);
+  const entries = readdirSync10(dir);
   for (const entry of entries) {
     const full = `${dir}/${entry}`;
-    const st = statSync2(full);
+    const st = statSync3(full);
     if (st.isDirectory())
       continue;
     const ext = extname3(full);
@@ -7895,24 +11101,24 @@ function buildSchemaMeta(models) {
 }
 
 // src/migrations.ts
-import { existsSync as existsSync12, mkdirSync as mkdirSync7, writeFileSync as writeFileSync10 } from "fs";
-import { dirname as dirname9, join as join13 } from "path";
-import process21 from "process";
+import { existsSync as existsSync16, mkdirSync as mkdirSync8, writeFileSync as writeFileSync12 } from "fs";
+import { dirname as dirname10, join as join14 } from "path";
+import process27 from "process";
 function findWorkspaceRoot6(startPath) {
   let currentPath = startPath;
-  while (currentPath !== dirname9(currentPath)) {
-    if (existsSync12(join13(currentPath, "package.json"))) {
+  while (currentPath !== dirname10(currentPath)) {
+    if (existsSync16(join14(currentPath, "package.json"))) {
       return currentPath;
     }
-    currentPath = dirname9(currentPath);
+    currentPath = dirname10(currentPath);
   }
-  return process21.cwd();
+  return process27.cwd();
 }
 function ensureSqlDirectory2() {
-  const workspaceRoot = findWorkspaceRoot6(process21.cwd());
-  const sqlDir = join13(workspaceRoot, "database", "sql");
-  if (!existsSync12(sqlDir)) {
-    mkdirSync7(sqlDir, { recursive: true });
+  const workspaceRoot = findWorkspaceRoot6(process27.cwd());
+  const sqlDir = join14(workspaceRoot, "database", "sql");
+  if (!existsSync16(sqlDir)) {
+    mkdirSync8(sqlDir, { recursive: true });
     console.log(`-- Created SQL directory: ${sqlDir}`);
   }
   return sqlDir;
@@ -7925,8 +11131,8 @@ function createMigrationFile(statement, fileName) {
   const timestamp = baseTimestamp + migrationCounter;
   migrationCounter++;
   const fullFileName = `${timestamp}-${fileName}.sql`;
-  const filePath = join13(sqlDir, fullFileName);
-  writeFileSync10(filePath, statement);
+  const filePath = join14(sqlDir, fullFileName);
+  writeFileSync12(filePath, statement);
   console.log(`-- Migration file created: ${fullFileName}`);
   migrationsCreatedCount++;
   return true;
@@ -8487,13 +11693,13 @@ export {
   defineSeeder,
   defineModels,
   defineModel,
-  defaultConfig2 as defaultConfig,
+  defaultConfig3 as defaultConfig,
   dbWipe,
   dbStats,
   dbOptimize,
   dbInfo,
   createQueryBuilder,
-  config2 as config,
+  config3 as config,
   clearQueryCache,
   checkSchema,
   cacheStats,