better-dx 0.2.0 → 0.2.2

package/dist/index.js

@@ -18,18 +18,25 @@ var __toESM = (mod, isNodeMode, target) => {
 var __require = import.meta.require;
 
 // 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";
@@ -37,6 +44,260 @@ 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);
+  }
+}
+var globalCache = new ConfigCache;
+var globalPerformanceMonitor = new PerformanceMonitor;
 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;
@@ -163,7 +424,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);
@@ -203,7 +464,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)) {
@@ -504,7 +765,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);
@@ -840,7 +1101,7 @@ class Logger {
       }
       return Promise.resolve();
     }));
-    if (existsSync2(this.currentLogFile)) {
+    if (existsSync22(this.currentLogFile)) {
       try {
         const fd = openSync(this.currentLogFile, "r+");
         fsyncSync(fd);
@@ -1160,7 +1421,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" });
   }
@@ -1852,17 +2113,2971 @@ async function loadConfig3({
 }
 var defaultConfigDir2 = resolve3(process6.cwd(), "config");
 var defaultGeneratedDir2 = resolve3(process6.cwd(), "src/generated");
-
-// src/config.ts
+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;
+}
+var defaultLogDirectory2 = process7.env.CLARITY_LOG_DIR || join3(getProjectRoot2(), "logs");
 var 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
+};
+async function loadConfig4() {
+  try {
+    const loadedConfig = await loadConfig3({
+      name: "clarity",
+      alias: "logging",
+      defaultConfig: defaultConfig2,
+      cwd: process7.cwd()
+    });
+    return { ...defaultConfig2, ...loadedConfig || {} };
+  } catch {
+    return defaultConfig2;
+  }
+}
+var config2 = await loadConfig4();
+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
+    };
+  }
+}
+var 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"
+};
+var styles2 = terminalStyles2;
+var red2 = terminalStyles2.red;
+var green2 = terminalStyles2.green;
+var yellow2 = terminalStyles2.yellow;
+var blue2 = terminalStyles2.blue;
+var magenta2 = terminalStyles2.magenta;
+var cyan2 = terminalStyles2.cyan;
+var white2 = terminalStyles2.white;
+var gray2 = terminalStyles2.gray;
+var bgRed2 = terminalStyles2.bgRed;
+var bgYellow2 = terminalStyles2.bgYellow;
+var bgGray = terminalStyles2.bgGray;
+var bold2 = terminalStyles2.bold;
+var dim2 = terminalStyles2.dim;
+var italic2 = terminalStyles2.italic;
+var underline2 = terminalStyles2.underline;
+var strikethrough = terminalStyles2.strikethrough;
+var reset2 = terminalStyles2.reset;
+var defaultFingersCrossedConfig2 = {
+  activationLevel: "error",
+  bufferSize: 50,
+  flushOnDeactivation: true,
+  stopBuffering: false
+};
+var levelIcons2 = {
+  debug: "\uD83D\uDD0D",
+  info: blue2("\u2139"),
+  success: green2("\u2713"),
+  warning: bgYellow2(white2(bold2(" WARN "))),
+  error: bgRed2(white2(bold2(" ERROR ")))
+};
+
+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);
+    }
+  }
+}
+var logger2 = new Logger2("stacks");
+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}`;
+  }
+}
+
+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
+    });
+  }
+}
+
+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;
+  }
+}
+
+class ConfigValidationError extends BunfigError {
+  code = "CONFIG_VALIDATION_ERROR";
+  constructor(configPath, validationErrors, configName) {
+    super(`Configuration validation failed for "${configPath}"`, {
+      configPath,
+      configName,
+      validationErrors,
+      errorCount: validationErrors.length
+    });
+  }
+}
+
+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;
+  }
+}
+
+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
+    });
+  }
+}
+
+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;
+  }
+}
+
+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;
+  }
+}
+
+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
+    });
+  }
+}
+
+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
+    });
+  }
+}
+
+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;
+  }
+}
+var 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);
+  }
+};
+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;
+  }
+}
+var URL_PATTERN = /^https?:\/\//;
+
+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: URL_PATTERN },
+        { path: "timeout", type: "number", min: 0 },
+        { path: "retries", type: "number", min: 0, max: 10 }
+      ]
+    };
+  }
+}
+var log2 = new Logger2("bunfig", {
+  showTags: true
+});
+
+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`]
+    };
+  }
+  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;
+  }
+  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;
+  }
+  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];
+        usedName = alias;
+      }
+      if (pkgConfig && typeof pkgConfig === "object" && !Array.isArray(pkgConfig)) {
+        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);
+  }
+}
+var globalConfigLoader = new ConfigLoader;
+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) {
+    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;
+  }
+}
+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 processConfigLevel(config4);
+}
+var defaultConfigDir3 = resolve7(process12.cwd(), "config");
+var defaultGeneratedDir3 = resolve7(process12.cwd(), "src/generated");
+
+// src/config.ts
+var defaultConfig3 = {
   verbose: true
 };
-var config2 = await loadConfig3({
+var config3 = await loadConfig5({
   name: "development",
   alias: "dx",
-  defaultConfig: defaultConfig2
+  defaultConfig: defaultConfig3
 });
 export {
-  defaultConfig2 as defaultConfig,
-  config2 as config
+  defaultConfig3 as defaultConfig,
+  config3 as config
 };