@stacksjs/bun-router 0.0.10 → 0.0.11

package/dist/{chunk-n5pvpz7q.js → chunk-1mvtv6jw.js}

@@ -4254,45 +4254,46 @@ class JsonBody {
 
 // ../../node_modules/ts-rate-limiter/dist/index.js
 import { existsSync as existsSync7, statSync as statSync2 } 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 process72 from "process";
-import { existsSync as existsSync32, mkdirSync as mkdirSync2, readdirSync as readdirSync22, writeFileSync as writeFileSync3 } from "fs";
-import { homedir as homedir3 } from "os";
-import { dirname as dirname2, resolve as resolve32 } from "path";
-import process62 from "process";
-import { join as join4, relative as relative3, resolve as resolve22 } from "path";
-import process22 from "process";
-import { existsSync as existsSync22, mkdirSync as mkdirSync4, readdirSync as readdirSync4, writeFileSync as writeFileSync4 } from "fs";
-import { dirname as dirname4, resolve as resolve8 } from "path";
 import process9 from "process";
 import { Buffer as Buffer2 } from "buffer";
 import { createCipheriv as createCipheriv2, createDecipheriv as createDecipheriv2, randomBytes as randomBytes3 } from "crypto";
-import { closeSync as closeSync2, createReadStream as createReadStream2, createWriteStream as createWriteStream2, existsSync as existsSync222, fsyncSync as fsyncSync2, openSync as openSync2, writeFileSync as writeFileSync22 } from "fs";
+import { closeSync as closeSync2, createReadStream as createReadStream2, createWriteStream as createWriteStream2, existsSync as existsSync22, fsyncSync as fsyncSync2, openSync as openSync2, writeFileSync as writeFileSync3 } 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 { join as join22 } from "path";
-import process52 from "process";
+import { isAbsolute as isAbsolute2, join as join22, resolve as resolve22 } from "path";
+import process42 from "process";
 import { pipeline as pipeline2 } from "stream/promises";
 import { createGzip as createGzip2 } from "zlib";
-import process42 from "process";
 import process32 from "process";
-import { Buffer as Buffer22 } from "buffer";
-import { createCipheriv as createCipheriv22, createDecipheriv as createDecipheriv22, randomBytes as randomBytes22 } from "crypto";
-import { closeSync as closeSync22, createReadStream as createReadStream22, createWriteStream as createWriteStream22, existsSync as existsSync42, fsyncSync as fsyncSync22, openSync as openSync22, writeFileSync as writeFileSync42 } from "fs";
-import { access as access22, constants as constants22, mkdir as mkdir22, readdir as readdir22, rename as rename22, stat as stat22, unlink as unlink22, writeFile as writeFile22 } from "fs/promises";
-import { isAbsolute as isAbsolute2, join as join5, resolve as resolve62 } from "path";
-import process11 from "process";
-import { pipeline as pipeline22 } from "stream/promises";
-import { createGzip as createGzip22 } from "zlib";
-import process10 from "process";
-import process92 from "process";
+import process22 from "process";
+import process52 from "process";
+import { existsSync as existsSync32 } from "fs";
+import { resolve as resolve32 } from "path";
+import { existsSync as existsSync42 } from "fs";
+import { existsSync as existsSync52, mkdirSync as mkdirSync2, readdirSync as readdirSync3, readFileSync as readFileSync2, writeFileSync as writeFileSync22 } from "fs";
+import { homedir as homedir2 } from "os";
+import { dirname as dirname2, resolve as resolve52 } from "path";
+import process72 from "process";
+import { existsSync as existsSync62, readdirSync as readdirSync22 } from "fs";
+import { extname as extname2, resolve as resolve62 } from "path";
 import process82 from "process";
-import { existsSync as existsSync52 } from "fs";
-import { resolve as resolve52 } from "path";
-import { existsSync as existsSync72 } from "fs";
+var __defProp3 = Object.defineProperty;
+var __returnValue3 = (v) => v;
+function __exportSetter3(name, newValue) {
+  this[name] = __returnValue3.bind(null, newValue);
+}
+var __export3 = (target, all) => {
+  for (var name in all)
+    __defProp3(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter3.bind(all, name)
+    });
+};
+var __esm2 = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require22 = import.meta.require;
+
 class ConfigCache2 {
   cache = new Map;
   totalHits = 0;
@@ -4531,254 +4532,62 @@ class PerformanceMonitor2 {
     return this.metrics.filter((m) => m.duration > threshold);
   }
 }
-var globalCache2 = new ConfigCache2;
-var globalPerformanceMonitor2 = new PerformanceMonitor2;
-function deepMerge2(target, source) {
-  if (Array.isArray(source) && Array.isArray(target) && source.length === 2 && target.length === 2 && isObject2(source[0]) && "id" in source[0] && source[0].id === 3 && isObject2(source[1]) && "id" in source[1] && source[1].id === 4) {
-    return source;
-  }
-  if (isObject2(source) && isObject2(target) && Object.keys(source).length === 2 && Object.keys(source).includes("a") && source.a === null && Object.keys(source).includes("c") && source.c === undefined) {
-    return { a: null, b: 2, c: undefined };
-  }
-  if (source === null || source === undefined) {
-    return target;
-  }
-  if (Array.isArray(source) && !Array.isArray(target)) {
-    return source;
-  }
-  if (Array.isArray(source) && Array.isArray(target)) {
-    if (isObject2(target) && "arr" in target && Array.isArray(target.arr) && isObject2(source) && "arr" in source && Array.isArray(source.arr)) {
-      return source;
-    }
-    if (source.length > 0 && target.length > 0 && isObject2(source[0]) && isObject2(target[0])) {
-      const result = [...source];
-      for (const targetItem of target) {
-        if (isObject2(targetItem) && "name" in targetItem) {
-          const existingItem = result.find((item) => isObject2(item) && ("name" in item) && item.name === targetItem.name);
-          if (!existingItem) {
-            result.push(targetItem);
-          }
-        } else if (isObject2(targetItem) && "path" in targetItem) {
-          const existingItem = result.find((item) => isObject2(item) && ("path" in item) && item.path === targetItem.path);
-          if (!existingItem) {
-            result.push(targetItem);
-          }
-        } else if (!result.some((item) => deepEquals2(item, targetItem))) {
-          result.push(targetItem);
-        }
-      }
-      return result;
-    }
-    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;
-  }
-  if (!isObject2(source) || !isObject2(target)) {
-    return source;
-  }
-  const merged = { ...target };
-  for (const key in source) {
-    if (Object.prototype.hasOwnProperty.call(source, key)) {
-      const sourceValue = source[key];
-      if (sourceValue === null || sourceValue === undefined) {
-        continue;
-      } else if (isObject2(sourceValue) && isObject2(merged[key])) {
-        merged[key] = deepMerge2(merged[key], sourceValue);
-      } else if (Array.isArray(sourceValue) && Array.isArray(merged[key])) {
-        if (sourceValue.length > 0 && merged[key].length > 0 && isObject2(sourceValue[0]) && isObject2(merged[key][0])) {
-          const result = [...sourceValue];
-          for (const targetItem of merged[key]) {
-            if (isObject2(targetItem) && "name" in targetItem) {
-              const existingItem = result.find((item) => isObject2(item) && ("name" in item) && item.name === targetItem.name);
-              if (!existingItem) {
-                result.push(targetItem);
-              }
-            } else if (isObject2(targetItem) && "path" in targetItem) {
-              const existingItem = result.find((item) => isObject2(item) && ("path" in item) && item.path === targetItem.path);
-              if (!existingItem) {
-                result.push(targetItem);
-              }
-            } else if (!result.some((item) => deepEquals2(item, targetItem))) {
-              result.push(targetItem);
-            }
-          }
-          merged[key] = result;
-        } else if (sourceValue.every((item) => typeof item === "string") && merged[key].every((item) => typeof item === "string")) {
-          const result = [...sourceValue];
-          for (const item of merged[key]) {
-            if (!result.includes(item)) {
-              result.push(item);
-            }
-          }
-          merged[key] = result;
-        } else {
-          merged[key] = sourceValue;
-        }
-      } else {
-        merged[key] = sourceValue;
-      }
-    }
-  }
-  return merged;
-}
-function deepEquals2(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 (!deepEquals2(a[i], b[i]))
-        return false;
-    }
-    return true;
-  }
-  if (isObject2(a) && isObject2(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 (!deepEquals2(a[key], b[key]))
-        return false;
-    }
-    return true;
-  }
-  return false;
-}
-function isObject2(item) {
-  return Boolean(item && typeof item === "object" && !Array.isArray(item));
+function createKey2(configName, options = {}) {
+  const sortedKeys = Object.keys(options).sort();
+  const optionsStr = sortedKeys.map((key) => `${key}:${options[key]}`).join("|");
+  return optionsStr ? `${configName}:${optionsStr}` : configName;
 }
-async function tryLoadConfig2(configPath, defaultConfig3) {
-  if (!existsSync22(configPath))
-    return null;
+function isEquivalent2(a, b) {
   try {
-    const importedConfig = await import(configPath);
-    const loadedConfig = importedConfig.default || importedConfig;
-    if (typeof loadedConfig !== "object" || loadedConfig === null || Array.isArray(loadedConfig))
-      return null;
-    try {
-      return deepMerge2(defaultConfig3, loadedConfig);
-    } catch {
-      return null;
-    }
+    return JSON.stringify(a) === JSON.stringify(b);
   } catch {
-    return null;
+    return a === b;
   }
 }
-async function loadConfig2({
-  name = "",
-  cwd,
-  defaultConfig: defaultConfig3
-}) {
-  const baseDir = cwd || process9.cwd();
-  const extensions = [".ts", ".js", ".mjs", ".cjs", ".json"];
-  const configPaths = [
-    `${name}.config`,
-    `.${name}.config`,
-    name,
-    `.${name}`
-  ];
-  for (const configPath of configPaths) {
-    for (const ext of extensions) {
-      const fullPath = resolve8(baseDir, `${configPath}${ext}`);
-      const config22 = await tryLoadConfig2(fullPath, defaultConfig3);
-      if (config22 !== null) {
-        return config22;
-      }
-    }
-  }
-  try {
-    const pkgPath = resolve8(baseDir, "package.json");
-    if (existsSync22(pkgPath)) {
-      const pkg = await import(pkgPath);
-      const pkgConfig = pkg[name];
-      if (pkgConfig && typeof pkgConfig === "object" && !Array.isArray(pkgConfig)) {
-        try {
-          return deepMerge2(defaultConfig3, pkgConfig);
-        } catch {}
-      }
-    }
-  } catch {}
-  return defaultConfig3;
+function estimateMemoryUsage2(cache) {
+  const stats = cache.getStats();
+  return stats.size * 2;
 }
-var defaultConfigDir2 = resolve8(process9.cwd(), "config");
-var defaultGeneratedDir2 = resolve8(process9.cwd(), "src/generated");
+var globalCache2;
+var globalPerformanceMonitor2;
+var CacheUtils2;
+var init_cache2 = __esm2(() => {
+  globalCache2 = new ConfigCache2;
+  globalPerformanceMonitor2 = new PerformanceMonitor2;
+  CacheUtils2 = {
+    createKey: createKey2,
+    isEquivalent: isEquivalent2,
+    estimateMemoryUsage: estimateMemoryUsage2
+  };
+});
 function getProjectRoot2(filePath, options = {}) {
-  let path = process22.cwd();
+  let path = process9.cwd();
   while (path.includes("storage"))
-    path = resolve22(path, "..");
-  const finalPath = resolve22(path, filePath || "");
+    path = resolve4(path, "..");
+  const finalPath = resolve4(path, filePath || "");
   if (options?.relative)
-    return relative3(process22.cwd(), finalPath);
+    return relative2(process9.cwd(), finalPath);
   return finalPath;
 }
-var defaultLogDirectory2 = process22.env.CLARITY_LOG_DIR || join4(getProjectRoot2(), "logs");
-var defaultConfig3 = {
-  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
-};
-async function loadConfig22() {
-  try {
-    const loadedConfig = await loadConfig2({
-      name: "clarity",
-      defaultConfig: defaultConfig3,
-      cwd: process22.cwd(),
-      endpoint: "",
-      headers: {}
-    });
-    return { ...defaultConfig3, ...loadedConfig };
-  } catch {
-    return defaultConfig3;
-  }
-}
-var config5 = await loadConfig22();
 function isBrowserProcess2() {
-  if (process32.env.NODE_ENV === "test" || process32.env.BUN_ENV === "test") {
+  if (process22.env.NODE_ENV === "test" || process22.env.BUN_ENV === "test") {
     return false;
   }
   return typeof window !== "undefined";
 }
 async function isServerProcess2() {
-  if (process32.env.NODE_ENV === "test" || process32.env.BUN_ENV === "test") {
+  if (process22.env.NODE_ENV === "test" || process22.env.BUN_ENV === "test") {
     return true;
   }
   if (typeof navigator !== "undefined" && navigator.product === "ReactNative") {
     return true;
   }
-  if (typeof process32 !== "undefined") {
-    const type = process32.type;
+  if (typeof process22 !== "undefined") {
+    const type = process22.type;
     if (type === "renderer" || type === "worker") {
       return false;
     }
-    return !!(process32.versions && (process32.versions.node || process32.versions.bun));
+    return !!(process22.versions && (process22.versions.node || process22.versions.bun));
   }
   return false;
 }
@@ -4799,17 +4608,17 @@ class JsonFormatter2 {
     if (isServer) {
       const { hostname } = await import("os");
       return {
-        pid: process42.pid,
+        pid: process32.pid,
         hostname: hostname(),
-        environment: process42.env.NODE_ENV || "development",
-        platform: process42.platform,
-        version: process42.version
+        environment: process32.env.NODE_ENV || "development",
+        platform: process32.platform,
+        version: process32.version
       };
     }
     return {
       userAgent: navigator.userAgent,
       hostname: window.location.hostname || "browser",
-      environment: process42.env.NODE_ENV || process42.env.BUN_ENV || "development",
+      environment: process32.env.NODE_ENV || process32.env.BUN_ENV || "development",
       viewport: {
         width: window.innerWidth,
         height: window.innerHeight
@@ -4818,64 +4627,12 @@ class JsonFormatter2 {
     };
   }
 }
-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`,
-  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`,
-  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 bold2 = terminalStyles2.bold;
-var dim2 = terminalStyles2.dim;
-var italic2 = terminalStyles2.italic;
-var underline2 = terminalStyles2.underline;
-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;
-  config;
-  options;
-  formatter;
-  timers = new Set;
-  subLoggers = new Set;
-  fingersCrossedBuffer = [];
   fingersCrossedConfig;
   fingersCrossedActive = false;
   currentLogFile;
@@ -4890,6 +4647,12 @@ class Logger2 {
   tagFormat;
   timestampPosition;
   environment;
+  config;
+  options;
+  formatter;
+  timers = new Set;
+  subLoggers = new Set;
+  fingersCrossedBuffer = [];
   ANSI_PATTERN = /\u001B\[.*?m/g;
   activeProgressBar = null;
   constructor(name, options = {}) {
@@ -4901,7 +4664,7 @@ class Logger2 {
     this.fancy = options.fancy ?? true;
     this.tagFormat = options.tagFormat ?? { prefix: "[", suffix: "]" };
     this.timestampPosition = options.timestampPosition ?? "right";
-    this.environment = options.environment ?? process52.env.APP_ENV ?? "local";
+    this.environment = options.environment ?? process42.env.APP_ENV ?? "local";
     this.fingersCrossedConfig = this.initializeFingersCrossedConfig(options);
     const configOptions = { ...options };
     const hasTimestamp = options.timestamp !== undefined;
@@ -4911,7 +4674,8 @@ class Logger2 {
     this.config = {
       ...this.config,
       ...configOptions,
-      timestamp: hasTimestamp || this.config.timestamp
+      timestamp: hasTimestamp || this.config.timestamp,
+      level: this.options.level ?? "info"
     };
     this.currentLogFile = this.generateLogFilename();
     this.encryptionKeys = new Map;
@@ -4928,6 +4692,19 @@ class Logger2 {
       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 {
@@ -4956,6 +4733,7 @@ class Logger2 {
       fingersCrossed: {},
       enabled: true,
       showTags: false,
+      showIcons: true,
       formatter: undefined
     };
     const mergedOptions = {
@@ -4967,6 +4745,9 @@ class Logger2 {
     }
     return mergedOptions;
   }
+  shouldWriteToFile() {
+    return !isBrowserProcess2() && this.config.writeToFile === true;
+  }
   async writeToFile(data) {
     const cancelled = false;
     const operationPromise = (async () => {
@@ -5000,11 +4781,11 @@ class Logger2 {
             throw new Error("Operation cancelled: Logger was destroyed");
           const dataToWrite = this.validateEncryptionConfig() ? (await this.encrypt(data)).encrypted : Buffer2.from(data);
           try {
-            if (!existsSync222(this.currentLogFile)) {
+            if (!existsSync22(this.currentLogFile)) {
               await writeFile2(this.currentLogFile, "", { mode: 420 });
             }
             fd = openSync2(this.currentLogFile, "a", 420);
-            writeFileSync22(fd, dataToWrite, { flag: "a" });
+            writeFileSync3(fd, dataToWrite, { flag: "a" });
             fsyncSync2(fd);
             if (fd !== undefined) {
               closeSync2(fd);
@@ -5082,6 +4863,8 @@ class Logger2 {
   setupRotation() {
     if (isBrowserProcess2())
       return;
+    if (!this.shouldWriteToFile())
+      return;
     if (typeof this.config.rotation === "boolean")
       return;
     const config22 = this.config.rotation;
@@ -5166,13 +4949,18 @@ class Logger2 {
     const { key } = this.getCurrentKey();
     const iv = randomBytes3(16);
     const cipher = createCipheriv2("aes-256-gcm", key, iv);
-    const encrypted = Buffer2.concat([
-      cipher.update(data, "utf8"),
-      cipher.final()
-    ]);
+    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: Buffer2.concat([iv, encrypted, authTag]),
+      encrypted: out,
       iv
     };
   }
@@ -5207,6 +4995,8 @@ class Logger2 {
   async rotateLog() {
     if (isBrowserProcess2())
       return;
+    if (!this.shouldWriteToFile())
+      return;
     const stats = await stat2(this.currentLogFile).catch(() => null);
     if (!stats)
       return;
@@ -5279,42 +5069,19 @@ class Logger2 {
       this.isActivated = true;
       for (const entry of this.logBuffer) {
         const formattedBufferedEntry = await this.formatter.format(entry);
-        await this.writeToFile(formattedBufferedEntry);
+        if (this.shouldWriteToFile())
+          await this.writeToFile(formattedBufferedEntry);
         console.log(formattedBufferedEntry);
       }
       if (this.fingersCrossedConfig.stopBuffering)
         this.logBuffer = [];
     }
     if (this.isActivated) {
-      await this.writeToFile(formattedEntry);
+      if (this.shouldWriteToFile())
+        await this.writeToFile(formattedEntry);
       console.log(formattedEntry);
-    } else {
-      if (this.logBuffer.length >= this.fingersCrossedConfig.bufferSize)
-        this.logBuffer.shift();
-      const entry = {
-        timestamp: new Date,
-        level,
-        message: formattedEntry,
-        name: this.name
-      };
-      this.logBuffer.push(entry);
     }
   }
-  shouldActivateFingersCrossed(level) {
-    if (!this.fingersCrossedConfig)
-      return false;
-    return this.getLevelValue(level) >= this.getLevelValue(this.fingersCrossedConfig.activationLevel);
-  }
-  getLevelValue(level) {
-    const levels = {
-      debug: 0,
-      info: 1,
-      success: 2,
-      warning: 3,
-      error: 4
-    };
-    return levels[level];
-  }
   shouldLog(level) {
     if (!this.enabled)
       return false;
@@ -5336,7 +5103,7 @@ class Logger2 {
       }
       return Promise.resolve();
     }));
-    if (existsSync222(this.currentLogFile)) {
+    if (existsSync22(this.currentLogFile)) {
       try {
         const fd = openSync2(this.currentLogFile, "r+");
         fsyncSync2(fd);
@@ -5394,7 +5161,17 @@ class Logger2 {
     return `[${date.toISOString()}]`;
   }
   formatConsoleTimestamp(date) {
-    return this.fancy ? styles2.gray(date.toLocaleTimeString()) : date.toLocaleTimeString();
+    return this.shouldStyleConsole() ? styles2.gray(date.toLocaleTimeString()) : date.toLocaleTimeString();
+  }
+  shouldStyleConsole() {
+    if (!this.fancy || isBrowserProcess2())
+      return false;
+    const noColor = typeof process42.env.NO_COLOR !== "undefined";
+    const forceColorDisabled = process42.env.FORCE_COLOR === "0";
+    if (noColor || forceColorDisabled)
+      return false;
+    const hasTTY = typeof process42.stderr !== "undefined" && process42.stderr.isTTY || typeof process42.stdout !== "undefined" && process42.stdout.isTTY;
+    return !!hasTTY;
   }
   formatConsoleMessage(parts) {
     const { timestamp, icon = "", tag = "", message, level, showTimestamp = true } = parts;
@@ -5414,7 +5191,7 @@ class Logger2 {
       components.push(message);
       return components.join(" ");
     }
-    const terminalWidth = process52.stdout.columns || 120;
+    const terminalWidth = process42.stdout.columns || 120;
     let mainPart = "";
     if (level === "warning" || level === "error") {
       mainPart = `${icon} ${message}`;
@@ -5464,8 +5241,80 @@ class Logger2 {
     }
     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 = process42.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 = process42.env.HOME || "";
+        if (home)
+          p = p.replace(/^~(?=$|\/)/, home);
+      }
+      if (isAbsolute2(p) || p.startsWith("./") || p.startsWith("../")) {
+        p = resolve22(p);
+      } else {
+        return null;
+      }
+      return existsSync22(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;
+    if (!this.shouldLog(level))
+      return;
+    const timestamp = new Date;
     const consoleTime = this.formatConsoleTimestamp(timestamp);
     const fileTime = this.formatFileTimestamp(timestamp);
     let formattedMessage;
@@ -5476,8 +5325,9 @@ class Logger2 {
     } else {
       formattedMessage = this.formatMessage(message, args);
     }
-    if (this.fancy && !isBrowserProcess2()) {
-      const icon = levelIcons2[level];
+    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) {
@@ -5486,7 +5336,7 @@ class Logger2 {
             timestamp: consoleTime,
             icon,
             tag,
-            message: styles2.gray(formattedMessage),
+            message: styles2.gray(baseConsoleText),
             level
           });
           console.error(consoleMessage);
@@ -5496,17 +5346,17 @@ class Logger2 {
             timestamp: consoleTime,
             icon,
             tag,
-            message: formattedMessage,
+            message: baseConsoleText,
             level
           });
-          console.error(consoleMessage);
+          console.warn(consoleMessage);
           break;
         case "success":
           consoleMessage = this.formatConsoleMessage({
             timestamp: consoleTime,
             icon,
             tag,
-            message: styles2.green(formattedMessage),
+            message: styles2.green(baseConsoleText),
             level
           });
           console.error(consoleMessage);
@@ -5516,7 +5366,7 @@ class Logger2 {
             timestamp: consoleTime,
             icon,
             tag,
-            message: formattedMessage,
+            message: baseConsoleText,
             level
           });
           console.warn(consoleMessage);
@@ -5526,7 +5376,7 @@ class Logger2 {
             timestamp: consoleTime,
             icon,
             tag,
-            message: formattedMessage,
+            message: baseConsoleText,
             level
           });
           console.error(consoleMessage);
@@ -5552,25 +5402,68 @@ class Logger2 {
         console.error(errorStack);
       }
     }
-    if (!this.shouldLog(level))
-      return;
-    let logEntry = `${fileTime} ${this.environment}.${level.toUpperCase()}: ${formattedMessage}
+    let logEntry = `${fileTime} ${this.environment}.${level.toUpperCase()}: ${fileText}
 `;
     if (errorStack) {
       logEntry += `${errorStack}
 `;
     }
     logEntry = logEntry.replace(this.ANSI_PATTERN, "");
-    await this.writeToFile(logEntry);
+    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() && process42.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() && process42.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() && process42.stdout.isTTY)
+        process42.stdout.write(`
+`);
+      const method = level === "warning" ? "warn" : level;
+      this[method](message);
+      if (this.activeProgressBar && this.shouldStyleConsole() && !isBrowserProcess2() && process42.stdout.isTTY)
+        this.renderProgressBar(this.activeProgressBar);
+    };
+    return { update, finish, interrupt };
   }
   time(label) {
     const start = performance.now();
-    if (this.fancy && !isBrowserProcess2()) {
+    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: styles2.blue("\u25D0"),
+        icon: this.options.showIcons === false ? "" : styles2.blue("\u25D0"),
         tag,
         message: `${styles2.cyan(label)}...`
       }));
@@ -5591,18 +5484,19 @@ class Logger2 {
       logEntry += `
 `;
       logEntry = logEntry.replace(this.ANSI_PATTERN, "");
-      if (this.fancy && !isBrowserProcess2()) {
+      if (this.shouldStyleConsole()) {
         const tag = this.options.showTags !== false && this.name ? styles2.gray(this.formatTag(this.name)) : "";
         console.error(this.formatConsoleMessage({
           timestamp: consoleTime,
-          icon: styles2.green("\u2713"),
+          icon: this.options.showIcons === false ? "" : styles2.green("\u2713"),
           tag,
           message: `${completionMessage}${metadata ? ` ${JSON.stringify(metadata)}` : ""}`
         }));
       } else if (!isBrowserProcess2()) {
         console.error(logEntry.trim());
       }
-      await this.writeToFile(logEntry);
+      if (this.shouldWriteToFile())
+        await this.writeToFile(logEntry);
     };
   }
   async debug(message, ...args) {
@@ -5656,7 +5550,7 @@ class Logger2 {
   createReadStream() {
     if (isBrowserProcess2())
       throw new Error("createReadStream is not supported in browser environments");
-    if (!existsSync222(this.currentLogFile))
+    if (!existsSync22(this.currentLogFile))
       throw new Error(`Log file does not exist: ${this.currentLogFile}`);
     return createReadStream2(this.currentLogFile, { encoding: "utf8" });
   }
@@ -5671,16 +5565,18 @@ class Logger2 {
     const key = this.keys.get(this.currentKeyId);
     try {
       const encryptedData = Buffer2.isBuffer(data) ? data : Buffer2.from(data, "base64");
-      const iv = encryptedData.slice(0, 16);
-      const authTag = encryptedData.slice(-16);
-      const ciphertext = encryptedData.slice(16, -16);
+      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 decrypted = Buffer2.concat([
-        decipher.update(ciphertext),
-        decipher.final()
-      ]);
-      return decrypted.toString("utf8");
+      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)}`);
     }
@@ -5725,43 +5621,38 @@ class Logger2 {
     const timestamp = new Date;
     const consoleTime = this.formatConsoleTimestamp(timestamp);
     const fileTime = this.formatFileTimestamp(timestamp);
-    if (this.fancy && !isBrowserProcess2()) {
-      const lines = message.split(`
+    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) => {
-        const padding = " ".repeat(width - line.length - 2);
-        return `\u2502 ${line}${padding} \u2502`;
-      });
-      if (this.options.showTags !== false && this.name) {
-        console.error(this.formatConsoleMessage({
+        return this.formatConsoleMessage({
           timestamp: consoleTime,
-          message: styles2.gray(this.formatTag(this.name)),
+          message: styles2.cyan(line),
           showTimestamp: false
-        }));
-      }
+        });
+      });
       console.error(this.formatConsoleMessage({
         timestamp: consoleTime,
-        message: styles2.cyan(top)
-      }));
-      boxedLines.forEach((line) => console.error(this.formatConsoleMessage({
-        timestamp: consoleTime,
-        message: styles2.cyan(line),
+        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] ${message}`);
+      console.error(`${fileTime} ${this.environment}.INFO: [BOX] ${fileText}`);
     }
-    const logEntry = `${fileTime} ${this.environment}.INFO: [BOX] ${message}
+    const logEntry = `${fileTime} ${this.environment}.INFO: [BOX] ${fileText}
 `.replace(this.ANSI_PATTERN, "");
-    await this.writeToFile(logEntry);
+    if (this.shouldWriteToFile())
+      await this.writeToFile(logEntry);
   }
   async prompt(message) {
     if (isBrowserProcess2()) {
@@ -5771,23 +5662,23 @@ class Logger2 {
       console.error(`${styles2.cyan("?")} ${message} (y/n) `);
       const onData = (data) => {
         const input = data.toString().trim().toLowerCase();
-        process52.stdin.removeListener("data", onData);
+        process42.stdin.removeListener("data", onData);
         try {
-          if (typeof process52.stdin.setRawMode === "function") {
-            process52.stdin.setRawMode(false);
+          if (typeof process42.stdin.setRawMode === "function") {
+            process42.stdin.setRawMode(false);
           }
         } catch {}
-        process52.stdin.pause();
+        process42.stdin.pause();
         console.error("");
         resolve322(input === "y" || input === "yes");
       };
       try {
-        if (typeof process52.stdin.setRawMode === "function") {
-          process52.stdin.setRawMode(true);
+        if (typeof process42.stdin.setRawMode === "function") {
+          process42.stdin.setRawMode(true);
         }
       } catch {}
-      process52.stdin.resume();
-      process52.stdin.once("data", onData);
+      process42.stdin.resume();
+      process42.stdin.once("data", onData);
     });
   }
   setFancy(enabled) {
@@ -5832,73 +5723,21 @@ class Logger2 {
         formattedMessage += ` ${args.slice(argIndex).map((arg) => typeof arg === "object" ? JSON.stringify(arg, null, 2) : String(arg)).join(" ")}`;
       }
     }
-    if (this.fancy && !isBrowserProcess2()) {
+    const { consoleText, fileText } = this.buildOutputTexts(formattedMessage);
+    if (this.shouldStyleConsole()) {
       const tag = this.options.showTags !== false && this.name ? styles2.gray(this.formatTag(this.name)) : "";
-      const spinnerChar = styles2.blue("\u25D0");
-      console.error(`${spinnerChar} ${tag} ${styles2.cyan(formattedMessage)}`);
+      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] ${formattedMessage}
+    const logEntry = `[${formattedDate}] ${this.environment}.INFO: [START] ${fileText}
 `.replace(this.ANSI_PATTERN, "");
-    await this.writeToFile(logEntry);
-  }
-  progress(total, initialMessage = "") {
-    if (!this.enabled || !this.fancy || isBrowserProcess2() || total <= 0) {
-      return {
-        update: () => {},
-        finish: () => {},
-        interrupt: () => {}
-      };
-    }
-    if (this.activeProgressBar) {
-      console.warn("Warning: Another progress bar is already active. Finishing the previous one.");
-      this.finishProgressBar(this.activeProgressBar, "[Auto-finished]");
-    }
-    const barLength = 20;
-    this.activeProgressBar = {
-      total,
-      current: 0,
-      message: initialMessage,
-      barLength,
-      lastRenderedLine: ""
-    };
-    this.renderProgressBar(this.activeProgressBar);
-    const update = (current, message) => {
-      if (!this.activeProgressBar || !this.enabled || !this.fancy || isBrowserProcess2())
-        return;
-      this.activeProgressBar.current = Math.max(0, Math.min(total, current));
-      if (message !== undefined) {
-        this.activeProgressBar.message = message;
-      }
-      const isFinished = this.activeProgressBar.current === this.activeProgressBar.total;
-      this.renderProgressBar(this.activeProgressBar, isFinished);
-    };
-    const finish = (message) => {
-      if (!this.activeProgressBar || !this.enabled || !this.fancy || isBrowserProcess2())
-        return;
-      this.activeProgressBar.current = this.activeProgressBar.total;
-      if (message !== undefined) {
-        this.activeProgressBar.message = message;
-      }
-      this.renderProgressBar(this.activeProgressBar, true);
-      this.finishProgressBar(this.activeProgressBar);
-    };
-    const interrupt = (interruptMessage, level = "info") => {
-      if (!this.activeProgressBar || !this.enabled || !this.fancy || isBrowserProcess2())
-        return;
-      process52.stdout.write(`${"\r".padEnd(process52.stdout.columns || 80)}\r`);
-      this.log(level, interruptMessage);
-      setTimeout(() => {
-        if (this.activeProgressBar) {
-          this.renderProgressBar(this.activeProgressBar);
-        }
-      }, 50);
-    };
-    return { update, finish, interrupt };
+    if (this.shouldWriteToFile())
+      await this.writeToFile(logEntry);
   }
   renderProgressBar(barState, isFinished = false) {
-    if (!this.enabled || !this.fancy || isBrowserProcess2() || !process52.stdout.isTTY)
+    if (!this.enabled || !this.shouldStyleConsole() || !process42.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);
@@ -5908,20 +5747,20 @@ class Logger2 {
     const bar = `[${filledBar}${emptyBar}]`;
     const percentageText = `${percent}%`.padStart(4);
     const messageText = barState.message ? ` ${barState.message}` : "";
-    const icon = isFinished || percent === 100 ? styles2.green("\u2713") : styles2.blue("\u25B6");
+    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 = process52.stdout.columns || 80;
+    const terminalWidth = process42.stdout.columns || 80;
     const clearLine = " ".repeat(Math.max(0, terminalWidth - line.replace(this.ANSI_PATTERN, "").length));
     barState.lastRenderedLine = `${line}${clearLine}`;
-    process52.stdout.write(barState.lastRenderedLine);
+    process42.stdout.write(barState.lastRenderedLine);
     if (isFinished) {
-      process52.stdout.write(`
+      process42.stdout.write(`
 `);
     }
   }
   finishProgressBar(barState, finalMessage) {
-    if (!this.enabled || !this.fancy || isBrowserProcess2() || !process52.stdout.isTTY) {
+    if (!this.enabled || !this.fancy || isBrowserProcess2() || !process42.stdout.isTTY) {
       this.activeProgressBar = null;
       return;
     }
@@ -5980,1934 +5819,369 @@ class Logger2 {
     }
   }
 }
-var logger2 = new Logger2("stacks");
-function deepMerge22(target, source) {
-  if (Array.isArray(source) && Array.isArray(target) && source.length === 2 && target.length === 2 && isObject22(source[0]) && "id" in source[0] && source[0].id === 3 && isObject22(source[1]) && "id" in source[1] && source[1].id === 4) {
-    return source;
-  }
-  if (isObject22(source) && isObject22(target) && Object.keys(source).length === 2 && Object.keys(source).includes("a") && source.a === null && Object.keys(source).includes("c") && source.c === undefined) {
-    return { a: null, b: 2, c: undefined };
-  }
-  if (source === null || source === undefined) {
-    return target;
-  }
-  if (Array.isArray(source) && !Array.isArray(target)) {
-    return source;
-  }
-  if (Array.isArray(source) && Array.isArray(target)) {
-    if (isObject22(target) && "arr" in target && Array.isArray(target.arr) && isObject22(source) && "arr" in source && Array.isArray(source.arr)) {
-      return source;
-    }
-    if (source.length > 0 && target.length > 0 && isObject22(source[0]) && isObject22(target[0])) {
-      const result = [...source];
-      for (const targetItem of target) {
-        if (isObject22(targetItem) && "name" in targetItem) {
-          const existingItem = result.find((item) => isObject22(item) && ("name" in item) && item.name === targetItem.name);
-          if (!existingItem) {
-            result.push(targetItem);
-          }
-        } else if (isObject22(targetItem) && "path" in targetItem) {
-          const existingItem = result.find((item) => isObject22(item) && ("path" in item) && item.path === targetItem.path);
-          if (!existingItem) {
-            result.push(targetItem);
-          }
-        } else if (!result.some((item) => deepEquals22(item, targetItem))) {
-          result.push(targetItem);
-        }
+var defaultLogDirectory2;
+var defaultConfig3;
+var config5;
+var configReady2;
+var terminalStyles2;
+var styles2;
+var red2;
+var green2;
+var yellow2;
+var blue2;
+var magenta2;
+var cyan2;
+var white2;
+var gray2;
+var bgRed2;
+var bgYellow2;
+var bgGray2;
+var bold2;
+var dim2;
+var italic2;
+var underline2;
+var strikethrough2;
+var reset2;
+var defaultFingersCrossedConfig2;
+var levelIcons2;
+var logger2;
+var init_src3 = __esm2(() => {
+  defaultLogDirectory2 = process9.env.CLARITY_LOG_DIR || join3(getProjectRoot2(), "logs");
+  defaultConfig3 = {
+    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
+  };
+  config5 = { ...defaultConfig3 };
+  configReady2 = (async () => {
+    try {
+      const { loadConfig: bunfigLoadConfig } = await Promise.resolve().then(() => (init_src22(), exports_src2));
+      const loadedConfig = await bunfigLoadConfig({
+        name: "clarity",
+        alias: "logging",
+        defaultConfig: defaultConfig3,
+        cwd: process9.cwd()
+      });
+      if (loadedConfig)
+        Object.assign(config5, loadedConfig);
+    } catch {}
+    return config5;
+  })();
+  terminalStyles2 = {
+    red: (text) => `\x1B[31m${text}\x1B[0m`,
+    green: (text) => `\x1B[32m${text}\x1B[0m`,
+    yellow: (text) => `\x1B[33m${text}\x1B[0m`,
+    blue: (text) => `\x1B[34m${text}\x1B[0m`,
+    magenta: (text) => `\x1B[35m${text}\x1B[0m`,
+    cyan: (text) => `\x1B[36m${text}\x1B[0m`,
+    white: (text) => `\x1B[37m${text}\x1B[0m`,
+    gray: (text) => `\x1B[90m${text}\x1B[0m`,
+    bgRed: (text) => `\x1B[41m${text}\x1B[0m`,
+    bgYellow: (text) => `\x1B[43m${text}\x1B[0m`,
+    bgGray: (text) => `\x1B[100m${text}\x1B[0m`,
+    bold: (text) => `\x1B[1m${text}\x1B[0m`,
+    dim: (text) => `\x1B[2m${text}\x1B[0m`,
+    italic: (text) => `\x1B[3m${text}\x1B[0m`,
+    underline: (text) => `\x1B[4m${text}\x1B[0m`,
+    strikethrough: (text) => `\x1B[9m${text}\x1B[0m`,
+    reset: "\x1B[0m"
+  };
+  styles2 = terminalStyles2;
+  red2 = terminalStyles2.red;
+  green2 = terminalStyles2.green;
+  yellow2 = terminalStyles2.yellow;
+  blue2 = terminalStyles2.blue;
+  magenta2 = terminalStyles2.magenta;
+  cyan2 = terminalStyles2.cyan;
+  white2 = terminalStyles2.white;
+  gray2 = terminalStyles2.gray;
+  bgRed2 = terminalStyles2.bgRed;
+  bgYellow2 = terminalStyles2.bgYellow;
+  bgGray2 = terminalStyles2.bgGray;
+  bold2 = terminalStyles2.bold;
+  dim2 = terminalStyles2.dim;
+  italic2 = terminalStyles2.italic;
+  underline2 = terminalStyles2.underline;
+  strikethrough2 = terminalStyles2.strikethrough;
+  reset2 = terminalStyles2.reset;
+  defaultFingersCrossedConfig2 = {
+    activationLevel: "error",
+    bufferSize: 50,
+    flushOnDeactivation: true,
+    stopBuffering: false
+  };
+  levelIcons2 = {
+    debug: "\uD83D\uDD0D",
+    info: blue2("\u2139"),
+    success: green2("\u2713"),
+    warning: bgYellow2(white2(bold2(" WARN "))),
+    error: bgRed2(white2(bold2(" ERROR ")))
+  };
+  logger2 = new Logger2("stacks");
+});
+var version2 = "0.15.9";
+var init_package2 = () => {};
+async function withErrorRecovery2(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;
       }
-      return result;
-    }
-    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);
-        }
+      if (retryDelay > 0) {
+        await new Promise((resolve322) => setTimeout(resolve322, retryDelay));
       }
-      return result;
     }
-    return source;
-  }
-  if (!isObject22(source) || !isObject22(target)) {
-    return source;
   }
-  const merged = { ...target };
-  for (const key in source) {
-    if (Object.prototype.hasOwnProperty.call(source, key)) {
-      const sourceValue = source[key];
-      if (sourceValue === null || sourceValue === undefined) {
-        continue;
-      } else if (isObject22(sourceValue) && isObject22(merged[key])) {
-        merged[key] = deepMerge22(merged[key], sourceValue);
-      } else if (Array.isArray(sourceValue) && Array.isArray(merged[key])) {
-        if (sourceValue.length > 0 && merged[key].length > 0 && isObject22(sourceValue[0]) && isObject22(merged[key][0])) {
-          const result = [...sourceValue];
-          for (const targetItem of merged[key]) {
-            if (isObject22(targetItem) && "name" in targetItem) {
-              const existingItem = result.find((item) => isObject22(item) && ("name" in item) && item.name === targetItem.name);
-              if (!existingItem) {
-                result.push(targetItem);
-              }
-            } else if (isObject22(targetItem) && "path" in targetItem) {
-              const existingItem = result.find((item) => isObject22(item) && ("path" in item) && item.path === targetItem.path);
-              if (!existingItem) {
-                result.push(targetItem);
-              }
-            } else if (!result.some((item) => deepEquals22(item, targetItem))) {
-              result.push(targetItem);
-            }
-          }
-          merged[key] = result;
-        } else if (sourceValue.every((item) => typeof item === "string") && merged[key].every((item) => typeof item === "string")) {
-          const result = [...sourceValue];
-          for (const item of merged[key]) {
-            if (!result.includes(item)) {
-              result.push(item);
-            }
-          }
-          merged[key] = result;
-        } else {
-          merged[key] = sourceValue;
-        }
-      } else {
-        merged[key] = sourceValue;
-      }
-    }
+  if (fallback !== undefined) {
+    return fallback;
   }
-  return merged;
+  throw lastError instanceof Error ? lastError : new Error(`Unknown error: ${String(lastError)}`);
 }
-function deepMergeWithArrayStrategy2(target, source, strategy = "replace") {
-  if (source === null || source === undefined)
-    return target;
-  if (Array.isArray(source)) {
-    return strategy === "replace" ? source : deepMerge22(target, source);
-  }
-  if (Array.isArray(target)) {
-    return strategy === "replace" ? source : deepMerge22(target, source);
-  }
-  if (!isObject22(source) || !isObject22(target))
-    return source;
-  const result = { ...target };
-  for (const key of Object.keys(source)) {
-    if (!Object.prototype.hasOwnProperty.call(source, key))
-      continue;
-    const sourceValue = source[key];
-    const targetValue = result[key];
-    if (sourceValue === null || sourceValue === undefined)
-      continue;
-    if (Array.isArray(sourceValue) || Array.isArray(targetValue)) {
-      if (strategy === "replace") {
-        result[key] = sourceValue;
-      } else {
-        result[key] = deepMerge22(targetValue, sourceValue);
-      }
-    } else if (isObject22(sourceValue) && isObject22(targetValue)) {
-      result[key] = deepMergeWithArrayStrategy2(targetValue, sourceValue, strategy);
-    } else {
-      result[key] = sourceValue;
-    }
-  }
-  return result;
+function isBunfigError2(error) {
+  return error instanceof BunfigError2;
 }
-function deepEquals22(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 (!deepEquals22(a[i], b[i]))
-        return false;
-    }
-    return true;
-  }
-  if (isObject22(a) && isObject22(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 (!deepEquals22(a[key], b[key]))
-        return false;
-    }
-    return true;
-  }
-  return false;
-}
-function isObject22(item) {
-  return Boolean(item && typeof item === "object" && !Array.isArray(item));
-}
-var log2 = new Logger2("bunfig", {
-  showTags: true
-});
-async function tryLoadConfig22(configPath, defaultConfig22, arrayStrategy = "replace") {
-  if (!existsSync32(configPath))
-    return null;
-  try {
-    const importedConfig = await import(configPath);
-    const loadedConfig = importedConfig.default || importedConfig;
-    if (typeof loadedConfig !== "object" || loadedConfig === null || Array.isArray(loadedConfig))
-      return null;
-    try {
-      return deepMergeWithArrayStrategy2(defaultConfig22, loadedConfig, arrayStrategy);
-    } catch {
-      return null;
-    }
-  } catch {
-    return null;
+function isConfigNotFoundError2(error) {
+  return error instanceof ConfigNotFoundError2;
+}
+function isRetryableError2(error) {
+  if (isBunfigError2(error)) {
+    return error.code === "FILE_SYSTEM_ERROR" || error.code === "BROWSER_CONFIG_ERROR";
   }
+  const retryableMessages = [
+    "ENOENT",
+    "EACCES",
+    "EMFILE",
+    "ENFILE",
+    "EBUSY",
+    "network",
+    "timeout",
+    "connection"
+  ];
+  return retryableMessages.some((msg) => error.message.toLowerCase().includes(msg.toLowerCase()));
 }
-function applyEnvVarsToConfig2(name, config32, verbose = false) {
-  if (!name)
-    return config32;
-  const envPrefix = name.toUpperCase().replace(/-/g, "_");
-  const result = { ...config32 };
-  function processObject(obj, path = []) {
-    const result2 = { ...obj };
-    for (const [key, value] of Object.entries(obj)) {
-      const envPath = [...path, key];
-      const formatKey = (k) => k.replace(/([A-Z])/g, "_$1").toUpperCase();
-      const envKey = `${envPrefix}_${envPath.map(formatKey).join("_")}`;
-      const oldEnvKey = `${envPrefix}_${envPath.map((p) => p.toUpperCase()).join("_")}`;
-      if (verbose)
-        log2.info(`Checking environment variable ${envKey} for config ${name}.${envPath.join(".")}`);
-      if (typeof value === "object" && value !== null && !Array.isArray(value)) {
-        result2[key] = processObject(value, envPath);
-      } else {
-        const envValue = process62.env[envKey] || process62.env[oldEnvKey];
-        if (envValue !== undefined) {
-          if (verbose) {
-            log2.info(`Using environment variable ${envValue ? envKey : oldEnvKey} for config ${name}.${envPath.join(".")}`);
-          }
-          if (typeof value === "number") {
-            result2[key] = Number(envValue);
-          } else if (typeof value === "boolean") {
-            result2[key] = envValue.toLowerCase() === "true";
-          } else if (Array.isArray(value)) {
-            try {
-              const parsed = JSON.parse(envValue);
-              if (Array.isArray(parsed)) {
-                result2[key] = parsed;
-              } else {
-                result2[key] = envValue.split(",").map((item) => item.trim());
-              }
-            } catch {
-              result2[key] = envValue.split(",").map((item) => item.trim());
-            }
-          } else {
-            result2[key] = envValue;
-          }
-        }
+var BunfigError2;
+var ConfigNotFoundError2;
+var ConfigLoadError2;
+var ConfigValidationError2;
+var ConfigMergeError2;
+var EnvVarError2;
+var FileSystemError2;
+var TypeGenerationError2;
+var SchemaValidationError2;
+var BrowserConfigError2;
+var PluginError2;
+var ErrorFactory2;
+var init_errors2 = __esm2(() => {
+  BunfigError2 = class BunfigError22 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);
       }
     }
-    return result2;
-  }
-  return processObject(result);
-}
-async function loadConfig3({
-  name = "",
-  alias,
-  cwd,
-  configDir,
-  defaultConfig: defaultConfig22,
-  verbose = false,
-  checkEnv = true,
-  arrayStrategy = "replace"
-}) {
-  const configWithEnvVars = checkEnv && typeof defaultConfig22 === "object" && defaultConfig22 !== null && !Array.isArray(defaultConfig22) ? applyEnvVarsToConfig2(name, defaultConfig22, verbose) : defaultConfig22;
-  const baseDir = cwd || process62.cwd();
-  const extensions = [".ts", ".js", ".mjs", ".cjs", ".json"];
-  if (verbose) {
-    log2.info(`Loading configuration for "${name}"${alias ? ` (alias: "${alias}")` : ""} from ${baseDir}`);
-  }
-  const primaryBarePatterns = [name, `.${name}`].filter(Boolean);
-  const primaryConfigSuffixPatterns = [`${name}.config`, `.${name}.config`].filter(Boolean);
-  const aliasBarePatterns = alias ? [alias, `.${alias}`] : [];
-  const aliasConfigSuffixPatterns = alias ? [`${alias}.config`, `.${alias}.config`] : [];
-  const searchDirectories = Array.from(new Set([
-    baseDir,
-    resolve32(baseDir, "config"),
-    resolve32(baseDir, ".config"),
-    configDir ? resolve32(baseDir, configDir) : undefined
-  ].filter(Boolean)));
-  for (const dir of searchDirectories) {
-    if (verbose)
-      log2.info(`Searching for configuration in: ${dir}`);
-    const isConfigLikeDir = [resolve32(baseDir, "config"), resolve32(baseDir, ".config")].concat(configDir ? [resolve32(baseDir, configDir)] : []).includes(dir);
-    const patternsForDir = isConfigLikeDir ? [...primaryBarePatterns, ...primaryConfigSuffixPatterns, ...aliasBarePatterns, ...aliasConfigSuffixPatterns] : [...primaryConfigSuffixPatterns, ...primaryBarePatterns, ...aliasConfigSuffixPatterns, ...aliasBarePatterns];
-    for (const configPath of patternsForDir) {
-      for (const ext of extensions) {
-        const fullPath = resolve32(dir, `${configPath}${ext}`);
-        const config32 = await tryLoadConfig22(fullPath, configWithEnvVars, arrayStrategy);
-        if (config32 !== null) {
-          if (verbose) {
-            log2.success(`Configuration loaded from: ${fullPath}`);
-          }
-          return config32;
-        }
-      }
+    toJSON() {
+      return {
+        name: this.name,
+        code: this.code,
+        message: this.message,
+        timestamp: this.timestamp.toISOString(),
+        context: this.context,
+        stack: this.stack
+      };
     }
-  }
-  if (name) {
-    const homeConfigDir = resolve32(homedir3(), ".config", name);
-    const homeConfigPatterns = ["config", `${name}.config`];
-    if (alias) {
-      homeConfigPatterns.push(`${alias}.config`);
+    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}`;
     }
-    if (verbose) {
-      log2.info(`Checking user config directory: ${homeConfigDir}`);
+  };
+  ConfigNotFoundError2 = class ConfigNotFoundError22 extends BunfigError2 {
+    code = "CONFIG_NOT_FOUND";
+    constructor(configName, searchPaths, alias) {
+      const aliasList = alias === undefined ? [] : Array.isArray(alias) ? alias.filter(Boolean) : [alias];
+      let aliasStr = "";
+      if (aliasList.length === 1)
+        aliasStr = ` or alias "${aliasList[0]}"`;
+      else if (aliasList.length > 1)
+        aliasStr = ` or aliases ${aliasList.map((a) => `"${a}"`).join(", ")}`;
+      super(`Configuration "${configName}"${aliasStr} not found`, {
+        configName,
+        alias,
+        searchPaths,
+        searchPathCount: searchPaths.length
+      });
     }
-    for (const configPath of homeConfigPatterns) {
-      for (const ext of extensions) {
-        const fullPath = resolve32(homeConfigDir, `${configPath}${ext}`);
-        const config32 = await tryLoadConfig22(fullPath, configWithEnvVars, arrayStrategy);
-        if (config32 !== null) {
-          if (verbose) {
-            log2.success(`Configuration loaded from user config directory: ${fullPath}`);
-          }
-          return config32;
-        }
-      }
+  };
+  ConfigLoadError2 = class ConfigLoadError22 extends BunfigError2 {
+    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;
     }
-  }
-  if (name) {
-    const homeConfigDir = resolve32(homedir3(), ".config");
-    const homeConfigDotfilePatterns = [`.${name}.config`];
-    if (alias)
-      homeConfigDotfilePatterns.push(`.${alias}.config`);
-    if (verbose)
-      log2.info(`Checking user config directory for dotfile configs: ${homeConfigDir}`);
-    for (const configPath of homeConfigDotfilePatterns) {
-      for (const ext of extensions) {
-        const fullPath = resolve32(homeConfigDir, `${configPath}${ext}`);
-        const config32 = await tryLoadConfig22(fullPath, configWithEnvVars, arrayStrategy);
-        if (config32 !== null) {
-          if (verbose)
-            log2.success(`Configuration loaded from user config directory dotfile: ${fullPath}`);
-          return config32;
-        }
-      }
+  };
+  ConfigValidationError2 = class ConfigValidationError22 extends BunfigError2 {
+    code = "CONFIG_VALIDATION_ERROR";
+    constructor(configPath, validationErrors, configName) {
+      super(`Configuration validation failed for "${configPath}"`, {
+        configPath,
+        configName,
+        validationErrors,
+        errorCount: validationErrors.length
+      });
     }
-  }
-  if (name) {
-    const homeDir = homedir3();
-    const homeRootPatterns = [`.${name}.config`, `.${name}`];
-    if (alias) {
-      homeRootPatterns.push(`.${alias}.config`);
-      homeRootPatterns.push(`.${alias}`);
+  };
+  ConfigMergeError2 = class ConfigMergeError22 extends BunfigError2 {
+    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;
     }
-    if (verbose)
-      log2.info(`Checking user home directory for dotfile configs: ${homeDir}`);
-    for (const configPath of homeRootPatterns) {
-      for (const ext of extensions) {
-        const fullPath = resolve32(homeDir, `${configPath}${ext}`);
-        const config32 = await tryLoadConfig22(fullPath, configWithEnvVars, arrayStrategy);
-        if (config32 !== null) {
-          if (verbose)
-            log2.success(`Configuration loaded from user home directory: ${fullPath}`);
-          return config32;
-        }
-      }
+  };
+  EnvVarError2 = class EnvVarError22 extends BunfigError2 {
+    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
+      });
     }
-  }
-  try {
-    const pkgPath = resolve32(baseDir, "package.json");
-    if (existsSync32(pkgPath)) {
-      const pkg = await import(pkgPath);
-      let pkgConfig = pkg[name];
-      if (!pkgConfig && alias) {
-        pkgConfig = pkg[alias];
-        if (pkgConfig && verbose) {
-          log2.success(`Using alias "${alias}" configuration from package.json`);
-        }
-      }
-      if (pkgConfig && typeof pkgConfig === "object" && !Array.isArray(pkgConfig)) {
-        try {
-          if (verbose) {
-            log2.success(`Configuration loaded from package.json: ${pkgConfig === pkg[name] ? name : alias}`);
-          }
-          return deepMergeWithArrayStrategy2(configWithEnvVars, pkgConfig, arrayStrategy);
-        } catch (error) {
-          if (verbose) {
-            log2.warn(`Failed to merge package.json config:`, error);
-          }
-        }
-      }
+  };
+  FileSystemError2 = class FileSystemError22 extends BunfigError2 {
+    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;
     }
-  } catch (error) {
-    if (verbose) {
-      log2.warn(`Failed to load package.json:`, error);
+  };
+  TypeGenerationError2 = class TypeGenerationError22 extends BunfigError2 {
+    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;
     }
-  }
-  if (verbose) {
-    log2.info(`No configuration found for "${name}"${alias ? ` or alias "${alias}"` : ""}, using default configuration with environment variables`);
-  }
-  return configWithEnvVars;
-}
-var defaultConfigDir22 = resolve32(process62.cwd(), "config");
-var defaultGeneratedDir22 = resolve32(process62.cwd(), "src/generated");
-function getProjectRoot22(filePath, options = {}) {
-  let path = process72.cwd();
-  while (path.includes("storage"))
-    path = resolve4(path, "..");
-  const finalPath = resolve4(path, filePath || "");
-  if (options?.relative)
-    return relative2(process72.cwd(), finalPath);
-  return finalPath;
-}
-var defaultLogDirectory22 = process72.env.CLARITY_LOG_DIR || join3(getProjectRoot22(), "logs");
-var defaultConfig22 = {
-  level: "info",
-  defaultName: "clarity",
-  timestamp: true,
-  colors: true,
-  format: "text",
-  maxLogSize: 10485760,
-  logDatePattern: "YYYY-MM-DD",
-  logDirectory: defaultLogDirectory22,
-  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: defaultConfig22,
-      cwd: process72.cwd()
-    });
-    return { ...defaultConfig22, ...loadedConfig || {} };
-  } catch {
-    return defaultConfig22;
-  }
-}
-var config22 = await loadConfig4();
-function isBrowserProcess22() {
-  if (process92.env.NODE_ENV === "test" || process92.env.BUN_ENV === "test") {
-    return false;
-  }
-  return typeof window !== "undefined";
-}
-async function isServerProcess22() {
-  if (process92.env.NODE_ENV === "test" || process92.env.BUN_ENV === "test") {
-    return true;
-  }
-  if (typeof navigator !== "undefined" && navigator.product === "ReactNative") {
-    return true;
-  }
-  if (typeof process92 !== "undefined") {
-    const type = process92.type;
-    if (type === "renderer" || type === "worker") {
-      return false;
+  };
+  SchemaValidationError2 = class SchemaValidationError22 extends BunfigError2 {
+    code = "SCHEMA_VALIDATION_ERROR";
+    constructor(schemaPath, validationErrors, configName) {
+      super(`Schema validation failed${configName ? ` for config "${configName}"` : ""}`, {
+        schemaPath,
+        configName,
+        validationErrors,
+        errorCount: validationErrors.length
+      });
     }
-    return !!(process92.versions && (process92.versions.node || process92.versions.bun));
-  }
-  return false;
-}
-
-class JsonFormatter22 {
-  async format(entry) {
-    const isServer = await isServerProcess22();
-    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
-      };
+  };
+  BrowserConfigError2 = class BrowserConfigError22 extends BunfigError2 {
+    code = "BROWSER_CONFIG_ERROR";
+    constructor(endpoint, status, statusText, configName) {
+      super(`Failed to fetch configuration from "${endpoint}": ${status} ${statusText}`, {
+        endpoint,
+        status,
+        statusText,
+        configName
+      });
     }
-    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 terminalStyles22 = {
-  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 styles22 = terminalStyles22;
-var red22 = terminalStyles22.red;
-var green22 = terminalStyles22.green;
-var yellow22 = terminalStyles22.yellow;
-var blue22 = terminalStyles22.blue;
-var magenta22 = terminalStyles22.magenta;
-var cyan22 = terminalStyles22.cyan;
-var white22 = terminalStyles22.white;
-var gray22 = terminalStyles22.gray;
-var bgRed22 = terminalStyles22.bgRed;
-var bgYellow22 = terminalStyles22.bgYellow;
-var bgGray2 = terminalStyles22.bgGray;
-var bold22 = terminalStyles22.bold;
-var dim22 = terminalStyles22.dim;
-var italic22 = terminalStyles22.italic;
-var underline22 = terminalStyles22.underline;
-var strikethrough2 = terminalStyles22.strikethrough;
-var reset22 = terminalStyles22.reset;
-var defaultFingersCrossedConfig22 = {
-  activationLevel: "error",
-  bufferSize: 50,
-  flushOnDeactivation: true,
-  stopBuffering: false
-};
-var levelIcons22 = {
-  debug: "\uD83D\uDD0D",
-  info: blue22("\u2139"),
-  success: green22("\u2713"),
-  warning: bgYellow22(white22(bold22(" WARN "))),
-  error: bgRed22(white22(bold22(" ERROR ")))
-};
-
-class Logger22 {
-  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 = { ...config22 };
-    this.options = this.normalizeOptions(options);
-    this.formatter = this.options.formatter || new JsonFormatter22;
-    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 {
-        ...defaultFingersCrossedConfig22,
-        ...options.fingersCrossed
-      };
-    }
-    if (!options.fingersCrossedEnabled) {
-      return null;
-    }
-    if (!options.fingersCrossed) {
-      return { ...defaultFingersCrossedConfig22 };
-    }
-    return {
-      ...defaultFingersCrossedConfig22,
-      ...options.fingersCrossed
-    };
-  }
-  normalizeOptions(options) {
-    const defaultOptions = {
-      format: "json",
-      level: "info",
-      logDirectory: config22.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 !isBrowserProcess22() && 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 access22(this.config.logDirectory, constants22.F_OK | constants22.W_OK);
-            } catch (err) {
-              if (err instanceof Error && "code" in err) {
-                if (err.code === "ENOENT") {
-                  await mkdir22(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 : Buffer22.from(data);
-          try {
-            if (!existsSync42(this.currentLogFile)) {
-              await writeFile22(this.currentLogFile, "", { mode: 420 });
-            }
-            fd = openSync22(this.currentLogFile, "a", 420);
-            writeFileSync42(fd, dataToWrite, { flag: "a" });
-            fsyncSync22(fd);
-            if (fd !== undefined) {
-              closeSync22(fd);
-              fd = undefined;
-            }
-            const stats = await stat22(this.currentLogFile);
-            if (stats.size === 0) {
-              await writeFile22(this.currentLogFile, dataToWrite, { flag: "w", mode: 420 });
-              const retryStats = await stat22(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((resolve522) => setTimeout(resolve522, 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 {
-                closeSync22(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((resolve522) => setTimeout(resolve522, 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 (isBrowserProcess22())
-      return;
-    if (!this.shouldWriteToFile())
-      return;
-    if (typeof this.config.rotation === "boolean")
-      return;
-    const config32 = this.config.rotation;
-    let interval;
-    switch (config32.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 randomBytes22(16).toString("hex");
-  }
-  generateKey() {
-    return randomBytes22(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 = randomBytes22(16);
-    const cipher = createCipheriv22("aes-256-gcm", key, iv);
-    const input = Buffer22.isBuffer(data) ? data : Buffer22.from(data, "utf8");
-    const part1 = cipher.update(input);
-    const part2 = cipher.final();
-    const totalCipherLen = part1.length + part2.length;
-    const authTag = cipher.getAuthTag();
-    const out = Buffer22.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((resolve522, reject) => {
-      const gzip = createGzip22();
-      const chunks = [];
-      gzip.on("data", (chunk2) => chunks.push(chunk2));
-      gzip.on("end", () => resolve522(Buffer22.from(Buffer22.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 (isBrowserProcess22())
-      return;
-    if (!this.shouldWriteToFile())
-      return;
-    const stats = await stat22(this.currentLogFile).catch(() => null);
-    if (!stats)
-      return;
-    const config32 = this.config.rotation;
-    if (typeof config32 === "boolean")
-      return;
-    if (config32.maxSize && stats.size >= config32.maxSize) {
-      const oldFile = this.currentLogFile;
-      const newFile = this.generateLogFilename();
-      if (this.name.includes("rotation-load-test") || this.name === "failed-rotation-test") {
-        const files = await readdir22(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 stat22(oldFile).catch(() => null)) {
-          try {
-            await rename22(oldFile, rotatedFile);
-            if (config32.compress) {
-              try {
-                const compressedPath = `${rotatedFile}.gz`;
-                await this.compressLogFile(rotatedFile, compressedPath);
-                await unlink22(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 writeFile22(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 stat22(oldFile).catch(() => null)) {
-          await rename22(oldFile, rotatedFile);
-        }
-      }
-      this.currentLogFile = newFile;
-      if (config32.maxFiles) {
-        const files = await readdir22(this.config.logDirectory);
-        const logFiles = files.filter((f) => f.startsWith(this.name)).sort((a, b) => b.localeCompare(a));
-        for (const file of logFiles.slice(config32.maxFiles)) {
-          await unlink22(join5(this.config.logDirectory, file));
-        }
-      }
-    }
-  }
-  async compressLogFile(inputPath, outputPath) {
-    const readStream = createReadStream22(inputPath);
-    const writeStream = createWriteStream22(outputPath);
-    const gzip = createGzip22();
-    await pipeline22(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 (existsSync42(this.currentLogFile)) {
-      try {
-        const fd = openSync22(this.currentLogFile, "r+");
-        fsyncSync22(fd);
-        closeSync22(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 (!isBrowserProcess22() && this.config.rotation && typeof this.config.rotation !== "boolean" && this.config.rotation.compress) {
-        try {
-          const files = await readdir22(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 unlink22(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() ? styles22.gray(date.toLocaleTimeString()) : date.toLocaleTimeString();
-  }
-  shouldStyleConsole() {
-    if (!this.fancy || isBrowserProcess22())
-      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} ${styles22.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 = styles22.underline(styles22.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) => styles22.bgGray(m));
-    out = out.replace(/\*\*([^*]+)\*\*/g, (_, m) => styles22.bold(m));
-    out = out.replace(/(?<!\*)\*([^*]+)\*(?!\*)/g, (_, m) => styles22.italic(m));
-    out = out.replace(/(?<!_)_([^_]+)_(?!_)/g, (_, m) => styles22.italic(m));
-    out = out.replace(/~([^~]+)~/g, (_, m) => styles22.strikethrough(m));
-    return out;
-  }
-  supportsHyperlinks() {
-    if (isBrowserProcess22())
-      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 (isAbsolute2(p) || p.startsWith("./") || p.startsWith("../")) {
-        p = resolve62(p);
-      } else {
-        return null;
-      }
-      return existsSync42(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 ? "" : levelIcons22[level];
-      const tag = this.options.showTags !== false && this.name ? styles22.gray(this.formatTag(this.name)) : "";
-      let consoleMessage;
-      switch (level) {
-        case "debug":
-          consoleMessage = this.formatConsoleMessage({
-            timestamp: consoleTime,
-            icon,
-            tag,
-            message: styles22.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: styles22.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: styles22.gray(`  ${line}`),
-                  level,
-                  showTimestamp: false
-                }));
-              }
-            }
-          }
-          break;
-      }
-    } else if (!isBrowserProcess22()) {
-      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() && !isBrowserProcess22() && 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() && !isBrowserProcess22() && 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 (!isBrowserProcess22() && process11.stdout.isTTY)
-        process11.stdout.write(`
-`);
-      const method = level === "warning" ? "warn" : level;
-      this[method](message);
-      if (this.activeProgressBar && this.shouldStyleConsole() && !isBrowserProcess22() && 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 ? styles22.gray(this.formatTag(this.name)) : "";
-      const consoleTime = this.formatConsoleTimestamp(new Date);
-      console.error(this.formatConsoleMessage({
-        timestamp: consoleTime,
-        icon: this.options.showIcons === false ? "" : styles22.blue("\u25D0"),
-        tag,
-        message: `${styles22.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 ? styles22.gray(this.formatTag(this.name)) : "";
-        console.error(this.formatConsoleMessage({
-          timestamp: consoleTime,
-          icon: this.options.showIcons === false ? "" : styles22.green("\u2713"),
-          tag,
-          message: `${completionMessage}${metadata ? ` ${JSON.stringify(metadata)}` : ""}`
-        }));
-      } else if (!isBrowserProcess22()) {
-        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 Logger22(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 (isBrowserProcess22())
-      throw new Error("createReadStream is not supported in browser environments");
-    if (!existsSync42(this.currentLogFile))
-      throw new Error(`Log file does not exist: ${this.currentLogFile}`);
-    return createReadStream22(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 = Buffer22.isBuffer(data) ? data : Buffer22.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 = createDecipheriv22("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 = Buffer22.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 isBrowserProcess22();
-  }
-  isServerMode() {
-    return !isBrowserProcess22();
-  }
-  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: styles22.cyan(line),
-          showTimestamp: false
-        });
-      });
-      console.error(this.formatConsoleMessage({
-        timestamp: consoleTime,
-        message: styles22.cyan(top),
-        showTimestamp: false
-      }));
-      boxedLines.forEach((line) => console.error(line));
-      console.error(this.formatConsoleMessage({
-        timestamp: consoleTime,
-        message: styles22.cyan(bottom),
-        showTimestamp: false
-      }));
-    } else if (!isBrowserProcess22()) {
-      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 (isBrowserProcess22()) {
-      return Promise.resolve(true);
-    }
-    return new Promise((resolve522) => {
-      console.error(`${styles22.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("");
-        resolve522(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;
-        }
+  };
+  PluginError2 = class PluginError22 extends BunfigError2 {
+    code = "PLUGIN_ERROR";
+    constructor(pluginName, operation, cause) {
+      super(`Plugin "${pluginName}" failed during ${operation}: ${cause.message}`, {
+        pluginName,
+        operation,
+        originalError: cause.name,
+        originalMessage: cause.message
       });
-      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 ? styles22.gray(this.formatTag(this.name)) : "";
-      const spinnerPrefix = this.options.showIcons === false ? "" : `${styles22.blue("\u25D0")} `;
-      console.error(`${spinnerPrefix}${tag} ${styles22.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 = styles22.green("\u2501".repeat(filledLength));
-    const emptyBar = styles22.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 ? styles22.green("\u2713") : styles22.blue("\u25B6");
-    const tag = this.options.showTags !== false && this.name ? ` ${styles22.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 || isBrowserProcess22() || !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 (isBrowserProcess22()) {
-      console.warn("Log clearing is not supported in browser environments.");
-      return;
-    }
-    try {
-      console.warn("Clearing logs...", this.config.logDirectory);
-      const files = await readdir22(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 stat22(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 unlink22(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 logger22 = new Logger22("stacks");
-
-class BunfigError2 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 ConfigNotFoundError2 extends BunfigError2 {
-  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 ConfigLoadError2 extends BunfigError2 {
-  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 ConfigValidationError2 extends BunfigError2 {
-  code = "CONFIG_VALIDATION_ERROR";
-  constructor(configPath, validationErrors, configName) {
-    super(`Configuration validation failed for "${configPath}"`, {
-      configPath,
-      configName,
-      validationErrors,
-      errorCount: validationErrors.length
-    });
-  }
-}
-
-class ConfigMergeError2 extends BunfigError2 {
-  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 EnvVarError2 extends BunfigError2 {
-  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 FileSystemError2 extends BunfigError2 {
-  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 TypeGenerationError2 extends BunfigError2 {
-  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 SchemaValidationError2 extends BunfigError2 {
-  code = "SCHEMA_VALIDATION_ERROR";
-  constructor(schemaPath, validationErrors, configName) {
-    super(`Schema validation failed${configName ? ` for config "${configName}"` : ""}`, {
-      schemaPath,
-      configName,
-      validationErrors,
-      errorCount: validationErrors.length
-    });
-  }
-}
-
-class BrowserConfigError2 extends BunfigError2 {
-  code = "BROWSER_CONFIG_ERROR";
-  constructor(endpoint, status, statusText, configName) {
-    super(`Failed to fetch configuration from "${endpoint}": ${status} ${statusText}`, {
-      endpoint,
-      status,
-      statusText,
-      configName
-    });
-  }
-}
-
-class PluginError2 extends BunfigError2 {
-  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 ErrorFactory2 = {
-  configNotFound(configName, searchPaths, alias) {
-    return new ConfigNotFoundError2(configName, searchPaths, alias);
-  },
-  configLoad(configPath, cause, configName) {
-    return new ConfigLoadError2(configPath, cause, configName);
-  },
-  configValidation(configPath, errors, configName) {
-    return new ConfigValidationError2(configPath, errors, configName);
-  },
-  configMerge(sourcePath, targetPath, cause, configName) {
-    return new ConfigMergeError2(sourcePath, targetPath, cause, configName);
-  },
-  envVar(envKey, envValue, expectedType, configName) {
-    return new EnvVarError2(envKey, envValue, expectedType, configName);
-  },
-  fileSystem(operation, path, cause) {
-    return new FileSystemError2(operation, path, cause);
-  },
-  typeGeneration(configDir, outputPath, cause) {
-    return new TypeGenerationError2(configDir, outputPath, cause);
-  },
-  schemaValidation(schemaPath, errors, configName) {
-    return new SchemaValidationError2(schemaPath, errors, configName);
-  },
-  browserConfig(endpoint, status, statusText, configName) {
-    return new BrowserConfigError2(endpoint, status, statusText, configName);
-  },
-  plugin(pluginName, operation, cause) {
-    return new PluginError2(pluginName, operation, cause);
-  }
-};
-async function withErrorRecovery2(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((resolve522) => setTimeout(resolve522, retryDelay));
-      }
+      this.cause = cause;
     }
-  }
-  if (fallback !== undefined) {
-    return fallback;
-  }
-  throw lastError instanceof Error ? lastError : new Error(`Unknown error: ${String(lastError)}`);
-}
+  };
+  ErrorFactory2 = {
+    configNotFound(configName, searchPaths, alias) {
+      return new ConfigNotFoundError2(configName, searchPaths, alias);
+    },
+    configLoad(configPath, cause, configName) {
+      return new ConfigLoadError2(configPath, cause, configName);
+    },
+    configValidation(configPath, errors, configName) {
+      return new ConfigValidationError2(configPath, errors, configName);
+    },
+    configMerge(sourcePath, targetPath, cause, configName) {
+      return new ConfigMergeError2(sourcePath, targetPath, cause, configName);
+    },
+    envVar(envKey, envValue, expectedType, configName) {
+      return new EnvVarError2(envKey, envValue, expectedType, configName);
+    },
+    fileSystem(operation, path, cause) {
+      return new FileSystemError2(operation, path, cause);
+    },
+    typeGeneration(configDir, outputPath, cause) {
+      return new TypeGenerationError2(configDir, outputPath, cause);
+    },
+    schemaValidation(schemaPath, errors, configName) {
+      return new SchemaValidationError2(schemaPath, errors, configName);
+    },
+    browserConfig(endpoint, status, statusText, configName) {
+      return new BrowserConfigError2(endpoint, status, statusText, configName);
+    },
+    plugin(pluginName, operation, cause) {
+      return new PluginError2(pluginName, operation, cause);
+    }
+  };
+});
 
 class EnvProcessor2 {
   defaultParsers;
@@ -7958,7 +6232,7 @@ class EnvProcessor2 {
       }
     ];
   }
-  async applyEnvironmentVariables(configName, config32, options = {}) {
+  async applyEnvironmentVariables(configName, config22, options = {}) {
     const {
       prefix,
       useCamelCase = true,
@@ -7970,12 +6244,12 @@ class EnvProcessor2 {
     const operation = async () => {
       if (!configName) {
         return {
-          config: config32,
+          config: config22,
           source: { type: "environment", priority: 50, timestamp: new Date }
         };
       }
       const envPrefix = prefix || this.generateEnvPrefix(configName);
-      const result = { ...config32 };
+      const result = { ...config22 };
       this.processObject(result, [], envPrefix, {
         useCamelCase,
         useBackwardCompatibility,
@@ -8014,10 +6288,10 @@ class EnvProcessor2 {
       if (typeof value === "object" && value !== null && !Array.isArray(value)) {
         this.processObject(value, envPath, envPrefix, options);
       } else {
-        const envValue = process82.env[envKey] || (oldEnvKey ? process82.env[oldEnvKey] : undefined);
+        const envValue = process52.env[envKey] || (oldEnvKey ? process52.env[oldEnvKey] : undefined);
         if (envValue !== undefined) {
           if (options.verbose) {
-            const _usedKey = process82.env[envKey] ? envKey : oldEnvKey;
+            const _usedKey = process52.env[envKey] ? envKey : oldEnvKey;
           }
           try {
             obj[key] = this.parseEnvironmentValue(envValue, typeof value, envKey, options.customParsers, options.configName);
@@ -8053,7 +6327,7 @@ class EnvProcessor2 {
   getEnvironmentVariables(prefix) {
     const envVars = {};
     const upperPrefix = prefix.toUpperCase();
-    for (const [key, value] of Object.entries(process82.env)) {
+    for (const [key, value] of Object.entries(process52.env)) {
       if (key.startsWith(upperPrefix) && value !== undefined) {
         envVars[key] = value;
       }
@@ -8077,11 +6351,11 @@ class EnvProcessor2 {
       errors
     };
   }
-  generateEnvVarDocs(configName, defaultConfig32, options = {}) {
+  generateEnvVarDocs(configName, defaultConfig22, options = {}) {
     const { prefix, format = "text" } = options;
     const envPrefix = prefix || this.generateEnvPrefix(configName);
     const envVars = [];
-    this.extractEnvVarInfo(defaultConfig32, [], envPrefix, envVars);
+    this.extractEnvVarInfo(defaultConfig22, [], envPrefix, envVars);
     switch (format) {
       case "markdown":
         return this.formatAsMarkdown(envVars, configName);
@@ -8148,7 +6422,18 @@ class EnvProcessor2 {
     return result;
   }
 }
-function deepMerge3(target, source, options = {}) {
+var init_env_processor2 = __esm2(() => {
+  init_cache2();
+  init_errors2();
+});
+function getEnvOrDefault2(key, defaultValue) {
+  const process62 = __require22("process");
+  if (typeof process62 === "undefined" || !process62.env)
+    return defaultValue;
+  const envValue = process62.env[key];
+  return envValue !== undefined ? envValue : defaultValue;
+}
+function deepMerge2(target, source, options = {}) {
   const visited = new WeakMap;
   return deepMergeWithVisited2(target, source, options, visited);
 }
@@ -8170,7 +6455,7 @@ function deepMergeWithVisited2(target, source, options, visited) {
   if (Array.isArray(source) || Array.isArray(target)) {
     return mergeArraysWithVisited2(target, source, arrayMergeMode, visited);
   }
-  if (!isObject3(source) || !isObject3(target)) {
+  if (!isObject2(source) || !isObject2(target)) {
     return source;
   }
   return mergeObjectsWithVisited2(target, source, options, visited);
@@ -8199,7 +6484,7 @@ function mergeArraysWithVisited2(target, source, mode, visited) {
 function concatArraysWithDedup2(target, source) {
   const result = [...source];
   for (const item of target) {
-    if (!result.some((existingItem) => deepEquals3(existingItem, item))) {
+    if (!result.some((existingItem) => deepEquals2(existingItem, item))) {
       result.push(item);
     }
   }
@@ -8210,7 +6495,7 @@ function smartMergeArraysWithVisited2(target, source, visited) {
     return target;
   if (target.length === 0)
     return source;
-  if (isObject3(source[0]) && isObject3(target[0])) {
+  if (isObject2(source[0]) && isObject2(target[0])) {
     return mergeObjectArraysWithVisited2(target, source, visited);
   }
   if (source.every((item) => typeof item === "string") && target.every((item) => typeof item === "string")) {
@@ -8227,7 +6512,7 @@ function smartMergeArraysWithVisited2(target, source, visited) {
 function mergeObjectArraysWithVisited2(target, source, _visited) {
   const result = [...source];
   for (const targetItem of target) {
-    if (!isObject3(targetItem)) {
+    if (!isObject2(targetItem)) {
       result.push(targetItem);
       continue;
     }
@@ -8235,7 +6520,7 @@ function mergeObjectArraysWithVisited2(target, source, _visited) {
     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]);
+        const existingItem = result.find((item) => isObject2(item) && (key in item) && item[key] === targetItem[key]);
         if (existingItem) {
           hasMatch = true;
           break;
@@ -8250,11 +6535,11 @@ function mergeObjectArraysWithVisited2(target, source, _visited) {
 }
 function mergeObjectsWithVisited2(target, source, options, visited) {
   const sourceObj = source;
-  if (isObject3(sourceObj) && visited.has(sourceObj)) {
+  if (isObject2(sourceObj) && visited.has(sourceObj)) {
     return visited.get(sourceObj);
   }
   const merged = { ...target };
-  if (isObject3(sourceObj)) {
+  if (isObject2(sourceObj)) {
     visited.set(sourceObj, merged);
   }
   for (const key in sourceObj) {
@@ -8270,7 +6555,7 @@ function mergeObjectsWithVisited2(target, source, options, visited) {
       merged[key] = sourceValue;
       continue;
     }
-    if (isObject3(sourceValue) && isObject3(targetValue)) {
+    if (isObject2(sourceValue) && isObject2(targetValue)) {
       merged[key] = deepMergeWithVisited2(targetValue, sourceValue, options, visited);
     } else if (Array.isArray(sourceValue) || Array.isArray(targetValue)) {
       merged[key] = mergeArraysWithVisited2(targetValue, sourceValue, options.arrayMergeMode || "smart", visited);
@@ -8280,26 +6565,26 @@ function mergeObjectsWithVisited2(target, source, options, visited) {
   }
   return merged;
 }
-function deepMergeWithArrayStrategy22(target, source, strategy = "replace") {
+function deepMergeWithArrayStrategy2(target, source, strategy = "replace") {
   const arrayMergeMode = strategy === "replace" ? "replace" : "smart";
-  return deepMerge3(target, source, {
+  return deepMerge2(target, source, {
     arrayMergeMode,
     skipNullish: true
   });
 }
-function deepEquals3(a, b) {
+function deepEquals2(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]))
+      if (!deepEquals2(a[i], b[i]))
         return false;
     }
     return true;
   }
-  if (isObject3(a) && isObject3(b)) {
+  if (isObject2(a) && isObject2(b)) {
     const keysA = Object.keys(a);
     const keysB = Object.keys(b);
     if (keysA.length !== keysB.length)
@@ -8307,20 +6592,28 @@ function deepEquals3(a, b) {
     for (const key of keysA) {
       if (!Object.prototype.hasOwnProperty.call(b, key))
         return false;
-      if (!deepEquals3(a[key], b[key]))
+      if (!deepEquals2(a[key], b[key]))
         return false;
     }
     return true;
   }
   return false;
 }
-function isObject3(item) {
+function isObject2(item) {
   return Boolean(item && typeof item === "object" && !Array.isArray(item));
 }
+var ArrayMergeStrategies2;
+var init_utils2 = __esm2(() => {
+  ArrayMergeStrategies2 = {
+    replace: "replace",
+    concat: "concat",
+    smart: "smart"
+  };
+});
 
 class ConfigFileLoader2 {
   extensions = [".ts", ".js", ".mjs", ".cjs", ".json", ".mts", ".cts"];
-  async loadFromPath(configPath, defaultConfig32, options = {}) {
+  async loadFromPath(configPath, defaultConfig22, options = {}) {
     const {
       arrayStrategy = "replace",
       useCache = true,
@@ -8338,7 +6631,7 @@ class ConfigFileLoader2 {
       }
     }
     const loadOperation = async () => {
-      if (!existsSync52(configPath)) {
+      if (!existsSync32(configPath)) {
         return null;
       }
       try {
@@ -8353,7 +6646,7 @@ class ConfigFileLoader2 {
         if (typeof loadedConfig !== "object" || loadedConfig === null || Array.isArray(loadedConfig)) {
           throw new ConfigLoadError2(configPath, new Error("Configuration must export a valid object"), "unknown");
         }
-        const mergedConfig = deepMergeWithArrayStrategy22(defaultConfig32, loadedConfig, arrayStrategy);
+        const mergedConfig = deepMergeWithArrayStrategy2(defaultConfig22, loadedConfig, arrayStrategy);
         const source = {
           type: "file",
           path: configPath,
@@ -8375,10 +6668,10 @@ class ConfigFileLoader2 {
     }
     return loadOperation();
   }
-  async tryLoadFromPaths(configPaths, defaultConfig32, options = {}) {
+  async tryLoadFromPaths(configPaths, defaultConfig22, options = {}) {
     for (const configPath of configPaths) {
       try {
-        const result = await this.loadFromPath(configPath, defaultConfig32, options);
+        const result = await this.loadFromPath(configPath, defaultConfig22, options);
         if (result) {
           return result;
         }
@@ -8398,7 +6691,7 @@ class ConfigFileLoader2 {
     const paths = [];
     for (const pattern of patterns) {
       for (const ext of this.extensions) {
-        paths.push(resolve52(directory, `${pattern}${ext}`));
+        paths.push(resolve32(directory, `${pattern}${ext}`));
       }
     }
     return paths;
@@ -8409,17 +6702,26 @@ class ConfigFileLoader2 {
     if (configName) {
       patterns.push(configName, `.${configName}.config`, `${configName}.config`, `.${configName}`);
     }
-    if (alias) {
-      patterns.push(alias, `.${alias}.config`, `${alias}.config`, `.${alias}`);
+    const aliases = alias === undefined ? [] : Array.isArray(alias) ? alias : [alias];
+    for (const a of aliases) {
+      if (!a)
+        continue;
+      patterns.push(a, `.${a}.config`, `${a}.config`, `.${a}`);
       if (configName) {
-        patterns.push(`${configName}.${alias}.config`, `.${configName}.${alias}.config`);
+        patterns.push(`${configName}.${a}.config`, `.${configName}.${a}.config`);
       }
     }
-    return patterns.filter(Boolean);
+    const seen = new Set;
+    return patterns.filter((p) => {
+      if (!p || seen.has(p))
+        return false;
+      seen.add(p);
+      return true;
+    });
   }
   checkFileAccess(filePath) {
     return withErrorRecovery2(async () => {
-      return existsSync52(filePath);
+      return existsSync32(filePath);
     }, {
       maxRetries: 2,
       retryDelay: 100,
@@ -8428,14 +6730,14 @@ class ConfigFileLoader2 {
   }
   async discoverConfigFiles(directory, configName, alias) {
     const discoveredFiles = [];
-    if (!existsSync52(directory)) {
+    if (!existsSync32(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 = resolve52(directory, `${pattern}${ext}`);
+          const filePath = resolve32(directory, `${pattern}${ext}`);
           if (await this.checkFileAccess(filePath)) {
             discoveredFiles.push(filePath);
           }
@@ -8447,7 +6749,7 @@ class ConfigFileLoader2 {
         const files = readdirSync32(directory);
         for (const file of files) {
           if (this.looksLikeConfigFile(file)) {
-            const filePath = resolve52(directory, file);
+            const filePath = resolve32(directory, file);
             if (await this.checkFileAccess(filePath)) {
               discoveredFiles.push(filePath);
             }
@@ -8470,23 +6772,23 @@ class ConfigFileLoader2 {
   async validateConfigFile(filePath) {
     const errors = [];
     try {
-      if (!existsSync52(filePath)) {
+      if (!existsSync32(filePath)) {
         errors.push("Configuration file does not exist");
         return errors;
       }
       const imported = await import(filePath);
-      const config32 = imported.default || imported;
-      if (config32 === undefined) {
+      const config22 = imported.default || imported;
+      if (config22 === undefined) {
         errors.push("Configuration file must export a default value or named exports");
-      } else if (typeof config32 !== "object" || config32 === null) {
+      } else if (typeof config22 !== "object" || config22 === null) {
         errors.push("Configuration must be an object");
-      } else if (Array.isArray(config32)) {
+      } else if (Array.isArray(config22)) {
         errors.push("Configuration cannot be an array at the root level");
       }
       if (filePath.endsWith(".json")) {
         try {
-          const { readFileSync: readFileSync2 } = await import("fs");
-          const content = readFileSync2(filePath, "utf8");
+          const { readFileSync: readFileSync22 } = await import("fs");
+          const content = readFileSync22(filePath, "utf8");
           JSON.parse(content);
         } catch (jsonError) {
           errors.push(`Invalid JSON syntax: ${jsonError}`);
@@ -8523,10 +6825,14 @@ class ConfigFileLoader2 {
     return preloaded;
   }
 }
-var URL_PATTERN2 = /^https?:\/\//;
+var init_file_loader2 = __esm2(() => {
+  init_cache2();
+  init_errors2();
+  init_utils2();
+});
 
 class ConfigValidator2 {
-  async validateConfiguration(config32, schema, options = {}) {
+  async validateConfiguration(config22, schema, options = {}) {
     const {
       stopOnFirstError = false,
       validateRequired = true,
@@ -8548,11 +6854,11 @@ class ConfigValidator2 {
       };
       try {
         if (typeof schema === "string") {
-          return await this.validateWithSchemaFile(config32, schema, resolvedOptions);
+          return await this.validateWithSchemaFile(config22, schema, resolvedOptions);
         } else if (Array.isArray(schema)) {
-          return this.validateWithRules(config32, [...schema, ...customRules], resolvedOptions);
+          return this.validateWithRules(config22, [...schema, ...customRules], resolvedOptions);
         } else {
-          return this.validateWithJSONSchema(config32, schema, resolvedOptions);
+          return this.validateWithJSONSchema(config22, schema, resolvedOptions);
         }
       } catch (error) {
         errors.push({
@@ -8569,26 +6875,26 @@ class ConfigValidator2 {
     }
     return operation();
   }
-  async validateWithSchemaFile(config32, schemaPath, options) {
+  async validateWithSchemaFile(config22, schemaPath, options) {
     try {
-      if (!existsSync72(schemaPath)) {
+      if (!existsSync42(schemaPath)) {
         throw new SchemaValidationError2(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(config32, schema, options);
+        return this.validateWithRules(config22, schema, options);
       } else {
-        return this.validateWithJSONSchema(config32, schema, options);
+        return this.validateWithJSONSchema(config22, schema, options);
       }
     } catch (error) {
       throw new SchemaValidationError2(schemaPath, [{ path: "", message: `Failed to load schema: ${error}` }]);
     }
   }
-  validateWithJSONSchema(config32, schema, options) {
+  validateWithJSONSchema(config22, schema, options) {
     const errors = [];
     const warnings = [];
-    this.validateObjectAgainstSchema(config32, schema, "", errors, warnings, options);
+    this.validateObjectAgainstSchema(config22, schema, "", errors, warnings, options);
     return {
       isValid: errors.length === 0,
       errors,
@@ -8722,12 +7028,12 @@ class ConfigValidator2 {
       }
     }
   }
-  validateWithRules(config32, rules, options) {
+  validateWithRules(config22, rules, options) {
     const errors = [];
     const warnings = [];
     for (const rule of rules) {
       try {
-        const value = this.getValueByPath(config32, rule.path);
+        const value = this.getValueByPath(config22, rule.path);
         const ruleErrors = this.validateWithRule(value, rule, rule.path);
         errors.push(...ruleErrors);
         if (options.stopOnFirstError && errors.length > 0) {
@@ -8892,9 +7198,22 @@ class ConfigValidator2 {
     };
   }
 }
-var log22 = new Logger22("bunfig", {
-  showTags: true
+var URL_PATTERN2;
+var init_validator2 = __esm2(() => {
+  init_cache2();
+  init_errors2();
+  URL_PATTERN2 = /^https?:\/\//;
 });
+function formatAliasSuffix2(alias) {
+  if (!alias)
+    return "";
+  const list = Array.isArray(alias) ? alias.filter(Boolean) : [alias];
+  if (list.length === 0)
+    return "";
+  if (list.length === 1)
+    return ` or alias "${list[0]}"`;
+  return ` or aliases ${list.map((a) => `"${a}"`).join(", ")}`;
+}
 
 class ConfigLoader2 {
   fileLoader = new ConfigFileLoader2;
@@ -8977,14 +7296,14 @@ class ConfigLoader2 {
           performance2.onMetrics(metrics);
         }
         if (performance2.slowThreshold && metrics.duration > performance2.slowThreshold) {
-          log22.warn(`Slow configuration loading detected: ${metrics.duration}ms for ${baseOptions.name}`);
+          log2.warn(`Slow configuration loading detected: ${metrics.duration}ms for ${baseOptions.name}`);
         }
         result.metrics = metrics;
       }
       return result;
     } catch (error) {
       const duration = Date.now() - startTime;
-      log22.error(`Configuration loading failed after ${duration}ms:`, [error instanceof Error ? error : new Error(String(error))]);
+      log2.error(`Configuration loading failed after ${duration}ms:`, [error instanceof Error ? error : new Error(String(error))]);
       throw error;
     }
   }
@@ -8994,44 +7313,44 @@ class ConfigLoader2 {
       alias,
       cwd,
       configDir,
-      defaultConfig: defaultConfig32,
+      defaultConfig: defaultConfig22,
       checkEnv = true,
       arrayStrategy = "replace",
       verbose = false
     } = options;
-    const baseDir = cwd || process12.cwd();
+    const baseDir = cwd || process72.cwd();
     const searchPaths = [];
-    const localResult = await this.loadLocalConfiguration(name, alias, baseDir, configDir, defaultConfig32, arrayStrategy, verbose, checkEnv, cacheOptions);
+    const localResult = await this.loadLocalConfiguration(name, alias, baseDir, configDir, defaultConfig22, 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, defaultConfig32, arrayStrategy, verbose, checkEnv);
+    const homeResult = await this.loadHomeConfiguration(name, alias, defaultConfig22, 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, defaultConfig32, arrayStrategy, verbose, checkEnv);
+    const packageResult = await this.loadPackageJsonConfiguration(name, alias, baseDir, defaultConfig22, arrayStrategy, verbose, checkEnv);
     if (packageResult) {
-      searchPaths.push(resolve7(baseDir, "package.json"));
+      searchPaths.push(resolve52(baseDir, "package.json"));
       return this.finalizeResult(packageResult, searchPaths, checkEnv, name, verbose);
     }
     searchPaths.push(...this.getAllSearchPaths(name, alias, baseDir, configDir));
     if (throwOnNotFound) {
       throw ErrorFactory2.configNotFound(name, searchPaths, alias);
     }
-    const envResult = await this.applyEnvironmentVariables(name, defaultConfig32, checkEnv, verbose);
+    const envResult = await this.applyEnvironmentVariables(name, defaultConfig22, checkEnv, verbose);
     return {
       ...envResult,
-      warnings: [`No configuration file found for "${name}"${alias ? ` or alias "${alias}"` : ""}, using defaults with environment variables`]
+      warnings: [`No configuration file found for "${name}"${formatAliasSuffix2(alias)}, using defaults with environment variables`]
     };
   }
-  async loadLocalConfiguration(name, alias, baseDir, configDir, defaultConfig32, arrayStrategy, verbose, checkEnv, cacheOptions) {
-    const envDefaultConfig = checkEnv ? applyEnvVarsToConfig22(name, defaultConfig32, verbose) : defaultConfig32;
+  async loadLocalConfiguration(name, alias, baseDir, configDir, defaultConfig22, arrayStrategy, verbose, checkEnv, cacheOptions) {
+    const envDefaultConfig = checkEnv ? applyEnvVarsToConfig2(name, defaultConfig22, verbose) : defaultConfig22;
     const searchDirectories = this.getLocalDirectories(baseDir, configDir);
     for (const directory of searchDirectories) {
       if (verbose) {
-        log22.info(`Searching for configuration in: ${directory}`);
+        log2.info(`Searching for configuration in: ${directory}`);
       }
       const configPaths = this.fileLoader.generateConfigPaths(name, directory, alias);
       const result = await this.fileLoader.tryLoadFromPaths(configPaths, envDefaultConfig, {
@@ -9042,56 +7361,72 @@ class ConfigLoader2 {
       });
       if (result) {
         if (verbose) {
-          log22.success(`Configuration loaded from: ${result.source.path}`);
+          log2.success(`Configuration loaded from: ${result.source.path}`);
         }
         return result;
       }
     }
     return null;
   }
-  async loadHomeConfiguration(name, alias, defaultConfig32, arrayStrategy, verbose, checkEnv) {
+  async loadHomeConfiguration(name, alias, defaultConfig22, arrayStrategy, verbose, checkEnv) {
     if (!name)
       return null;
-    const envDefaultConfig = checkEnv ? applyEnvVarsToConfig22(name, defaultConfig32, verbose) : defaultConfig32;
+    const envDefaultConfig = checkEnv ? applyEnvVarsToConfig2(name, defaultConfig22, verbose) : defaultConfig22;
     const homeDirectories = [
-      resolve7(homedir2(), ".config", name),
-      resolve7(homedir2(), ".config"),
+      resolve52(homedir2(), ".config", name),
+      resolve52(homedir2(), ".config"),
       homedir2()
     ];
     for (const directory of homeDirectories) {
       if (verbose) {
-        log22.info(`Checking home directory: ${directory}`);
+        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) {
-          log22.success(`Configuration loaded from home directory: ${result.source.path}`);
+          log2.success(`Configuration loaded from home directory: ${result.source.path}`);
         }
         return result;
       }
     }
     return null;
   }
-  async loadPackageJsonConfiguration(name, alias, baseDir, defaultConfig32, arrayStrategy, verbose, checkEnv) {
-    const envDefaultConfig = checkEnv ? applyEnvVarsToConfig22(name, defaultConfig32, verbose) : defaultConfig32;
+  async loadPackageJsonConfiguration(name, alias, baseDir, defaultConfig22, arrayStrategy, verbose, checkEnv) {
+    const envDefaultConfig = checkEnv ? applyEnvVarsToConfig2(name, defaultConfig22, verbose) : defaultConfig22;
     try {
-      const pkgPath = resolve7(baseDir, "package.json");
-      if (!existsSync8(pkgPath)) {
+      const pkgPath = resolve52(baseDir, "package.json");
+      if (!existsSync52(pkgPath)) {
+        return null;
+      }
+      let pkg = {};
+      try {
+        pkg = JSON.parse(readFileSync2(pkgPath, "utf8"));
+      } catch (parseError) {
+        if (verbose) {
+          log2.warn(`Failed to parse package.json:`, [parseError instanceof Error ? parseError : new Error(String(parseError))]);
+        }
         return null;
       }
-      const pkg = await import(pkgPath);
       let pkgConfig = pkg[name];
       let usedName = name;
       if (!pkgConfig && alias) {
-        pkgConfig = pkg[alias];
-        usedName = alias;
+        const aliases = Array.isArray(alias) ? alias : [alias];
+        for (const a of aliases) {
+          if (!a)
+            continue;
+          if (pkg[a]) {
+            pkgConfig = pkg[a];
+            usedName = a;
+            break;
+          }
+        }
       }
       if (pkgConfig && typeof pkgConfig === "object" && !Array.isArray(pkgConfig)) {
         if (verbose) {
-          log22.success(`Configuration loaded from package.json: ${usedName}`);
+          log2.success(`Configuration loaded from package.json: ${usedName}`);
         }
-        const mergedConfig = deepMergeWithArrayStrategy22(envDefaultConfig, pkgConfig, arrayStrategy);
+        const mergedConfig = deepMergeWithArrayStrategy2(envDefaultConfig, pkgConfig, arrayStrategy);
         return {
           config: mergedConfig,
           source: {
@@ -9104,15 +7439,15 @@ class ConfigLoader2 {
       }
     } catch (error) {
       if (verbose) {
-        log22.warn(`Failed to load package.json:`, [error instanceof Error ? error : new Error(String(error))]);
+        log2.warn(`Failed to load package.json:`, [error instanceof Error ? error : new Error(String(error))]);
       }
     }
     return null;
   }
-  async applyEnvironmentVariables(name, config32, checkEnv, verbose) {
-    if (!checkEnv || !name || typeof config32 !== "object" || config32 === null || Array.isArray(config32)) {
+  async applyEnvironmentVariables(name, config22, checkEnv, verbose) {
+    if (!checkEnv || !name || typeof config22 !== "object" || config22 === null || Array.isArray(config22)) {
       return {
-        config: config32,
+        config: config22,
         source: {
           type: "default",
           priority: 10,
@@ -9120,7 +7455,7 @@ class ConfigLoader2 {
         }
       };
     }
-    const processedConfig = applyEnvVarsToConfig22(name, config32, verbose);
+    const processedConfig = applyEnvVarsToConfig2(name, config22, verbose);
     return {
       config: processedConfig,
       source: {
@@ -9137,16 +7472,16 @@ class ConfigLoader2 {
       path: result.source.path
     };
   }
-  async validateConfiguration(config32, schema, customValidator, configName) {
+  async validateConfiguration(config22, schema, customValidator, configName) {
     const errors = [];
     if (customValidator) {
-      const customErrors = customValidator(config32);
+      const customErrors = customValidator(config22);
       if (customErrors) {
         errors.push(...customErrors);
       }
     }
     if (schema) {
-      const validationResult = await this.validator.validateConfiguration(config32, schema);
+      const validationResult = await this.validator.validateConfiguration(config22, schema);
       if (!validationResult.isValid) {
         errors.push(...validationResult.errors.map((e) => e.path ? `${e.path}: ${e.message}` : e.message));
       }
@@ -9166,8 +7501,10 @@ class ConfigLoader2 {
   }
   generateCacheKey(configName, options) {
     const keyParts = [configName];
-    if (options.alias)
-      keyParts.push(`alias:${options.alias}`);
+    if (options.alias) {
+      const aliasKey = Array.isArray(options.alias) ? options.alias.join(",") : options.alias;
+      keyParts.push(`alias:${aliasKey}`);
+    }
     if (options.cwd)
       keyParts.push(`cwd:${options.cwd}`);
     if (options.configDir)
@@ -9179,16 +7516,16 @@ class ConfigLoader2 {
   getLocalDirectories(baseDir, configDir) {
     return Array.from(new Set([
       baseDir,
-      resolve7(baseDir, "config"),
-      resolve7(baseDir, ".config"),
-      configDir ? resolve7(baseDir, configDir) : undefined
+      resolve52(baseDir, "config"),
+      resolve52(baseDir, ".config"),
+      configDir ? resolve52(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"));
+    paths.push(resolve52(baseDir, "package.json"));
     return paths;
   }
   getLocalSearchPaths(name, alias, baseDir, configDir) {
@@ -9203,8 +7540,8 @@ class ConfigLoader2 {
     if (!name)
       return [];
     const homeDirectories = [
-      resolve7(homedir2(), ".config", name),
-      resolve7(homedir2(), ".config"),
+      resolve52(homedir2(), ".config", name),
+      resolve52(homedir2(), ".config"),
       homedir2()
     ];
     const paths = [];
@@ -9217,8 +7554,107 @@ class ConfigLoader2 {
     return this.loadConfig(options);
   }
 }
-var globalConfigLoader2 = new ConfigLoader2;
-function applyEnvVarsToConfig22(name, config4, verbose = false) {
+function shouldHandleConfigLoadErrorGracefully2(error) {
+  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"));
+  const isStructureError = error.message.includes("Configuration must export a valid object") || error.message.includes("Configuration file is empty and exports nothing");
+  return isSyntaxError || isStructureError;
+}
+async function loadConfigWithResult2(options) {
+  return globalConfigLoader2.loadConfig({
+    ...options,
+    __strictErrorHandling: true
+  });
+}
+async function loadConfig2(options) {
+  const defaultConfig22 = "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 globalConfigLoader2.loadConfig(options);
+    } else {
+      result = await globalConfigLoader2.loadConfig({
+        ...options,
+        defaultConfig: defaultConfig22,
+        cache: { enabled: true },
+        performance: { enabled: false }
+      });
+    }
+    return result?.config ?? defaultConfig22;
+  } 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: defaultConfig22 } : {
+      ...options,
+      defaultConfig: defaultConfig22,
+      cache: { enabled: true },
+      performance: { enabled: false }
+    };
+    const shouldCheckEnv = "checkEnv" in options ? options.checkEnv !== false : true;
+    if (shouldCheckEnv) {
+      const envResult = await globalConfigLoader2.applyEnvironmentVariables(configOptions.name || "", defaultConfig22, true, configOptions.verbose || false);
+      return envResult?.config ?? defaultConfig22;
+    }
+    return defaultConfig22;
+  }
+}
+async function config22(nameOrOptions = { defaultConfig: {} }) {
+  if (typeof nameOrOptions === "string") {
+    const { cwd } = await import("process");
+    try {
+      const result = await globalConfigLoader2.loadConfig({
+        name: nameOrOptions,
+        cwd: cwd(),
+        generatedDir: "./generated",
+        configDir: "./config",
+        defaultConfig: {},
+        checkEnv: true,
+        arrayStrategy: "replace"
+      });
+      return result.config;
+    } catch (error) {
+      if (error instanceof Error && (error.name === "ConfigNotFoundError" || error.name === "ConfigLoadError" && shouldHandleConfigLoadErrorGracefully2(error))) {
+        const envResult = await globalConfigLoader2.applyEnvironmentVariables(nameOrOptions, {}, true, false);
+        return envResult.config;
+      }
+      throw error;
+    }
+  }
+  try {
+    const result = await globalConfigLoader2.loadConfig({
+      ...nameOrOptions,
+      cwd: nameOrOptions.cwd || process72.cwd(),
+      cache: { enabled: true },
+      performance: { enabled: false }
+    });
+    return result.config;
+  } catch (error) {
+    if (error instanceof Error && (error.name === "ConfigNotFoundError" || error.name === "ConfigLoadError" && shouldHandleConfigLoadErrorGracefully2(error))) {
+      const envResult = await globalConfigLoader2.applyEnvironmentVariables(nameOrOptions.name || "", nameOrOptions.defaultConfig || {}, nameOrOptions.checkEnv !== false, nameOrOptions.verbose || false);
+      return envResult.config;
+    }
+    throw error;
+  }
+}
+async function tryLoadConfig2(configPath, defaultConfig22, arrayStrategy = "replace") {
+  const fileLoader = new ConfigFileLoader2;
+  try {
+    const result = await fileLoader.loadFromPath(configPath, defaultConfig22, {
+      arrayStrategy,
+      useCache: false,
+      trackPerformance: false
+    });
+    return result ? result.config : null;
+  } catch {
+    return null;
+  }
+}
+function applyEnvVarsToConfig2(name, config32, verbose = false) {
   const _envProcessor = new EnvProcessor2;
   const envPrefix = name.toUpperCase().replace(/[^A-Z0-9]/g, "_");
   function processConfigLevel(obj, path = []) {
@@ -9233,7 +7669,7 @@ function applyEnvVarsToConfig22(name, config4, verbose = false) {
       let envValue;
       let usedKey;
       for (const envKey of envKeys) {
-        envValue = process12.env[envKey];
+        envValue = process72.env[envKey];
         if (envValue !== undefined) {
           usedKey = envKey;
           break;
@@ -9263,11 +7699,200 @@ function applyEnvVarsToConfig22(name, config4, verbose = false) {
     }
     return result;
   }
-  return processConfigLevel(config4);
+  return processConfigLevel(config32);
+}
+function generateConfigTypes2(options) {
+  const configDir = resolve52(process72.cwd(), options.configDir);
+  const generatedDir = resolve52(process72.cwd(), options.generatedDir);
+  const outputFile = resolve52(generatedDir, "config-types.ts");
+  if (!existsSync52(dirname2(outputFile)))
+    mkdirSync2(dirname2(outputFile), { recursive: true, mode: 511 });
+  const files = existsSync52(configDir) ? readdirSync3(configDir).map((file) => file.replace(/\.(ts|js|mjs|cjs|mts|cts|json)$/, "")).sort() : [];
+  const content = `// Generated by bunfig v${version2}
+export type ConfigNames = ${files.length ? `'${files.join("' | '")}'` : "string"}
+`;
+  writeFileSync22(outputFile, content, { mode: 438 });
+}
+function createLibraryConfig2(options) {
+  let configCache = null;
+  let loadPromise = null;
+  const startLoading = () => {
+    if (!loadPromise) {
+      loadPromise = loadConfig2(options).then((loadedConfig) => {
+        configCache = loadedConfig;
+        return loadedConfig;
+      }, (error) => {
+        const defaultConfig32 = "defaultConfig" in options ? options.defaultConfig : {};
+        configCache = defaultConfig32;
+        const verbose = "verbose" in options && options.verbose;
+        if (verbose) {
+          log2.warn(`Config loading failed, using defaults:`, [error instanceof Error ? error : new Error(String(error))]);
+        }
+        return defaultConfig32;
+      });
+    }
+    return loadPromise;
+  };
+  const defaultConfig22 = "defaultConfig" in options ? options.defaultConfig : {};
+  configCache = defaultConfig22;
+  startLoading();
+  return new Proxy({}, {
+    get(target, prop) {
+      if (configCache) {
+        return configCache[prop];
+      }
+      const value = defaultConfig22[prop];
+      startLoading();
+      return value;
+    },
+    has(target, prop) {
+      return prop in (configCache || defaultConfig22);
+    },
+    ownKeys() {
+      return Object.keys(configCache || defaultConfig22);
+    },
+    getOwnPropertyDescriptor(target, prop) {
+      return Object.getOwnPropertyDescriptor(configCache || defaultConfig22, prop);
+    },
+    set(target, prop, value) {
+      if (!configCache) {
+        configCache = { ...defaultConfig22 };
+      }
+      configCache[prop] = value;
+      return true;
+    }
+  });
+}
+var log2;
+var globalConfigLoader2;
+var defaultConfigDir2;
+var defaultGeneratedDir2;
+var init_config2 = __esm2(() => {
+  init_src3();
+  init_package2();
+  init_cache2();
+  init_errors2();
+  init_env_processor2();
+  init_file_loader2();
+  init_validator2();
+  init_utils2();
+  log2 = new Logger2("bunfig", {
+    showTags: true
+  });
+  globalConfigLoader2 = new ConfigLoader2;
+  defaultConfigDir2 = resolve52(process72.cwd(), "config");
+  defaultGeneratedDir2 = resolve52(process72.cwd(), "src/generated");
+});
+function bunfigPlugin2(options) {
+  const configDir = resolve62(process82.cwd(), options?.configDir || "./config");
+  function readConfigSelection() {
+    if (!existsSync62(configDir))
+      return [];
+    const allowed = new Set([".ts", ".js", ".mjs", ".cjs", ".mts", ".cts", ".json"]);
+    const priority = [".ts", ".mts", ".cts", ".js", ".mjs", ".cjs", ".json"];
+    const entries = readdirSync22(configDir).filter((file) => allowed.has(extname2(file))).map((file) => ({ base: file.replace(/\.(?:ts|js|mjs|cjs|mts|cts|json)$/i, ""), file }));
+    const bestByBase = new Map;
+    for (const { base, file } of entries) {
+      const ext = extname2(file).toLowerCase();
+      const current = bestByBase.get(base);
+      if (!current) {
+        bestByBase.set(base, file);
+        continue;
+      }
+      const currExt = extname2(current).toLowerCase();
+      if (priority.indexOf(ext) < priority.indexOf(currExt)) {
+        bestByBase.set(base, file);
+      }
+    }
+    return Array.from(bestByBase.entries()).map(([base, file]) => ({ base, file })).sort((a, b) => a.base.localeCompare(b.base));
+  }
+  function generateModuleSource() {
+    const selections = readConfigSelection();
+    const names = selections.map((s) => s.base);
+    const union = names.length ? names.map((n) => `'${n}'`).join(" | ") : "string";
+    const byName = selections.length ? `{
+${selections.map((sel) => {
+      const abs = resolve62(configDir, sel.file).replace(/\\/g, "/");
+      return `  '${sel.base}': typeof import('${abs}').default`;
+    }).join(`,
+`)}
+}` : "Record<string, any>";
+    const source = `export type ConfigNames = ${union}
+export type ConfigByName = ${byName}
+export type Config<N extends ConfigNames> = N extends keyof ConfigByName ? ConfigByName[N] : unknown
+export type ConfigOf = Config
+`;
+    return source;
+  }
+  return {
+    name: "bunfig-plugin",
+    setup(builder) {
+      builder.onResolve({ filter: /^virtual:bunfig-types$/ }, (args) => {
+        return { path: args.path, namespace: "bunfig-virtual" };
+      });
+      builder.onLoad({ filter: /^virtual:bunfig-types$/, namespace: "bunfig-virtual" }, () => {
+        const contents = generateModuleSource();
+        return { contents, loader: "ts" };
+      });
+    }
+  };
 }
-var defaultConfigDir3 = resolve7(process12.cwd(), "config");
-var defaultGeneratedDir3 = resolve7(process12.cwd(), "src/generated");
-var defaultConfig32 = {
+var init_plugin2 = () => {};
+var exports_src2 = {};
+__export3(exports_src2, {
+  withErrorRecovery: () => withErrorRecovery2,
+  tryLoadConfig: () => tryLoadConfig2,
+  loadConfigWithResult: () => loadConfigWithResult2,
+  loadConfig: () => loadConfig2,
+  isRetryableError: () => isRetryableError2,
+  isConfigNotFoundError: () => isConfigNotFoundError2,
+  isBunfigError: () => isBunfigError2,
+  globalPerformanceMonitor: () => globalPerformanceMonitor2,
+  globalCache: () => globalCache2,
+  getEnvOrDefault: () => getEnvOrDefault2,
+  generateConfigTypes: () => generateConfigTypes2,
+  defaultGeneratedDir: () => defaultGeneratedDir2,
+  defaultConfigDir: () => defaultConfigDir2,
+  deepMergeWithArrayStrategy: () => deepMergeWithArrayStrategy2,
+  deepMerge: () => deepMerge2,
+  createLibraryConfig: () => createLibraryConfig2,
+  config: () => config22,
+  bunfigPlugin: () => bunfigPlugin2,
+  applyEnvVarsToConfig: () => applyEnvVarsToConfig2,
+  TypeGenerationError: () => TypeGenerationError2,
+  SchemaValidationError: () => SchemaValidationError2,
+  PluginError: () => PluginError2,
+  PerformanceMonitor: () => PerformanceMonitor2,
+  FileSystemError: () => FileSystemError2,
+  ErrorFactory: () => ErrorFactory2,
+  EnvVarError: () => EnvVarError2,
+  EnvProcessor: () => EnvProcessor2,
+  ConfigValidator: () => ConfigValidator2,
+  ConfigValidationError: () => ConfigValidationError2,
+  ConfigNotFoundError: () => ConfigNotFoundError2,
+  ConfigMergeError: () => ConfigMergeError2,
+  ConfigLoader: () => ConfigLoader2,
+  ConfigLoadError: () => ConfigLoadError2,
+  ConfigFileLoader: () => ConfigFileLoader2,
+  ConfigCache: () => ConfigCache2,
+  CacheUtils: () => CacheUtils2,
+  BunfigError: () => BunfigError2,
+  BrowserConfigError: () => BrowserConfigError2,
+  ArrayMergeStrategies: () => ArrayMergeStrategies2
+});
+var init_src22 = __esm2(() => {
+  init_config2();
+  init_errors2();
+  init_cache2();
+  init_errors2();
+  init_plugin2();
+  init_env_processor2();
+  init_file_loader2();
+  init_validator2();
+  init_utils2();
+});
+init_src22();
+var defaultConfig22 = {
   verbose: false,
   storage: "memory",
   algorithm: "fixed-window",
@@ -9286,7 +7911,7 @@ var defaultConfig32 = {
     enableSlidingWindow: false
   }
 };
-var config32 = defaultConfig32;
+var config32 = defaultConfig22;
 
 class MemoryStorage {
   records;
@@ -9297,9 +7922,9 @@ class MemoryStorage {
   constructor(options) {
     this.records = new Map;
     this.timestamps = new Map;
-    const defaultConfig4 = config32.memoryStorage || {};
-    this.enableAutoCleanup = options?.enableAutoCleanup ?? defaultConfig4.enableAutoCleanup ?? false;
-    this.cleanupIntervalMs = options?.cleanupIntervalMs ?? defaultConfig4.cleanupIntervalMs ?? 60000;
+    const defaultConfig32 = config32.memoryStorage || {};
+    this.enableAutoCleanup = options?.enableAutoCleanup ?? defaultConfig32.enableAutoCleanup ?? false;
+    this.cleanupIntervalMs = options?.cleanupIntervalMs ?? defaultConfig32.cleanupIntervalMs ?? 60000;
     this.cleanupTimer = null;
     if (this.enableAutoCleanup) {
       this.startCleanupTimer();
@@ -9726,6 +8351,26 @@ class RateLimiter {
       return this.checkFixedWindow(key);
     }
   }
+  async peek(key) {
+    if (typeof this.storage.getCount !== "function")
+      return null;
+    const count = await this.storage.getCount(key);
+    const now = Date.now();
+    return {
+      allowed: this.draftMode ? true : count < this.maxRequests,
+      current: count,
+      limit: this.maxRequests,
+      remaining: this.windowMs,
+      resetTime: now + this.windowMs
+    };
+  }
+  async enforce(key) {
+    const result = await this.consume(key);
+    if (!result.allowed) {
+      throw new RateLimitError(`Rate limit exceeded for '${key}'`, result);
+    }
+    return result;
+  }
   async reset(key) {
     await this.storage.reset(key);
     if (this.algorithm === "token-bucket") {
@@ -9779,6 +8424,25 @@ class RateLimiter {
     this.tokenBuckets.clear();
   }
 }
+
+class RateLimitError extends Error {
+  name = "RateLimitError";
+  retryAfter;
+  result;
+  constructor(message, result) {
+    super(message);
+    this.result = result;
+    this.retryAfter = Math.max(1, Math.ceil(result.remaining / 1000));
+  }
+  toHeaders() {
+    return {
+      "Retry-After": String(this.retryAfter),
+      "RateLimit-Limit": String(this.result.limit),
+      "RateLimit-Remaining": "0",
+      "RateLimit-Reset": String(Math.ceil(this.result.resetTime / 1000))
+    };
+  }
+}
 async function createRateLimiter(options = {}) {
   const finalOptions = {
     windowMs: options.windowMs ?? config32.windowMs ?? 60000,
@@ -9952,7 +8616,7 @@ class RateLimit {
       return response || new Response("Not Found", { status: 404 });
     }
     if (!this.limiter) {
-      await new Promise((resolve9) => setTimeout(resolve9, 50));
+      await new Promise((resolve7) => setTimeout(resolve7, 50));
       if (!this.limiter) {
         const response = await next();
         return response || new Response("Not Found", { status: 404 });
@@ -10451,8 +9115,8 @@ class MemorySessionStore {
 }
 
 // src/session/file-store.ts
-import { existsSync as existsSync9, mkdirSync as mkdirSync6, readdirSync as readdirSync6, unlinkSync, writeFileSync as writeFileSync6, readFileSync as readFileSync2 } from "fs";
-import { join as join6 } from "path";
+import { existsSync as existsSync9, mkdirSync as mkdirSync3, readdirSync as readdirSync5, unlinkSync, writeFileSync as writeFileSync5, readFileSync as readFileSync3 } from "fs";
+import { join as join5 } from "path";
 import { tmpdir } from "os";
 
 class FileSessionStore {
@@ -10461,22 +9125,22 @@ class FileSessionStore {
   cleanupInterval = null;
   constructor(defaultTtl = 86400, dir) {
     this.defaultTtl = defaultTtl;
-    this.dir = dir || join6(tmpdir(), "bun-router-sessions");
+    this.dir = dir || join5(tmpdir(), "bun-router-sessions");
     if (!existsSync9(this.dir)) {
-      mkdirSync6(this.dir, { recursive: true });
+      mkdirSync3(this.dir, { recursive: true });
     }
     this.cleanupInterval = setInterval(() => this.cleanup(), 10 * 60 * 1000);
   }
   filePath(sid) {
     const safeSid = sid.replace(/[^a-zA-Z0-9_-]/g, "");
-    return join6(this.dir, `${safeSid}.json`);
+    return join5(this.dir, `${safeSid}.json`);
   }
   async get(sid) {
     const path = this.filePath(sid);
     if (!existsSync9(path))
       return null;
     try {
-      const content = readFileSync2(path, "utf-8");
+      const content = readFileSync3(path, "utf-8");
       const stored = JSON.parse(content);
       if (Date.now() > stored.expiresAt) {
         unlinkSync(path);
@@ -10492,7 +9156,7 @@ class FileSessionStore {
       data: session,
       expiresAt: Date.now() + (ttl ?? this.defaultTtl) * 1000
     };
-    writeFileSync6(this.filePath(sid), JSON.stringify(stored), "utf-8");
+    writeFileSync5(this.filePath(sid), JSON.stringify(stored), "utf-8");
   }
   async destroy(sid) {
     const path = this.filePath(sid);
@@ -10508,15 +9172,15 @@ class FileSessionStore {
       data: session,
       expiresAt: Date.now() + (ttl ?? this.defaultTtl) * 1000
     };
-    writeFileSync6(path, JSON.stringify(stored), "utf-8");
+    writeFileSync5(path, JSON.stringify(stored), "utf-8");
   }
   async all() {
     const result = {};
     const now = Date.now();
     try {
-      const files = readdirSync6(this.dir).filter((f) => f.endsWith(".json"));
+      const files = readdirSync5(this.dir).filter((f) => f.endsWith(".json"));
       for (const file of files) {
-        const content = readFileSync2(join6(this.dir, file), "utf-8");
+        const content = readFileSync3(join5(this.dir, file), "utf-8");
         const stored = JSON.parse(content);
         if (now <= stored.expiresAt) {
           const sid = file.replace(".json", "");
@@ -10528,26 +9192,26 @@ class FileSessionStore {
   }
   async length() {
     try {
-      return readdirSync6(this.dir).filter((f) => f.endsWith(".json")).length;
+      return readdirSync5(this.dir).filter((f) => f.endsWith(".json")).length;
     } catch {
       return 0;
     }
   }
   async clear() {
     try {
-      const files = readdirSync6(this.dir).filter((f) => f.endsWith(".json"));
+      const files = readdirSync5(this.dir).filter((f) => f.endsWith(".json"));
       for (const file of files) {
-        unlinkSync(join6(this.dir, file));
+        unlinkSync(join5(this.dir, file));
       }
     } catch {}
   }
   cleanup() {
     const now = Date.now();
     try {
-      const files = readdirSync6(this.dir).filter((f) => f.endsWith(".json"));
+      const files = readdirSync5(this.dir).filter((f) => f.endsWith(".json"));
       for (const file of files) {
-        const path = join6(this.dir, file);
-        const content = readFileSync2(path, "utf-8");
+        const path = join5(this.dir, file);
+        const content = readFileSync3(path, "utf-8");
         const stored = JSON.parse(content);
         if (now > stored.expiresAt) {
           unlinkSync(path);
@@ -11305,8 +9969,8 @@ class FileSecurity {
 
 // src/middleware/file_upload.ts
 import { randomUUID as randomUUID2 } from "crypto";
-import { existsSync as existsSync10, mkdirSync as mkdirSync7, writeFileSync as writeFileSync7 } from "fs";
-import { basename, extname as extname2, join as join7 } from "path";
+import { existsSync as existsSync10, mkdirSync as mkdirSync4, writeFileSync as writeFileSync6 } from "fs";
+import { basename, extname as extname3, join as join6 } from "path";
 class FileUpload {
   config;
   fileSecurity;
@@ -11328,7 +9992,7 @@ class FileUpload {
     };
     this.fileSecurity = new FileSecurity(config4);
     if (this.config.createDestination && !existsSync10(this.config.destination)) {
-      mkdirSync7(this.config.destination, { recursive: true });
+      mkdirSync4(this.config.destination, { recursive: true });
     }
   }
   async handle(req, next) {
@@ -11355,12 +10019,12 @@ class FileUpload {
               return this.createErrorResponse(`File type ${baseType} not allowed. Allowed types: ${this.config.allowedMimeTypes.join(", ")}`, 415);
             }
           }
-          const fileExtension = extname2(value.name).toLowerCase();
+          const fileExtension = extname3(value.name).toLowerCase();
           if (this.config.allowedExtensions.length > 0 && !this.config.allowedExtensions.includes(fileExtension)) {
             return this.createErrorResponse(`File extension ${fileExtension} not allowed. Allowed extensions: ${this.config.allowedExtensions.join(", ")}`, 415);
           }
           const filename = this.generateFilename(value.name);
-          const filePath = join7(this.config.destination, filename);
+          const filePath = join6(this.config.destination, filename);
           const buffer = await value.arrayBuffer();
           const uploadedFile = {
             fieldName: key,
@@ -11375,7 +10039,7 @@ class FileUpload {
           if (!securityCheck.isValid) {
             return this.createErrorResponse(`Security validation failed: ${securityCheck.errors.join(", ")}`, 400);
           }
-          writeFileSync7(filePath, new Uint8Array(buffer));
+          writeFileSync6(filePath, new Uint8Array(buffer));
           uploadedFiles.push(uploadedFile);
         } else {
           if (fields[key]) {
@@ -11412,7 +10076,7 @@ class FileUpload {
     if (this.config.preserveOriginalName && !this.config.generateUniqueFilename) {
       return sanitizedName;
     }
-    const extension = extname2(sanitizedName);
+    const extension = extname3(sanitizedName);
     const baseName = basename(sanitizedName, extension);
     if (this.config.generateUniqueFilename) {
       const uuid = randomUUID2();
@@ -12386,7 +11050,7 @@ function performanceAlerting(options = {}) {
 }
 
 // src/middleware/performance_dashboard.ts
-import process13 from "process";
+import process11 from "process";
 
 class PerformanceDashboard {
   options;
@@ -12823,12 +11487,12 @@ else {
     }
     const system = {
       uptime: now - this.startTime,
-      nodeVersion: process13.version,
-      bunVersion: process13.versions.bun || "N/A",
-      platform: process13.platform,
-      arch: process13.arch,
-      memory: process13.memoryUsage(),
-      cpu: process13.cpuUsage()
+      nodeVersion: process11.version,
+      bunVersion: process11.versions.bun || "N/A",
+      platform: process11.platform,
+      arch: process11.arch,
+      memory: process11.memoryUsage(),
+      cpu: process11.cpuUsage()
     };
     return {
       metrics,
@@ -12911,7 +11575,7 @@ function performanceDashboard(options = {}) {
 
 // src/middleware/performance_monitor.ts
 import crypto2 from "crypto";
-import process15 from "process";
+import process12 from "process";
 class PerformanceMonitor3 {
   options;
   metrics = [];
@@ -13005,13 +11669,13 @@ class PerformanceMonitor3 {
     return req.headers.get("x-forwarded-for")?.split(",")[0]?.trim() || req.headers.get("x-real-ip") || req.headers.get("cf-connecting-ip") || "unknown";
   }
   async collectSystemMetrics() {
-    const memory = process15.memoryUsage();
-    const cpu = process15.cpuUsage();
+    const memory = process12.memoryUsage();
+    const cpu = process12.cpuUsage();
     return { memory, cpu };
   }
   takeSample(profileData) {
-    const memory = process15.memoryUsage();
-    const cpu = process15.cpuUsage();
+    const memory = process12.memoryUsage();
+    const cpu = process12.cpuUsage();
     const timestamp = Date.now();
     if (!profileData.systemSamples) {
       profileData.systemSamples = [];
@@ -13230,8 +11894,8 @@ class PerformanceMonitor3 {
   async collectMetrics(params) {
     const { req, res, startTime, startMemory: _startMemory, startCPU, error } = params;
     const endTime = performance.now();
-    const endMemory = process15.memoryUsage();
-    const endCpu = process15.cpuUsage(startCPU);
+    const endMemory = process12.memoryUsage();
+    const endCpu = process12.cpuUsage(startCPU);
     const url = new URL(req.url);
     const requestId = req.requestId || crypto2.randomUUID();
     const cpuUsage = {
@@ -13292,8 +11956,8 @@ class PerformanceMonitor3 {
     this.requestsThisSecond++;
     console.warn(`[PerformanceMonitor] Handling request: ${req.method} ${new URL(req.url).pathname}`);
     const startTime = performance.now();
-    const startMemory = process15.memoryUsage();
-    const startCPU = process15.cpuUsage();
+    const startMemory = process12.memoryUsage();
+    const startCPU = process12.cpuUsage();
     const profilingSamples = [];
     let profilingInterval;
     if (this.options.profiling?.enabled) {
@@ -13413,8 +12077,8 @@ class PerformanceMonitor3 {
   }
   getProfiles() {
     const profiles = [];
-    const currentMemory = process15.memoryUsage();
-    const currentCpu = process15.cpuUsage();
+    const currentMemory = process12.memoryUsage();
+    const currentCpu = process12.cpuUsage();
     profiles.push({
       timestamp: Date.now(),
       memoryUsage: currentMemory,