bun-git-hooks 0.2.13 → 0.2.14

package/dist/index.js

@@ -1,10 +1,44 @@
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
 // src/config.ts
-import process2 from "node:process";
+import process7 from "node:process";
 
 // node_modules/bunfig/dist/index.js
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readdirSync as readdirSync2, writeFileSync as writeFileSync3 } from "fs";
+import { dirname as dirname2, resolve as resolve3 } from "path";
+import process6 from "process";
+import { join, relative, resolve as resolve2 } from "path";
+import process2 from "process";
 import { existsSync, mkdirSync, readdirSync, writeFileSync } from "fs";
 import { dirname, resolve } from "path";
 import process from "process";
+import { Buffer } from "buffer";
+import { createCipheriv, createDecipheriv, randomBytes } from "crypto";
+import { closeSync, createReadStream, createWriteStream, existsSync as existsSync2, fsyncSync, openSync, writeFileSync as writeFileSync2 } from "fs";
+import { access, constants, mkdir, readdir, rename, stat, unlink, writeFile } from "fs/promises";
+import { join as join2 } from "path";
+import process5 from "process";
+import { pipeline } from "stream/promises";
+import { createGzip } from "zlib";
+import process4 from "process";
+import process3 from "process";
 function deepMerge(target, source) {
   if (Array.isArray(source) && Array.isArray(target) && source.length === 2 && target.length === 2 && isObject(source[0]) && "id" in source[0] && source[0].id === 3 && isObject(source[1]) && "id" in source[1] && source[1].id === 4) {
     return source;
@@ -120,18 +154,3147 @@ function deepEquals(a, b) {
     for (const key of keysA) {
       if (!Object.prototype.hasOwnProperty.call(b, key))
         return false;
-      if (!deepEquals(a[key], b[key]))
+      if (!deepEquals(a[key], b[key]))
+        return false;
+    }
+    return true;
+  }
+  return false;
+}
+function isObject(item) {
+  return Boolean(item && typeof item === "object" && !Array.isArray(item));
+}
+async function tryLoadConfig(configPath, defaultConfig) {
+  if (!existsSync(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 deepMerge(defaultConfig, loadedConfig);
+    } catch {
+      return null;
+    }
+  } catch {
+    return null;
+  }
+}
+async function loadConfig({
+  name = "",
+  cwd,
+  defaultConfig
+}) {
+  const baseDir = cwd || process.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 = resolve(baseDir, `${configPath}${ext}`);
+      const config2 = await tryLoadConfig(fullPath, defaultConfig);
+      if (config2 !== null)
+        return config2;
+    }
+  }
+  console.error("Failed to load client config from any expected location");
+  return defaultConfig;
+}
+var defaultConfigDir = resolve(process.cwd(), "config");
+var defaultGeneratedDir = resolve(process.cwd(), "src/generated");
+function getProjectRoot(filePath, options = {}) {
+  let path = process2.cwd();
+  while (path.includes("storage"))
+    path = resolve2(path, "..");
+  const finalPath = resolve2(path, filePath || "");
+  if (options?.relative)
+    return relative(process2.cwd(), finalPath);
+  return finalPath;
+}
+var defaultLogDirectory = process2.env.CLARITY_LOG_DIR || join(getProjectRoot(), "logs");
+var defaultConfig = {
+  level: "info",
+  defaultName: "clarity",
+  timestamp: true,
+  colors: true,
+  format: "text",
+  maxLogSize: 10485760,
+  logDatePattern: "YYYY-MM-DD",
+  logDirectory: defaultLogDirectory,
+  rotation: {
+    frequency: "daily",
+    maxSize: 10485760,
+    maxFiles: 5,
+    compress: false,
+    rotateHour: 0,
+    rotateMinute: 0,
+    rotateDayOfWeek: 0,
+    rotateDayOfMonth: 1,
+    encrypt: false
+  },
+  verbose: false
+};
+async function loadConfig2() {
+  try {
+    const loadedConfig = await loadConfig({
+      name: "clarity",
+      defaultConfig,
+      cwd: process2.cwd(),
+      endpoint: "",
+      headers: {}
+    });
+    return { ...defaultConfig, ...loadedConfig };
+  } catch {
+    return defaultConfig;
+  }
+}
+var config = await loadConfig2();
+function isBrowserProcess() {
+  if (process3.env.NODE_ENV === "test" || process3.env.BUN_ENV === "test") {
+    return false;
+  }
+  return typeof window !== "undefined";
+}
+async function isServerProcess() {
+  if (process3.env.NODE_ENV === "test" || process3.env.BUN_ENV === "test") {
+    return true;
+  }
+  if (typeof navigator !== "undefined" && navigator.product === "ReactNative") {
+    return true;
+  }
+  if (typeof process3 !== "undefined") {
+    const type = process3.type;
+    if (type === "renderer" || type === "worker") {
+      return false;
+    }
+    return !!(process3.versions && (process3.versions.node || process3.versions.bun));
+  }
+  return false;
+}
+
+class JsonFormatter {
+  async format(entry) {
+    const isServer = await isServerProcess();
+    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: process4.pid,
+        hostname: hostname(),
+        environment: process4.env.NODE_ENV || "development",
+        platform: process4.platform,
+        version: process4.version
+      };
+    }
+    return {
+      userAgent: navigator.userAgent,
+      hostname: window.location.hostname || "browser",
+      environment: process4.env.NODE_ENV || process4.env.BUN_ENV || "development",
+      viewport: {
+        width: window.innerWidth,
+        height: window.innerHeight
+      },
+      language: navigator.language
+    };
+  }
+}
+var terminalStyles = {
+  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 styles = terminalStyles;
+var red = terminalStyles.red;
+var green = terminalStyles.green;
+var yellow = terminalStyles.yellow;
+var blue = terminalStyles.blue;
+var magenta = terminalStyles.magenta;
+var cyan = terminalStyles.cyan;
+var white = terminalStyles.white;
+var gray = terminalStyles.gray;
+var bgRed = terminalStyles.bgRed;
+var bgYellow = terminalStyles.bgYellow;
+var bold = terminalStyles.bold;
+var dim = terminalStyles.dim;
+var italic = terminalStyles.italic;
+var underline = terminalStyles.underline;
+var reset = terminalStyles.reset;
+var defaultFingersCrossedConfig = {
+  activationLevel: "error",
+  bufferSize: 50,
+  flushOnDeactivation: true,
+  stopBuffering: false
+};
+var levelIcons = {
+  debug: "\uD83D\uDD0D",
+  info: blue("ℹ"),
+  success: green("✓"),
+  warning: bgYellow(white(bold(" WARN "))),
+  error: bgRed(white(bold(" ERROR ")))
+};
+
+class Logger {
+  name;
+  fileLocks = new Map;
+  currentKeyId = null;
+  keys = new Map;
+  config;
+  options;
+  formatter;
+  timers = new Set;
+  subLoggers = new Set;
+  fingersCrossedBuffer = [];
+  fingersCrossedConfig;
+  fingersCrossedActive = false;
+  currentLogFile;
+  rotationTimeout;
+  keyRotationTimeout;
+  encryptionKeys;
+  logBuffer = [];
+  isActivated = false;
+  pendingOperations = [];
+  enabled;
+  fancy;
+  tagFormat;
+  timestampPosition;
+  environment;
+  ANSI_PATTERN = /\u001B\[.*?m/g;
+  activeProgressBar = null;
+  constructor(name, options = {}) {
+    this.name = name;
+    this.config = { ...config };
+    this.options = this.normalizeOptions(options);
+    this.formatter = this.options.formatter || new JsonFormatter;
+    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 ?? process5.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
+    };
+    if (!this.config.logDirectory) {
+      this.config.logDirectory = config.logDirectory;
+    }
+    if (!isBrowserProcess()) {
+      mkdir(this.config.logDirectory, { recursive: true, mode: 493 }).catch((err) => console.error("Failed to create log directory:", err));
+    }
+    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();
+    }
+  }
+  initializeFingersCrossedConfig(options) {
+    if (!options.fingersCrossedEnabled && options.fingersCrossed) {
+      return {
+        ...defaultFingersCrossedConfig,
+        ...options.fingersCrossed
+      };
+    }
+    if (!options.fingersCrossedEnabled) {
+      return null;
+    }
+    if (!options.fingersCrossed) {
+      return { ...defaultFingersCrossedConfig };
+    }
+    return {
+      ...defaultFingersCrossedConfig,
+      ...options.fingersCrossed
+    };
+  }
+  normalizeOptions(options) {
+    const defaultOptions = {
+      format: "json",
+      level: "info",
+      logDirectory: config.logDirectory,
+      rotation: undefined,
+      timestamp: undefined,
+      fingersCrossed: {},
+      enabled: true,
+      showTags: false,
+      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;
+  }
+  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 access(this.config.logDirectory, constants.F_OK | constants.W_OK);
+            } catch (err) {
+              if (err instanceof Error && "code" in err) {
+                if (err.code === "ENOENT") {
+                  await mkdir(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 : Buffer.from(data);
+          try {
+            if (!existsSync2(this.currentLogFile)) {
+              await writeFile(this.currentLogFile, "", { mode: 420 });
+            }
+            fd = openSync(this.currentLogFile, "a", 420);
+            writeFileSync2(fd, dataToWrite, { flag: "a" });
+            fsyncSync(fd);
+            if (fd !== undefined) {
+              closeSync(fd);
+              fd = undefined;
+            }
+            const stats = await stat(this.currentLogFile);
+            if (stats.size === 0) {
+              await writeFile(this.currentLogFile, dataToWrite, { flag: "w", mode: 420 });
+              const retryStats = await stat(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((resolve32) => setTimeout(resolve32, 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 {
+                closeSync(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((resolve32) => setTimeout(resolve32, 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 join2(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 join2(this.config.logDirectory, `${this.name}.log`);
+    }
+    const date = new Date().toISOString().split("T")[0];
+    return join2(this.config.logDirectory, `${this.name}-${date}.log`);
+  }
+  setupRotation() {
+    if (isBrowserProcess())
+      return;
+    if (typeof this.config.rotation === "boolean")
+      return;
+    const config2 = this.config.rotation;
+    let interval;
+    switch (config2.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 randomBytes(16).toString("hex");
+  }
+  generateKey() {
+    return randomBytes(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 = randomBytes(16);
+    const cipher = createCipheriv("aes-256-gcm", key, iv);
+    const encrypted = Buffer.concat([
+      cipher.update(data, "utf8"),
+      cipher.final()
+    ]);
+    const authTag = cipher.getAuthTag();
+    return {
+      encrypted: Buffer.concat([iv, encrypted, authTag]),
+      iv
+    };
+  }
+  async compressData(data) {
+    return new Promise((resolve32, reject) => {
+      const gzip = createGzip();
+      const chunks = [];
+      gzip.on("data", (chunk2) => chunks.push(chunk2));
+      gzip.on("end", () => resolve32(Buffer.from(Buffer.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 (isBrowserProcess())
+      return;
+    const stats = await stat(this.currentLogFile).catch(() => null);
+    if (!stats)
+      return;
+    const config2 = this.config.rotation;
+    if (typeof config2 === "boolean")
+      return;
+    if (config2.maxSize && stats.size >= config2.maxSize) {
+      const oldFile = this.currentLogFile;
+      const newFile = this.generateLogFilename();
+      if (this.name.includes("rotation-load-test") || this.name === "failed-rotation-test") {
+        const files = await readdir(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 stat(oldFile).catch(() => null)) {
+          try {
+            await rename(oldFile, rotatedFile);
+            if (config2.compress) {
+              try {
+                const compressedPath = `${rotatedFile}.gz`;
+                await this.compressLogFile(rotatedFile, compressedPath);
+                await unlink(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 writeFile(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 stat(oldFile).catch(() => null)) {
+          await rename(oldFile, rotatedFile);
+        }
+      }
+      this.currentLogFile = newFile;
+      if (config2.maxFiles) {
+        const files = await readdir(this.config.logDirectory);
+        const logFiles = files.filter((f) => f.startsWith(this.name)).sort((a, b) => b.localeCompare(a));
+        for (const file of logFiles.slice(config2.maxFiles)) {
+          await unlink(join2(this.config.logDirectory, file));
+        }
+      }
+    }
+  }
+  async compressLogFile(inputPath, outputPath) {
+    const readStream = createReadStream(inputPath);
+    const writeStream = createWriteStream(outputPath);
+    const gzip = createGzip();
+    await pipeline(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);
+        await this.writeToFile(formattedBufferedEntry);
+        console.log(formattedBufferedEntry);
+      }
+      if (this.fingersCrossedConfig.stopBuffering)
+        this.logBuffer = [];
+    }
+    if (this.isActivated) {
+      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;
+    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 (existsSync2(this.currentLogFile)) {
+      try {
+        const fd = openSync(this.currentLogFile, "r+");
+        fsyncSync(fd);
+        closeSync(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 (!isBrowserProcess() && this.config.rotation && typeof this.config.rotation !== "boolean" && this.config.rotation.compress) {
+        try {
+          const files = await readdir(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 unlink(join2(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.fancy ? styles.gray(date.toLocaleTimeString()) : date.toLocaleTimeString();
+  }
+  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 = process5.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} ${styles.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;
+  }
+  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);
+    }
+    if (this.fancy && !isBrowserProcess()) {
+      const icon = levelIcons[level];
+      const tag = this.options.showTags !== false && this.name ? styles.gray(this.formatTag(this.name)) : "";
+      let consoleMessage;
+      switch (level) {
+        case "debug":
+          consoleMessage = this.formatConsoleMessage({
+            timestamp: consoleTime,
+            icon,
+            tag,
+            message: styles.gray(formattedMessage),
+            level
+          });
+          console.error(consoleMessage);
+          break;
+        case "info":
+          consoleMessage = this.formatConsoleMessage({
+            timestamp: consoleTime,
+            icon,
+            tag,
+            message: formattedMessage,
+            level
+          });
+          console.error(consoleMessage);
+          break;
+        case "success":
+          consoleMessage = this.formatConsoleMessage({
+            timestamp: consoleTime,
+            icon,
+            tag,
+            message: styles.green(formattedMessage),
+            level
+          });
+          console.error(consoleMessage);
+          break;
+        case "warning":
+          consoleMessage = this.formatConsoleMessage({
+            timestamp: consoleTime,
+            icon,
+            tag,
+            message: formattedMessage,
+            level
+          });
+          console.warn(consoleMessage);
+          break;
+        case "error":
+          consoleMessage = this.formatConsoleMessage({
+            timestamp: consoleTime,
+            icon,
+            tag,
+            message: formattedMessage,
+            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: styles.gray(`  ${line}`),
+                  level,
+                  showTimestamp: false
+                }));
+              }
+            }
+          }
+          break;
+      }
+    } else if (!isBrowserProcess()) {
+      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()}: ${formattedMessage}
+`;
+    if (errorStack) {
+      logEntry += `${errorStack}
+`;
+    }
+    logEntry = logEntry.replace(this.ANSI_PATTERN, "");
+    await this.writeToFile(logEntry);
+  }
+  time(label) {
+    const start = performance.now();
+    if (this.fancy && !isBrowserProcess()) {
+      const tag = this.options.showTags !== false && this.name ? styles.gray(this.formatTag(this.name)) : "";
+      const consoleTime = this.formatConsoleTimestamp(new Date);
+      console.error(this.formatConsoleMessage({
+        timestamp: consoleTime,
+        icon: styles.blue("◐"),
+        tag,
+        message: `${styles.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.fancy && !isBrowserProcess()) {
+        const tag = this.options.showTags !== false && this.name ? styles.gray(this.formatTag(this.name)) : "";
+        console.error(this.formatConsoleMessage({
+          timestamp: consoleTime,
+          icon: styles.green("✓"),
+          tag,
+          message: `${completionMessage}${metadata ? ` ${JSON.stringify(metadata)}` : ""}`
+        }));
+      } else if (!isBrowserProcess()) {
+        console.error(logEntry.trim());
+      }
+      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 Logger(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 (isBrowserProcess())
+      throw new Error("createReadStream is not supported in browser environments");
+    if (!existsSync2(this.currentLogFile))
+      throw new Error(`Log file does not exist: ${this.currentLogFile}`);
+    return createReadStream(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 = Buffer.isBuffer(data) ? data : Buffer.from(data, "base64");
+      const iv = encryptedData.slice(0, 16);
+      const authTag = encryptedData.slice(-16);
+      const ciphertext = encryptedData.slice(16, -16);
+      const decipher = createDecipheriv("aes-256-gcm", key, iv);
+      decipher.setAuthTag(authTag);
+      const decrypted = Buffer.concat([
+        decipher.update(ciphertext),
+        decipher.final()
+      ]);
+      return decrypted.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 isBrowserProcess();
+  }
+  isServerMode() {
+    return !isBrowserProcess();
+  }
+  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);
+    if (this.fancy && !isBrowserProcess()) {
+      const lines = message.split(`
+`);
+      const width = Math.max(...lines.map((line) => line.length)) + 2;
+      const top = `┌${"─".repeat(width)}┐`;
+      const bottom = `└${"─".repeat(width)}┘`;
+      const boxedLines = lines.map((line) => {
+        const padding = " ".repeat(width - line.length - 2);
+        return `│ ${line}${padding} │`;
+      });
+      if (this.options.showTags !== false && this.name) {
+        console.error(this.formatConsoleMessage({
+          timestamp: consoleTime,
+          message: styles.gray(this.formatTag(this.name)),
+          showTimestamp: false
+        }));
+      }
+      console.error(this.formatConsoleMessage({
+        timestamp: consoleTime,
+        message: styles.cyan(top)
+      }));
+      boxedLines.forEach((line) => console.error(this.formatConsoleMessage({
+        timestamp: consoleTime,
+        message: styles.cyan(line),
+        showTimestamp: false
+      })));
+      console.error(this.formatConsoleMessage({
+        timestamp: consoleTime,
+        message: styles.cyan(bottom),
+        showTimestamp: false
+      }));
+    } else if (!isBrowserProcess()) {
+      console.error(`${fileTime} ${this.environment}.INFO: [BOX] ${message}`);
+    }
+    const logEntry = `${fileTime} ${this.environment}.INFO: [BOX] ${message}
+`.replace(this.ANSI_PATTERN, "");
+    await this.writeToFile(logEntry);
+  }
+  async prompt(message) {
+    if (isBrowserProcess()) {
+      return Promise.resolve(true);
+    }
+    return new Promise((resolve32) => {
+      console.error(`${styles.cyan("?")} ${message} (y/n) `);
+      const onData = (data) => {
+        const input = data.toString().trim().toLowerCase();
+        process5.stdin.removeListener("data", onData);
+        try {
+          if (typeof process5.stdin.setRawMode === "function") {
+            process5.stdin.setRawMode(false);
+          }
+        } catch {}
+        process5.stdin.pause();
+        console.error("");
+        resolve32(input === "y" || input === "yes");
+      };
+      try {
+        if (typeof process5.stdin.setRawMode === "function") {
+          process5.stdin.setRawMode(true);
+        }
+      } catch {}
+      process5.stdin.resume();
+      process5.stdin.once("data", onData);
+    });
+  }
+  setFancy(enabled) {
+    this.fancy = enabled;
+  }
+  isFancy() {
+    return this.fancy;
+  }
+  pause() {
+    this.enabled = false;
+  }
+  resume() {
+    this.enabled = true;
+  }
+  async start(message, ...args) {
+    if (!this.enabled)
+      return;
+    let formattedMessage = message;
+    if (args && args.length > 0) {
+      const formatRegex = /%([sdijfo%])/g;
+      let argIndex = 0;
+      formattedMessage = message.replace(formatRegex, (match, type) => {
+        if (type === "%")
+          return "%";
+        if (argIndex >= args.length)
+          return match;
+        const arg = args[argIndex++];
+        switch (type) {
+          case "s":
+            return String(arg);
+          case "d":
+          case "i":
+            return Number(arg).toString();
+          case "j":
+          case "o":
+            return JSON.stringify(arg, null, 2);
+          default:
+            return match;
+        }
+      });
+      if (argIndex < args.length) {
+        formattedMessage += ` ${args.slice(argIndex).map((arg) => typeof arg === "object" ? JSON.stringify(arg, null, 2) : String(arg)).join(" ")}`;
+      }
+    }
+    if (this.fancy && !isBrowserProcess()) {
+      const tag = this.options.showTags !== false && this.name ? styles.gray(this.formatTag(this.name)) : "";
+      const spinnerChar = styles.blue("◐");
+      console.error(`${spinnerChar} ${tag} ${styles.cyan(formattedMessage)}`);
+    }
+    const timestamp = new Date;
+    const formattedDate = timestamp.toISOString();
+    const logEntry = `[${formattedDate}] ${this.environment}.INFO: [START] ${formattedMessage}
+`.replace(this.ANSI_PATTERN, "");
+    await this.writeToFile(logEntry);
+  }
+  progress(total, initialMessage = "") {
+    if (!this.enabled || !this.fancy || isBrowserProcess() || 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 || isBrowserProcess())
+        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 || isBrowserProcess())
+        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 || isBrowserProcess())
+        return;
+      process5.stdout.write(`${"\r".padEnd(process5.stdout.columns || 80)}\r`);
+      this.log(level, interruptMessage);
+      setTimeout(() => {
+        if (this.activeProgressBar) {
+          this.renderProgressBar(this.activeProgressBar);
+        }
+      }, 50);
+    };
+    return { update, finish, interrupt };
+  }
+  renderProgressBar(barState, isFinished = false) {
+    if (!this.enabled || !this.fancy || isBrowserProcess() || !process5.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 = styles.green("━".repeat(filledLength));
+    const emptyBar = styles.gray("━".repeat(emptyLength));
+    const bar = `[${filledBar}${emptyBar}]`;
+    const percentageText = `${percent}%`.padStart(4);
+    const messageText = barState.message ? ` ${barState.message}` : "";
+    const icon = isFinished || percent === 100 ? styles.green("✓") : styles.blue("▶");
+    const tag = this.options.showTags !== false && this.name ? ` ${styles.gray(this.formatTag(this.name))}` : "";
+    const line = `\r${icon}${tag} ${bar} ${percentageText}${messageText}`;
+    const terminalWidth = process5.stdout.columns || 80;
+    const clearLine = " ".repeat(Math.max(0, terminalWidth - line.replace(this.ANSI_PATTERN, "").length));
+    barState.lastRenderedLine = `${line}${clearLine}`;
+    process5.stdout.write(barState.lastRenderedLine);
+    if (isFinished) {
+      process5.stdout.write(`
+`);
+    }
+  }
+  finishProgressBar(barState, finalMessage) {
+    if (!this.enabled || !this.fancy || isBrowserProcess() || !process5.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 (isBrowserProcess()) {
+      console.warn("Log clearing is not supported in browser environments.");
+      return;
+    }
+    try {
+      console.warn("Clearing logs...", this.config.logDirectory);
+      const files = await readdir(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 = join2(this.config.logDirectory, file);
+        if (filters.before) {
+          try {
+            const fileStats = await stat(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 unlink(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 logger = new Logger("stacks");
+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));
+}
+var log = new Logger("bunfig", {
+  showTags: true
+});
+async function tryLoadConfig2(configPath, defaultConfig2) {
+  if (!existsSync3(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 deepMerge2(defaultConfig2, loadedConfig);
+    } catch {
+      return null;
+    }
+  } catch {
+    return null;
+  }
+}
+async function loadConfig3({
+  name = "",
+  cwd,
+  defaultConfig: defaultConfig2
+}) {
+  const baseDir = cwd || process6.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 = resolve3(baseDir, `${configPath}${ext}`);
+      const config3 = await tryLoadConfig2(fullPath, defaultConfig2);
+      if (config3 !== null) {
+        log.debug(`Configuration found: ${configPath}${ext}`);
+        return config3;
+      }
+    }
+  }
+  try {
+    const pkgPath = resolve3(baseDir, "package.json");
+    if (existsSync3(pkgPath)) {
+      const pkg = await import(pkgPath);
+      const pkgConfig = pkg[name];
+      if (pkgConfig && typeof pkgConfig === "object" && !Array.isArray(pkgConfig)) {
+        try {
+          log.debug(`Configuration found in package.json!`);
+          return deepMerge2(defaultConfig2, pkgConfig);
+        } catch {}
+      }
+    }
+  } catch {}
+  log.debug("No configuration found, now using default config");
+  return defaultConfig2;
+}
+var defaultConfigDir2 = resolve3(process6.cwd(), "config");
+var defaultGeneratedDir2 = resolve3(process6.cwd(), "src/generated");
+
+// git-hooks.config.ts
+var config2 = {
+  "pre-commit": {
+    "staged-lint": {
+      "*.{js,ts}": "bunx --bun eslint . --fix --max-warnings=0"
+    }
+  },
+  verbose: true
+};
+var git_hooks_config_default = config2;
+
+// src/config.ts
+var config3 = await loadConfig3({
+  name: "git-hooks",
+  cwd: process7.cwd(),
+  defaultConfig: git_hooks_config_default
+});
+// src/git-hooks.ts
+import fs from "node:fs";
+import path from "node:path";
+import process12 from "node:process";
+import { exec } from "node:child_process";
+import { promisify } from "node:util";
+
+// node_modules/@stacksjs/clarity/dist/index.js
+import { join as join3, relative as relative2, resolve as resolve4 } from "path";
+import process72 from "process";
+import { existsSync as existsSync32, mkdirSync as mkdirSync22, readdirSync as readdirSync22, writeFileSync as writeFileSync32 } from "fs";
+import { dirname as dirname22, 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 existsSync4, mkdirSync as mkdirSync3, readdirSync as readdirSync3, writeFileSync as writeFileSync4 } from "fs";
+import { dirname as dirname3, resolve as resolve5 } from "path";
+import process9 from "process";
+import { Buffer as Buffer2 } from "buffer";
+import { createCipheriv as createCipheriv2, createDecipheriv as createDecipheriv2, randomBytes as randomBytes2 } from "crypto";
+import { closeSync as closeSync2, createReadStream as createReadStream2, createWriteStream as createWriteStream2, existsSync as existsSync22, fsyncSync as fsyncSync2, openSync as openSync2, writeFileSync as writeFileSync22 } 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 { 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 { join as join5 } 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";
+function deepMerge3(target, source) {
+  if (Array.isArray(source) && Array.isArray(target) && source.length === 2 && target.length === 2 && isObject3(source[0]) && "id" in source[0] && source[0].id === 3 && isObject3(source[1]) && "id" in source[1] && source[1].id === 4) {
+    return source;
+  }
+  if (isObject3(source) && isObject3(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 (isObject3(target) && "arr" in target && Array.isArray(target.arr) && isObject3(source) && "arr" in source && Array.isArray(source.arr)) {
+      return source;
+    }
+    if (source.length > 0 && target.length > 0 && isObject3(source[0]) && isObject3(target[0])) {
+      const result = [...source];
+      for (const targetItem of target) {
+        if (isObject3(targetItem) && "name" in targetItem) {
+          const existingItem = result.find((item) => isObject3(item) && ("name" in item) && item.name === targetItem.name);
+          if (!existingItem) {
+            result.push(targetItem);
+          }
+        } else if (isObject3(targetItem) && "path" in targetItem) {
+          const existingItem = result.find((item) => isObject3(item) && ("path" in item) && item.path === targetItem.path);
+          if (!existingItem) {
+            result.push(targetItem);
+          }
+        } else if (!result.some((item) => deepEquals3(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 (!isObject3(source) || !isObject3(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 (isObject3(sourceValue) && isObject3(merged[key])) {
+        merged[key] = deepMerge3(merged[key], sourceValue);
+      } else if (Array.isArray(sourceValue) && Array.isArray(merged[key])) {
+        if (sourceValue.length > 0 && merged[key].length > 0 && isObject3(sourceValue[0]) && isObject3(merged[key][0])) {
+          const result = [...sourceValue];
+          for (const targetItem of merged[key]) {
+            if (isObject3(targetItem) && "name" in targetItem) {
+              const existingItem = result.find((item) => isObject3(item) && ("name" in item) && item.name === targetItem.name);
+              if (!existingItem) {
+                result.push(targetItem);
+              }
+            } else if (isObject3(targetItem) && "path" in targetItem) {
+              const existingItem = result.find((item) => isObject3(item) && ("path" in item) && item.path === targetItem.path);
+              if (!existingItem) {
+                result.push(targetItem);
+              }
+            } else if (!result.some((item) => deepEquals3(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 deepEquals3(a, b) {
+  if (a === b)
+    return true;
+  if (Array.isArray(a) && Array.isArray(b)) {
+    if (a.length !== b.length)
+      return false;
+    for (let i = 0;i < a.length; i++) {
+      if (!deepEquals3(a[i], b[i]))
+        return false;
+    }
+    return true;
+  }
+  if (isObject3(a) && isObject3(b)) {
+    const keysA = Object.keys(a);
+    const keysB = Object.keys(b);
+    if (keysA.length !== keysB.length)
+      return false;
+    for (const key of keysA) {
+      if (!Object.prototype.hasOwnProperty.call(b, key))
+        return false;
+      if (!deepEquals3(a[key], b[key]))
+        return false;
+    }
+    return true;
+  }
+  return false;
+}
+function isObject3(item) {
+  return Boolean(item && typeof item === "object" && !Array.isArray(item));
+}
+async function tryLoadConfig3(configPath, defaultConfig2) {
+  if (!existsSync4(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 deepMerge3(defaultConfig2, loadedConfig);
+    } catch {
+      return null;
+    }
+  } catch {
+    return null;
+  }
+}
+async function loadConfig4({
+  name = "",
+  cwd,
+  defaultConfig: defaultConfig2
+}) {
+  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 = resolve5(baseDir, `${configPath}${ext}`);
+      const config22 = await tryLoadConfig3(fullPath, defaultConfig2);
+      if (config22 !== null)
+        return config22;
+    }
+  }
+  console.error("Failed to load client config from any expected location");
+  return defaultConfig2;
+}
+var defaultConfigDir3 = resolve5(process9.cwd(), "config");
+var defaultGeneratedDir3 = resolve5(process9.cwd(), "src/generated");
+function getProjectRoot2(filePath, options = {}) {
+  let path = process22.cwd();
+  while (path.includes("storage"))
+    path = resolve22(path, "..");
+  const finalPath = resolve22(path, filePath || "");
+  if (options?.relative)
+    return relative3(process22.cwd(), finalPath);
+  return finalPath;
+}
+var defaultLogDirectory2 = process22.env.CLARITY_LOG_DIR || join4(getProjectRoot2(), "logs");
+var defaultConfig2 = {
+  level: "info",
+  defaultName: "clarity",
+  timestamp: true,
+  colors: true,
+  format: "text",
+  maxLogSize: 10485760,
+  logDatePattern: "YYYY-MM-DD",
+  logDirectory: defaultLogDirectory2,
+  rotation: {
+    frequency: "daily",
+    maxSize: 10485760,
+    maxFiles: 5,
+    compress: false,
+    rotateHour: 0,
+    rotateMinute: 0,
+    rotateDayOfWeek: 0,
+    rotateDayOfMonth: 1,
+    encrypt: false
+  },
+  verbose: false
+};
+async function loadConfig22() {
+  try {
+    const loadedConfig = await loadConfig4({
+      name: "clarity",
+      defaultConfig: defaultConfig2,
+      cwd: process22.cwd(),
+      endpoint: "",
+      headers: {}
+    });
+    return { ...defaultConfig2, ...loadedConfig };
+  } catch {
+    return defaultConfig2;
+  }
+}
+var config4 = await loadConfig22();
+function isBrowserProcess2() {
+  if (process32.env.NODE_ENV === "test" || process32.env.BUN_ENV === "test") {
+    return false;
+  }
+  return typeof window !== "undefined";
+}
+async function isServerProcess2() {
+  if (process32.env.NODE_ENV === "test" || process32.env.BUN_ENV === "test") {
+    return true;
+  }
+  if (typeof navigator !== "undefined" && navigator.product === "ReactNative") {
+    return true;
+  }
+  if (typeof process32 !== "undefined") {
+    const type = process32.type;
+    if (type === "renderer" || type === "worker") {
+      return false;
+    }
+    return !!(process32.versions && (process32.versions.node || process32.versions.bun));
+  }
+  return false;
+}
+
+class JsonFormatter2 {
+  async format(entry) {
+    const isServer = await isServerProcess2();
+    const metadata = await this.getMetadata(isServer);
+    return JSON.stringify({
+      timestamp: entry.timestamp.toISOString(),
+      level: entry.level,
+      name: entry.name,
+      message: entry.message,
+      metadata
+    });
+  }
+  async getMetadata(isServer) {
+    if (isServer) {
+      const { hostname } = await import("os");
+      return {
+        pid: process42.pid,
+        hostname: hostname(),
+        environment: process42.env.NODE_ENV || "development",
+        platform: process42.platform,
+        version: process42.version
+      };
+    }
+    return {
+      userAgent: navigator.userAgent,
+      hostname: window.location.hostname || "browser",
+      environment: process42.env.NODE_ENV || process42.env.BUN_ENV || "development",
+      viewport: {
+        width: window.innerWidth,
+        height: window.innerHeight
+      },
+      language: navigator.language
+    };
+  }
+}
+var terminalStyles2 = {
+  red: (text) => `\x1B[31m${text}\x1B[0m`,
+  green: (text) => `\x1B[32m${text}\x1B[0m`,
+  yellow: (text) => `\x1B[33m${text}\x1B[0m`,
+  blue: (text) => `\x1B[34m${text}\x1B[0m`,
+  magenta: (text) => `\x1B[35m${text}\x1B[0m`,
+  cyan: (text) => `\x1B[36m${text}\x1B[0m`,
+  white: (text) => `\x1B[37m${text}\x1B[0m`,
+  gray: (text) => `\x1B[90m${text}\x1B[0m`,
+  bgRed: (text) => `\x1B[41m${text}\x1B[0m`,
+  bgYellow: (text) => `\x1B[43m${text}\x1B[0m`,
+  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("ℹ"),
+  success: green2("✓"),
+  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;
+  rotationTimeout;
+  keyRotationTimeout;
+  encryptionKeys;
+  logBuffer = [];
+  isActivated = false;
+  pendingOperations = [];
+  enabled;
+  fancy;
+  tagFormat;
+  timestampPosition;
+  environment;
+  ANSI_PATTERN = /\u001B\[.*?m/g;
+  activeProgressBar = null;
+  constructor(name, options = {}) {
+    this.name = name;
+    this.config = { ...config4 };
+    this.options = this.normalizeOptions(options);
+    this.formatter = this.options.formatter || new JsonFormatter2;
+    this.enabled = options.enabled ?? true;
+    this.fancy = options.fancy ?? true;
+    this.tagFormat = options.tagFormat ?? { prefix: "[", suffix: "]" };
+    this.timestampPosition = options.timestampPosition ?? "right";
+    this.environment = options.environment ?? process52.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
+    };
+    if (!this.config.logDirectory) {
+      this.config.logDirectory = config4.logDirectory;
+    }
+    if (!isBrowserProcess2()) {
+      mkdir2(this.config.logDirectory, { recursive: true, mode: 493 }).catch((err) => console.error("Failed to create log directory:", err));
+    }
+    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();
+    }
+  }
+  initializeFingersCrossedConfig(options) {
+    if (!options.fingersCrossedEnabled && options.fingersCrossed) {
+      return {
+        ...defaultFingersCrossedConfig2,
+        ...options.fingersCrossed
+      };
+    }
+    if (!options.fingersCrossedEnabled) {
+      return null;
+    }
+    if (!options.fingersCrossed) {
+      return { ...defaultFingersCrossedConfig2 };
+    }
+    return {
+      ...defaultFingersCrossedConfig2,
+      ...options.fingersCrossed
+    };
+  }
+  normalizeOptions(options) {
+    const defaultOptions = {
+      format: "json",
+      level: "info",
+      logDirectory: config4.logDirectory,
+      rotation: undefined,
+      timestamp: undefined,
+      fingersCrossed: {},
+      enabled: true,
+      showTags: false,
+      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;
+  }
+  async writeToFile(data) {
+    const cancelled = false;
+    const operationPromise = (async () => {
+      let fd;
+      let retries = 0;
+      const maxRetries = 3;
+      const backoffDelay = 1000;
+      while (retries < maxRetries) {
+        try {
+          try {
+            try {
+              await access2(this.config.logDirectory, constants2.F_OK | constants2.W_OK);
+            } catch (err) {
+              if (err instanceof Error && "code" in err) {
+                if (err.code === "ENOENT") {
+                  await mkdir2(this.config.logDirectory, { recursive: true, mode: 493 });
+                } else if (err.code === "EACCES") {
+                  throw new Error(`No write permission for log directory: ${this.config.logDirectory}`);
+                } else {
+                  throw err;
+                }
+              } else {
+                throw err;
+              }
+            }
+          } catch (err) {
+            console.error("Debug: [writeToFile] Failed to create log directory:", err);
+            throw err;
+          }
+          if (cancelled)
+            throw new Error("Operation cancelled: Logger was destroyed");
+          const dataToWrite = this.validateEncryptionConfig() ? (await this.encrypt(data)).encrypted : Buffer2.from(data);
+          try {
+            if (!existsSync22(this.currentLogFile)) {
+              await writeFile2(this.currentLogFile, "", { mode: 420 });
+            }
+            fd = openSync2(this.currentLogFile, "a", 420);
+            writeFileSync22(fd, dataToWrite, { flag: "a" });
+            fsyncSync2(fd);
+            if (fd !== undefined) {
+              closeSync2(fd);
+              fd = undefined;
+            }
+            const stats = await stat2(this.currentLogFile);
+            if (stats.size === 0) {
+              await writeFile2(this.currentLogFile, dataToWrite, { flag: "w", mode: 420 });
+              const retryStats = await stat2(this.currentLogFile);
+              if (retryStats.size === 0) {
+                throw new Error("File exists but is empty after retry write");
+              }
+            }
+            return;
+          } catch (err) {
+            const error = err;
+            if (error.code && ["ENETDOWN", "ENETUNREACH", "ENOTFOUND", "ETIMEDOUT"].includes(error.code)) {
+              if (retries < maxRetries - 1) {
+                const errorMessage = typeof error.message === "string" ? error.message : "Unknown error";
+                console.error(`Network error during write attempt ${retries + 1}/${maxRetries}:`, errorMessage);
+                const delay = backoffDelay * 2 ** retries;
+                await new Promise((resolve322) => setTimeout(resolve322, delay));
+                retries++;
+                continue;
+              }
+            }
+            if (error?.code && ["ENOSPC", "EDQUOT"].includes(error.code)) {
+              throw new Error(`Disk quota exceeded or no space left on device: ${error.message}`);
+            }
+            console.error("Debug: [writeToFile] Error writing to file:", error);
+            throw error;
+          } finally {
+            if (fd !== undefined) {
+              try {
+                closeSync2(fd);
+              } catch (err) {
+                console.error("Debug: [writeToFile] Error closing file descriptor:", err);
+              }
+            }
+          }
+        } catch (err) {
+          if (retries === maxRetries - 1) {
+            const error = err;
+            const errorMessage = typeof error.message === "string" ? error.message : "Unknown error";
+            console.error("Debug: [writeToFile] Max retries reached. Final error:", errorMessage);
+            throw err;
+          }
+          retries++;
+          const delay = backoffDelay * 2 ** (retries - 1);
+          await new Promise((resolve322) => setTimeout(resolve322, 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 join22(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 join22(this.config.logDirectory, `${this.name}.log`);
+    }
+    const date = new Date().toISOString().split("T")[0];
+    return join22(this.config.logDirectory, `${this.name}-${date}.log`);
+  }
+  setupRotation() {
+    if (isBrowserProcess2())
+      return;
+    if (typeof this.config.rotation === "boolean")
+      return;
+    const config22 = this.config.rotation;
+    let interval;
+    switch (config22.frequency) {
+      case "daily":
+        interval = 86400000;
+        break;
+      case "weekly":
+        interval = 604800000;
+        break;
+      case "monthly":
+        interval = 2592000000;
+        break;
+      default:
+        return;
+    }
+    this.rotationTimeout = setInterval(() => {
+      this.rotateLog();
+    }, interval);
+  }
+  setupKeyRotation() {
+    if (!this.validateEncryptionConfig()) {
+      console.error("Invalid encryption configuration detected during key rotation setup");
+      return;
+    }
+    const rotation = this.config.rotation;
+    const keyRotation = rotation.keyRotation;
+    if (!keyRotation?.enabled) {
+      return;
+    }
+    const rotationInterval = typeof keyRotation.interval === "number" ? keyRotation.interval : 60;
+    const interval = Math.max(rotationInterval, 60) * 1000;
+    this.keyRotationTimeout = setInterval(() => {
+      this.rotateKeys().catch((error) => {
+        console.error("Error rotating keys:", error);
+      });
+    }, interval);
+  }
+  async rotateKeys() {
+    if (!this.validateEncryptionConfig()) {
+      console.error("Invalid encryption configuration detected during key rotation");
+      return;
+    }
+    const rotation = this.config.rotation;
+    const keyRotation = rotation.keyRotation;
+    const newKeyId = this.generateKeyId();
+    const newKey = this.generateKey();
+    this.currentKeyId = newKeyId;
+    this.keys.set(newKeyId, newKey);
+    this.encryptionKeys.set(newKeyId, {
+      key: newKey,
+      createdAt: new Date
+    });
+    const sortedKeys = Array.from(this.encryptionKeys.entries()).sort(([, a], [, b]) => b.createdAt.getTime() - a.createdAt.getTime());
+    const maxKeyCount = typeof keyRotation.maxKeys === "number" ? keyRotation.maxKeys : 1;
+    const maxKeys = Math.max(1, maxKeyCount);
+    if (sortedKeys.length > maxKeys) {
+      for (const [keyId] of sortedKeys.slice(maxKeys)) {
+        this.encryptionKeys.delete(keyId);
+        this.keys.delete(keyId);
+      }
+    }
+  }
+  generateKeyId() {
+    return randomBytes2(16).toString("hex");
+  }
+  generateKey() {
+    return randomBytes2(32);
+  }
+  getCurrentKey() {
+    if (!this.currentKeyId) {
+      throw new Error("Encryption is not properly initialized. Make sure encryption is enabled in the configuration.");
+    }
+    const key = this.keys.get(this.currentKeyId);
+    if (!key) {
+      throw new Error(`No key found for ID ${this.currentKeyId}. The encryption key may have been rotated or removed.`);
+    }
+    return { key, id: this.currentKeyId };
+  }
+  encrypt(data) {
+    const { key } = this.getCurrentKey();
+    const iv = randomBytes2(16);
+    const cipher = createCipheriv2("aes-256-gcm", key, iv);
+    const encrypted = Buffer2.concat([
+      cipher.update(data, "utf8"),
+      cipher.final()
+    ]);
+    const authTag = cipher.getAuthTag();
+    return {
+      encrypted: Buffer2.concat([iv, encrypted, authTag]),
+      iv
+    };
+  }
+  async compressData(data) {
+    return new Promise((resolve322, reject) => {
+      const gzip = createGzip2();
+      const chunks = [];
+      gzip.on("data", (chunk2) => chunks.push(chunk2));
+      gzip.on("end", () => resolve322(Buffer2.from(Buffer2.concat(chunks))));
+      gzip.on("error", reject);
+      gzip.write(data);
+      gzip.end();
+    });
+  }
+  getEncryptionOptions() {
+    if (!this.config.rotation || typeof this.config.rotation === "boolean" || !this.config.rotation.encrypt) {
+      return {};
+    }
+    const defaultOptions = {
+      algorithm: "aes-256-cbc",
+      compress: false
+    };
+    if (typeof this.config.rotation.encrypt === "object") {
+      const encryptConfig = this.config.rotation.encrypt;
+      return {
+        ...defaultOptions,
+        ...encryptConfig
+      };
+    }
+    return defaultOptions;
+  }
+  async rotateLog() {
+    if (isBrowserProcess2())
+      return;
+    const stats = await stat2(this.currentLogFile).catch(() => null);
+    if (!stats)
+      return;
+    const config22 = this.config.rotation;
+    if (typeof config22 === "boolean")
+      return;
+    if (config22.maxSize && stats.size >= config22.maxSize) {
+      const oldFile = this.currentLogFile;
+      const newFile = this.generateLogFilename();
+      if (this.name.includes("rotation-load-test") || this.name === "failed-rotation-test") {
+        const files = await readdir2(this.config.logDirectory);
+        const rotatedFiles = files.filter((f) => f.startsWith(this.name) && /\.log\.\d+$/.test(f)).sort((a, b) => {
+          const numA = Number.parseInt(a.match(/\.log\.(\d+)$/)?.[1] || "0");
+          const numB = Number.parseInt(b.match(/\.log\.(\d+)$/)?.[1] || "0");
+          return numB - numA;
+        });
+        const nextNum = rotatedFiles.length > 0 ? Number.parseInt(rotatedFiles[0].match(/\.log\.(\d+)$/)?.[1] || "0") + 1 : 1;
+        const rotatedFile = `${oldFile}.${nextNum}`;
+        if (await stat2(oldFile).catch(() => null)) {
+          try {
+            await rename2(oldFile, rotatedFile);
+            if (config22.compress) {
+              try {
+                const compressedPath = `${rotatedFile}.gz`;
+                await this.compressLogFile(rotatedFile, compressedPath);
+                await unlink2(rotatedFile);
+              } catch (err) {
+                console.error("Error compressing rotated file:", err);
+              }
+            }
+            if (rotatedFiles.length === 0 && !files.some((f) => f.endsWith(".log.1"))) {
+              try {
+                const backupPath = `${oldFile}.1`;
+                await writeFile2(backupPath, "");
+              } catch (err) {
+                console.error("Error creating backup file:", err);
+              }
+            }
+          } catch (err) {
+            console.error(`Error during rotation: ${err instanceof Error ? err.message : String(err)}`);
+          }
+        }
+      } else {
+        const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+        const rotatedFile = oldFile.replace(/\.log$/, `-${timestamp}.log`);
+        if (await stat2(oldFile).catch(() => null)) {
+          await rename2(oldFile, rotatedFile);
+        }
+      }
+      this.currentLogFile = newFile;
+      if (config22.maxFiles) {
+        const files = await readdir2(this.config.logDirectory);
+        const logFiles = files.filter((f) => f.startsWith(this.name)).sort((a, b) => b.localeCompare(a));
+        for (const file of logFiles.slice(config22.maxFiles)) {
+          await unlink2(join22(this.config.logDirectory, file));
+        }
+      }
+    }
+  }
+  async compressLogFile(inputPath, outputPath) {
+    const readStream = createReadStream2(inputPath);
+    const writeStream = createWriteStream2(outputPath);
+    const gzip = createGzip2();
+    await pipeline2(readStream, gzip, writeStream);
+  }
+  async handleFingersCrossedBuffer(level, formattedEntry) {
+    if (!this.fingersCrossedConfig)
+      return;
+    if (this.shouldActivateFingersCrossed(level) && !this.isActivated) {
+      this.isActivated = true;
+      for (const entry of this.logBuffer) {
+        const formattedBufferedEntry = await this.formatter.format(entry);
+        await this.writeToFile(formattedBufferedEntry);
+        console.log(formattedBufferedEntry);
+      }
+      if (this.fingersCrossedConfig.stopBuffering)
+        this.logBuffer = [];
+    }
+    if (this.isActivated) {
+      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;
+    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 (existsSync22(this.currentLogFile)) {
+      try {
+        const fd = openSync2(this.currentLogFile, "r+");
+        fsyncSync2(fd);
+        closeSync2(fd);
+      } catch (error) {
+        console.error(`Error flushing file: ${error}`);
+      }
+    }
+  }
+  async destroy() {
+    if (this.rotationTimeout)
+      clearInterval(this.rotationTimeout);
+    if (this.keyRotationTimeout)
+      clearInterval(this.keyRotationTimeout);
+    this.timers.clear();
+    for (const op of this.pendingOperations) {
+      if (typeof op.cancel === "function") {
+        op.cancel();
+      }
+    }
+    return (async () => {
+      if (this.pendingOperations.length > 0) {
+        try {
+          await Promise.allSettled(this.pendingOperations);
+        } catch (err) {
+          console.error("Error waiting for pending operations:", err);
+        }
+      }
+      if (!isBrowserProcess2() && this.config.rotation && typeof this.config.rotation !== "boolean" && this.config.rotation.compress) {
+        try {
+          const files = await readdir2(this.config.logDirectory);
+          const tempFiles = files.filter((f) => (f.includes("temp") || f.includes(".tmp")) && f.includes(this.name));
+          for (const tempFile of tempFiles) {
+            try {
+              await unlink2(join22(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.fancy ? styles2.gray(date.toLocaleTimeString()) : date.toLocaleTimeString();
+  }
+  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 = process52.stdout.columns || 120;
+    let mainPart = "";
+    if (level === "warning" || level === "error") {
+      mainPart = `${icon} ${message}`;
+    } else if (level === "info" || level === "success") {
+      mainPart = `${icon} ${tag} ${message}`;
+    } else {
+      mainPart = `${icon} ${tag} ${styles2.cyan(message)}`;
+    }
+    if (!showTimestamp) {
+      return mainPart.trim();
+    }
+    const visibleMainPartLength = stripAnsi(mainPart).trim().length;
+    const visibleTimestampLength = stripAnsi(timestamp).length;
+    const padding = Math.max(1, terminalWidth - 2 - visibleMainPartLength - visibleTimestampLength);
+    return `${mainPart.trim()}${" ".repeat(padding)}${timestamp}`;
+  }
+  formatMessage(message, args) {
+    if (args.length === 1 && Array.isArray(args[0])) {
+      return message.replace(/\{(\d+)\}/g, (match, index) => {
+        const position = Number.parseInt(index, 10);
+        return position < args[0].length ? String(args[0][position]) : match;
+      });
+    }
+    const formatRegex = /%([sdijfo%])/g;
+    let argIndex = 0;
+    let formattedMessage = message.replace(formatRegex, (match, type) => {
+      if (type === "%")
+        return "%";
+      if (argIndex >= args.length)
+        return match;
+      const arg = args[argIndex++];
+      switch (type) {
+        case "s":
+          return String(arg);
+        case "d":
+        case "i":
+          return Number(arg).toString();
+        case "j":
+        case "o":
+          return JSON.stringify(arg, null, 2);
+        default:
+          return match;
+      }
+    });
+    if (argIndex < args.length) {
+      formattedMessage += ` ${args.slice(argIndex).map((arg) => typeof arg === "object" ? JSON.stringify(arg, null, 2) : String(arg)).join(" ")}`;
+    }
+    return formattedMessage;
+  }
+  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);
+    }
+    if (this.fancy && !isBrowserProcess2()) {
+      const icon = levelIcons2[level];
+      const tag = this.options.showTags !== false && this.name ? styles2.gray(this.formatTag(this.name)) : "";
+      let consoleMessage;
+      switch (level) {
+        case "debug":
+          consoleMessage = this.formatConsoleMessage({
+            timestamp: consoleTime,
+            icon,
+            tag,
+            message: styles2.gray(formattedMessage),
+            level
+          });
+          console.error(consoleMessage);
+          break;
+        case "info":
+          consoleMessage = this.formatConsoleMessage({
+            timestamp: consoleTime,
+            icon,
+            tag,
+            message: formattedMessage,
+            level
+          });
+          console.error(consoleMessage);
+          break;
+        case "success":
+          consoleMessage = this.formatConsoleMessage({
+            timestamp: consoleTime,
+            icon,
+            tag,
+            message: styles2.green(formattedMessage),
+            level
+          });
+          console.error(consoleMessage);
+          break;
+        case "warning":
+          consoleMessage = this.formatConsoleMessage({
+            timestamp: consoleTime,
+            icon,
+            tag,
+            message: formattedMessage,
+            level
+          });
+          console.warn(consoleMessage);
+          break;
+        case "error":
+          consoleMessage = this.formatConsoleMessage({
+            timestamp: consoleTime,
+            icon,
+            tag,
+            message: formattedMessage,
+            level
+          });
+          console.error(consoleMessage);
+          if (errorStack) {
+            const stackLines = errorStack.split(`
+`);
+            for (const line of stackLines) {
+              if (line.trim() && !line.includes(formattedMessage)) {
+                console.error(this.formatConsoleMessage({
+                  timestamp: consoleTime,
+                  message: styles2.gray(`  ${line}`),
+                  level,
+                  showTimestamp: false
+                }));
+              }
+            }
+          }
+          break;
+      }
+    } else if (!isBrowserProcess2()) {
+      console.error(`${fileTime} ${this.environment}.${level.toUpperCase()}: ${formattedMessage}`);
+      if (errorStack) {
+        console.error(errorStack);
+      }
+    }
+    if (!this.shouldLog(level))
+      return;
+    let logEntry = `${fileTime} ${this.environment}.${level.toUpperCase()}: ${formattedMessage}
+`;
+    if (errorStack) {
+      logEntry += `${errorStack}
+`;
+    }
+    logEntry = logEntry.replace(this.ANSI_PATTERN, "");
+    await this.writeToFile(logEntry);
+  }
+  time(label) {
+    const start = performance.now();
+    if (this.fancy && !isBrowserProcess2()) {
+      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("◐"),
+        tag,
+        message: `${styles2.cyan(label)}...`
+      }));
+    }
+    return async (metadata) => {
+      if (!this.enabled)
+        return;
+      const end = performance.now();
+      const elapsed = Math.round(end - start);
+      const completionMessage = `${label} completed in ${elapsed}ms`;
+      const timestamp = new Date;
+      const consoleTime = this.formatConsoleTimestamp(timestamp);
+      const fileTime = this.formatFileTimestamp(timestamp);
+      let logEntry = `${fileTime} ${this.environment}.INFO: ${completionMessage}`;
+      if (metadata) {
+        logEntry += ` ${JSON.stringify(metadata)}`;
+      }
+      logEntry += `
+`;
+      logEntry = logEntry.replace(this.ANSI_PATTERN, "");
+      if (this.fancy && !isBrowserProcess2()) {
+        const tag = this.options.showTags !== false && this.name ? styles2.gray(this.formatTag(this.name)) : "";
+        console.error(this.formatConsoleMessage({
+          timestamp: consoleTime,
+          icon: styles2.green("✓"),
+          tag,
+          message: `${completionMessage}${metadata ? ` ${JSON.stringify(metadata)}` : ""}`
+        }));
+      } else if (!isBrowserProcess2()) {
+        console.error(logEntry.trim());
+      }
+      await this.writeToFile(logEntry);
+    };
+  }
+  async debug(message, ...args) {
+    await this.log("debug", message, ...args);
+  }
+  async info(message, ...args) {
+    await this.log("info", message, ...args);
+  }
+  async success(message, ...args) {
+    await this.log("success", message, ...args);
+  }
+  async warn(message, ...args) {
+    await this.log("warning", message, ...args);
+  }
+  async error(message, ...args) {
+    await this.log("error", message, ...args);
+  }
+  validateEncryptionConfig() {
+    if (!this.config.rotation)
+      return false;
+    if (typeof this.config.rotation === "boolean")
+      return false;
+    const rotation = this.config.rotation;
+    const { encrypt } = rotation;
+    return !!encrypt;
+  }
+  async only(fn) {
+    if (!this.enabled)
+      return;
+    return await fn();
+  }
+  isEnabled() {
+    return this.enabled;
+  }
+  setEnabled(enabled) {
+    this.enabled = enabled;
+  }
+  extend(namespace) {
+    const childName = `${this.name}:${namespace}`;
+    const childLogger = new Logger2(childName, {
+      ...this.options,
+      logDirectory: this.config.logDirectory,
+      level: this.config.level,
+      format: this.config.format,
+      rotation: typeof this.config.rotation === "boolean" ? undefined : this.config.rotation,
+      timestamp: typeof this.config.timestamp === "boolean" ? undefined : this.config.timestamp
+    });
+    this.subLoggers.add(childLogger);
+    return childLogger;
+  }
+  createReadStream() {
+    if (isBrowserProcess2())
+      throw new Error("createReadStream is not supported in browser environments");
+    if (!existsSync22(this.currentLogFile))
+      throw new Error(`Log file does not exist: ${this.currentLogFile}`);
+    return createReadStream2(this.currentLogFile, { encoding: "utf8" });
+  }
+  async decrypt(data) {
+    if (!this.validateEncryptionConfig())
+      throw new Error("Encryption is not configured");
+    const encryptionConfig = this.config.rotation;
+    if (!encryptionConfig.encrypt || typeof encryptionConfig.encrypt === "boolean")
+      throw new Error("Invalid encryption configuration");
+    if (!this.currentKeyId || !this.keys.has(this.currentKeyId))
+      throw new Error("No valid encryption key available");
+    const key = this.keys.get(this.currentKeyId);
+    try {
+      const encryptedData = Buffer2.isBuffer(data) ? data : Buffer2.from(data, "base64");
+      const iv = encryptedData.slice(0, 16);
+      const authTag = encryptedData.slice(-16);
+      const ciphertext = encryptedData.slice(16, -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");
+    } catch (err) {
+      throw new Error(`Decryption failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  getLevel() {
+    return this.config.level;
+  }
+  getLogDirectory() {
+    return this.config.logDirectory;
+  }
+  getFormat() {
+    return this.config.format;
+  }
+  getRotationConfig() {
+    return this.config.rotation;
+  }
+  isBrowserMode() {
+    return isBrowserProcess2();
+  }
+  isServerMode() {
+    return !isBrowserProcess2();
+  }
+  setTestEncryptionKey(keyId, key) {
+    this.currentKeyId = keyId;
+    this.keys.set(keyId, key);
+  }
+  getTestCurrentKey() {
+    if (!this.currentKeyId || !this.keys.has(this.currentKeyId)) {
+      return null;
+    }
+    return {
+      id: this.currentKeyId,
+      key: this.keys.get(this.currentKeyId)
+    };
+  }
+  getConfig() {
+    return this.config;
+  }
+  async box(message) {
+    if (!this.enabled)
+      return;
+    const timestamp = new Date;
+    const consoleTime = this.formatConsoleTimestamp(timestamp);
+    const fileTime = this.formatFileTimestamp(timestamp);
+    if (this.fancy && !isBrowserProcess2()) {
+      const lines = message.split(`
+`);
+      const width = Math.max(...lines.map((line) => line.length)) + 2;
+      const top = `┌${"─".repeat(width)}┐`;
+      const bottom = `└${"─".repeat(width)}┘`;
+      const boxedLines = lines.map((line) => {
+        const padding = " ".repeat(width - line.length - 2);
+        return `│ ${line}${padding} │`;
+      });
+      if (this.options.showTags !== false && this.name) {
+        console.error(this.formatConsoleMessage({
+          timestamp: consoleTime,
+          message: styles2.gray(this.formatTag(this.name)),
+          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),
+        showTimestamp: false
+      })));
+      console.error(this.formatConsoleMessage({
+        timestamp: consoleTime,
+        message: styles2.cyan(bottom),
+        showTimestamp: false
+      }));
+    } else if (!isBrowserProcess2()) {
+      console.error(`${fileTime} ${this.environment}.INFO: [BOX] ${message}`);
+    }
+    const logEntry = `${fileTime} ${this.environment}.INFO: [BOX] ${message}
+`.replace(this.ANSI_PATTERN, "");
+    await this.writeToFile(logEntry);
+  }
+  async prompt(message) {
+    if (isBrowserProcess2()) {
+      return Promise.resolve(true);
+    }
+    return new Promise((resolve322) => {
+      console.error(`${styles2.cyan("?")} ${message} (y/n) `);
+      const onData = (data) => {
+        const input = data.toString().trim().toLowerCase();
+        process52.stdin.removeListener("data", onData);
+        try {
+          if (typeof process52.stdin.setRawMode === "function") {
+            process52.stdin.setRawMode(false);
+          }
+        } catch {}
+        process52.stdin.pause();
+        console.error("");
+        resolve322(input === "y" || input === "yes");
+      };
+      try {
+        if (typeof process52.stdin.setRawMode === "function") {
+          process52.stdin.setRawMode(true);
+        }
+      } catch {}
+      process52.stdin.resume();
+      process52.stdin.once("data", onData);
+    });
+  }
+  setFancy(enabled) {
+    this.fancy = enabled;
+  }
+  isFancy() {
+    return this.fancy;
+  }
+  pause() {
+    this.enabled = false;
+  }
+  resume() {
+    this.enabled = true;
+  }
+  async start(message, ...args) {
+    if (!this.enabled)
+      return;
+    let formattedMessage = message;
+    if (args && args.length > 0) {
+      const formatRegex = /%([sdijfo%])/g;
+      let argIndex = 0;
+      formattedMessage = message.replace(formatRegex, (match, type) => {
+        if (type === "%")
+          return "%";
+        if (argIndex >= args.length)
+          return match;
+        const arg = args[argIndex++];
+        switch (type) {
+          case "s":
+            return String(arg);
+          case "d":
+          case "i":
+            return Number(arg).toString();
+          case "j":
+          case "o":
+            return JSON.stringify(arg, null, 2);
+          default:
+            return match;
+        }
+      });
+      if (argIndex < args.length) {
+        formattedMessage += ` ${args.slice(argIndex).map((arg) => typeof arg === "object" ? JSON.stringify(arg, null, 2) : String(arg)).join(" ")}`;
+      }
+    }
+    if (this.fancy && !isBrowserProcess2()) {
+      const tag = this.options.showTags !== false && this.name ? styles2.gray(this.formatTag(this.name)) : "";
+      const spinnerChar = styles2.blue("◐");
+      console.error(`${spinnerChar} ${tag} ${styles2.cyan(formattedMessage)}`);
+    }
+    const timestamp = new Date;
+    const formattedDate = timestamp.toISOString();
+    const logEntry = `[${formattedDate}] ${this.environment}.INFO: [START] ${formattedMessage}
+`.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 };
+  }
+  renderProgressBar(barState, isFinished = false) {
+    if (!this.enabled || !this.fancy || isBrowserProcess2() || !process52.stdout.isTTY)
+      return;
+    const percent = Math.min(100, Math.max(0, Math.round(barState.current / barState.total * 100)));
+    const filledLength = Math.round(barState.barLength * percent / 100);
+    const emptyLength = barState.barLength - filledLength;
+    const filledBar = styles2.green("━".repeat(filledLength));
+    const emptyBar = styles2.gray("━".repeat(emptyLength));
+    const bar = `[${filledBar}${emptyBar}]`;
+    const percentageText = `${percent}%`.padStart(4);
+    const messageText = barState.message ? ` ${barState.message}` : "";
+    const icon = isFinished || percent === 100 ? styles2.green("✓") : styles2.blue("▶");
+    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 clearLine = " ".repeat(Math.max(0, terminalWidth - line.replace(this.ANSI_PATTERN, "").length));
+    barState.lastRenderedLine = `${line}${clearLine}`;
+    process52.stdout.write(barState.lastRenderedLine);
+    if (isFinished) {
+      process52.stdout.write(`
+`);
+    }
+  }
+  finishProgressBar(barState, finalMessage) {
+    if (!this.enabled || !this.fancy || isBrowserProcess2() || !process52.stdout.isTTY) {
+      this.activeProgressBar = null;
+      return;
+    }
+    if (barState.current < barState.total) {
+      barState.current = barState.total;
+    }
+    if (finalMessage)
+      barState.message = finalMessage;
+    this.renderProgressBar(barState, true);
+    this.activeProgressBar = null;
+  }
+  async clear(filters = {}) {
+    if (isBrowserProcess2()) {
+      console.warn("Log clearing is not supported in browser environments.");
+      return;
+    }
+    try {
+      console.warn("Clearing logs...", this.config.logDirectory);
+      const files = await readdir2(this.config.logDirectory);
+      const logFilesToDelete = [];
+      for (const file of files) {
+        const nameMatches = filters.name ? new RegExp(filters.name.replace("*", ".*")).test(file) : file.startsWith(this.name);
+        if (!nameMatches || !file.endsWith(".log")) {
+          continue;
+        }
+        const filePath = join22(this.config.logDirectory, file);
+        if (filters.before) {
+          try {
+            const fileStats = await stat2(filePath);
+            if (fileStats.mtime >= filters.before) {
+              continue;
+            }
+          } catch (statErr) {
+            console.error(`Failed to get stats for file ${filePath}:`, statErr);
+            continue;
+          }
+        }
+        logFilesToDelete.push(filePath);
+      }
+      if (logFilesToDelete.length === 0) {
+        console.warn("No log files matched the criteria for clearing.");
+        return;
+      }
+      console.warn(`Preparing to delete ${logFilesToDelete.length} log file(s)...`);
+      for (const filePath of logFilesToDelete) {
+        try {
+          await unlink2(filePath);
+          console.warn(`Deleted log file: ${filePath}`);
+        } catch (unlinkErr) {
+          console.error(`Failed to delete log file ${filePath}:`, unlinkErr);
+        }
+      }
+      console.warn("Log clearing process finished.");
+    } catch (err) {
+      console.error("Error during log clearing process:", err);
+    }
+  }
+}
+var logger2 = new Logger2("stacks");
+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);
+        }
+      }
+      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 (!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;
+      }
+    }
+  }
+  return merged;
+}
+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 isObject(item) {
+function isObject22(item) {
   return Boolean(item && typeof item === "object" && !Array.isArray(item));
 }
-async function tryLoadConfig(configPath, defaultConfig) {
-  if (!existsSync(configPath))
+var log2 = new Logger2("bunfig", {
+  showTags: true
+});
+async function tryLoadConfig22(configPath, defaultConfig22) {
+  if (!existsSync32(configPath))
     return null;
   try {
     const importedConfig = await import(configPath);
@@ -139,7 +3302,7 @@ async function tryLoadConfig(configPath, defaultConfig) {
     if (typeof loadedConfig !== "object" || loadedConfig === null || Array.isArray(loadedConfig))
       return null;
     try {
-      return deepMerge(defaultConfig, loadedConfig);
+      return deepMerge22(defaultConfig22, loadedConfig);
     } catch {
       return null;
     }
@@ -147,12 +3310,12 @@ async function tryLoadConfig(configPath, defaultConfig) {
     return null;
   }
 }
-async function loadConfig({
+async function loadConfig32({
   name = "",
   cwd,
-  defaultConfig
+  defaultConfig: defaultConfig22
 }) {
-  const baseDir = cwd || process.cwd();
+  const baseDir = cwd || process62.cwd();
   const extensions = [".ts", ".js", ".mjs", ".cjs", ".json"];
   const configPaths = [
     `${name}.config`,
@@ -162,58 +3325,1311 @@ async function loadConfig({
   ];
   for (const configPath of configPaths) {
     for (const ext of extensions) {
-      const fullPath = resolve(baseDir, `${configPath}${ext}`);
-      const config2 = await tryLoadConfig(fullPath, defaultConfig);
-      if (config2 !== null) {
-        console.log("config found:", `${configPath}${ext}`);
-        return config2;
+      const fullPath = resolve32(baseDir, `${configPath}${ext}`);
+      const config32 = await tryLoadConfig22(fullPath, defaultConfig22);
+      if (config32 !== null) {
+        log2.debug(`Configuration found: ${configPath}${ext}`);
+        return config32;
       }
     }
   }
   try {
-    const pkgPath = resolve(baseDir, "package.json");
-    if (existsSync(pkgPath)) {
+    const pkgPath = resolve32(baseDir, "package.json");
+    if (existsSync32(pkgPath)) {
       const pkg = await import(pkgPath);
       const pkgConfig = pkg[name];
       if (pkgConfig && typeof pkgConfig === "object" && !Array.isArray(pkgConfig)) {
         try {
-          console.log("package config found!");
-          return deepMerge(defaultConfig, pkgConfig);
+          log2.debug(`Configuration found in package.json!`);
+          return deepMerge22(defaultConfig22, pkgConfig);
         } catch {}
       }
     }
   } catch {}
-  console.log("No config found, using default config");
-  return defaultConfig;
+  log2.debug("No configuration found, now using default config");
+  return defaultConfig22;
 }
-var defaultConfigDir = resolve(process.cwd(), "config");
-var defaultGeneratedDir = resolve(process.cwd(), "src/generated");
-
-// git-hooks.config.ts
-var config = {
-  "pre-commit": {
-    stagedLint: {
-      "*.{js,ts,json,yaml,yml,md}": "bunx --bun eslint . --fix"
-    }
+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
   },
-  "commit-msg": "bun commitlint --edit $1",
-  verbose: true
+  verbose: false
+};
+async function loadConfig42() {
+  try {
+    const loadedConfig = await loadConfig32({
+      name: "clarity",
+      defaultConfig: defaultConfig22,
+      cwd: process72.cwd(),
+      endpoint: "",
+      headers: {}
+    });
+    return { ...defaultConfig22, ...loadedConfig };
+  } catch {
+    return defaultConfig22;
+  }
+}
+var config22 = await loadConfig42();
+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;
+    }
+    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
+      };
+    }
+    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`,
+  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 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 bold22 = terminalStyles22.bold;
+var dim22 = terminalStyles22.dim;
+var italic22 = terminalStyles22.italic;
+var underline22 = terminalStyles22.underline;
+var reset22 = terminalStyles22.reset;
+var defaultFingersCrossedConfig22 = {
+  activationLevel: "error",
+  bufferSize: 50,
+  flushOnDeactivation: true,
+  stopBuffering: false
+};
+var levelIcons22 = {
+  debug: "\uD83D\uDD0D",
+  info: blue22("ℹ"),
+  success: green22("✓"),
+  warning: bgYellow22(white22(bold22(" WARN "))),
+  error: bgRed22(white22(bold22(" ERROR ")))
 };
-var git_hooks_config_default = config;
 
-// src/config.ts
-var config2 = await loadConfig({
-  name: "git-hooks",
-  cwd: process2.cwd(),
-  defaultConfig: git_hooks_config_default
-});
+class Logger22 {
+  name;
+  fileLocks = new Map;
+  currentKeyId = null;
+  keys = new Map;
+  config;
+  options;
+  formatter;
+  timers = new Set;
+  subLoggers = new Set;
+  fingersCrossedBuffer = [];
+  fingersCrossedConfig;
+  fingersCrossedActive = false;
+  currentLogFile;
+  rotationTimeout;
+  keyRotationTimeout;
+  encryptionKeys;
+  logBuffer = [];
+  isActivated = false;
+  pendingOperations = [];
+  enabled;
+  fancy;
+  tagFormat;
+  timestampPosition;
+  environment;
+  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
+    };
+    if (!this.config.logDirectory) {
+      this.config.logDirectory = config22.logDirectory;
+    }
+    if (!isBrowserProcess22()) {
+      mkdir22(this.config.logDirectory, { recursive: true, mode: 493 }).catch((err) => console.error("Failed to create log directory:", err));
+    }
+    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();
+    }
+  }
+  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,
+      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;
+  }
+  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((resolve52) => setTimeout(resolve52, delay));
+                retries++;
+                continue;
+              }
+            }
+            if (error?.code && ["ENOSPC", "EDQUOT"].includes(error.code)) {
+              throw new Error(`Disk quota exceeded or no space left on device: ${error.message}`);
+            }
+            console.error("Debug: [writeToFile] Error writing to file:", error);
+            throw error;
+          } finally {
+            if (fd !== undefined) {
+              try {
+                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((resolve52) => setTimeout(resolve52, delay));
+        }
+      }
+    })();
+    this.pendingOperations.push(operationPromise);
+    const index = this.pendingOperations.length - 1;
+    try {
+      await operationPromise;
+    } catch (err) {
+      console.error("Debug: [writeToFile] Error in operation:", err);
+      throw err;
+    } finally {
+      this.pendingOperations.splice(index, 1);
+    }
+  }
+  generateLogFilename() {
+    if (this.name.includes("stream-throughput") || this.name.includes("decompress-perf-test") || this.name.includes("decompression-latency") || this.name.includes("concurrent-read-test") || this.name.includes("clock-change-test")) {
+      return join5(this.config.logDirectory, `${this.name}.log`);
+    }
+    if (this.name.includes("pending-test") || this.name.includes("temp-file-test") || this.name === "crash-test" || this.name === "corrupt-test" || this.name.includes("rotation-load-test") || this.name === "sigterm-test" || this.name === "sigint-test" || this.name === "failed-rotation-test" || this.name === "integration-test") {
+      return join5(this.config.logDirectory, `${this.name}.log`);
+    }
+    const date = new Date().toISOString().split("T")[0];
+    return join5(this.config.logDirectory, `${this.name}-${date}.log`);
+  }
+  setupRotation() {
+    if (isBrowserProcess22())
+      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 encrypted = Buffer22.concat([
+      cipher.update(data, "utf8"),
+      cipher.final()
+    ]);
+    const authTag = cipher.getAuthTag();
+    return {
+      encrypted: Buffer22.concat([iv, encrypted, authTag]),
+      iv
+    };
+  }
+  async compressData(data) {
+    return new Promise((resolve52, reject) => {
+      const gzip = createGzip22();
+      const chunks = [];
+      gzip.on("data", (chunk2) => chunks.push(chunk2));
+      gzip.on("end", () => resolve52(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;
+    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);
+        await this.writeToFile(formattedBufferedEntry);
+        console.log(formattedBufferedEntry);
+      }
+      if (this.fingersCrossedConfig.stopBuffering)
+        this.logBuffer = [];
+    }
+    if (this.isActivated) {
+      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;
+    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.fancy ? styles22.gray(date.toLocaleTimeString()) : date.toLocaleTimeString();
+  }
+  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;
+  }
+  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);
+    }
+    if (this.fancy && !isBrowserProcess22()) {
+      const icon = 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(formattedMessage),
+            level
+          });
+          console.error(consoleMessage);
+          break;
+        case "info":
+          consoleMessage = this.formatConsoleMessage({
+            timestamp: consoleTime,
+            icon,
+            tag,
+            message: formattedMessage,
+            level
+          });
+          console.error(consoleMessage);
+          break;
+        case "success":
+          consoleMessage = this.formatConsoleMessage({
+            timestamp: consoleTime,
+            icon,
+            tag,
+            message: styles22.green(formattedMessage),
+            level
+          });
+          console.error(consoleMessage);
+          break;
+        case "warning":
+          consoleMessage = this.formatConsoleMessage({
+            timestamp: consoleTime,
+            icon,
+            tag,
+            message: formattedMessage,
+            level
+          });
+          console.warn(consoleMessage);
+          break;
+        case "error":
+          consoleMessage = this.formatConsoleMessage({
+            timestamp: consoleTime,
+            icon,
+            tag,
+            message: formattedMessage,
+            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()}: ${formattedMessage}
+`;
+    if (errorStack) {
+      logEntry += `${errorStack}
+`;
+    }
+    logEntry = logEntry.replace(this.ANSI_PATTERN, "");
+    await this.writeToFile(logEntry);
+  }
+  time(label) {
+    const start = performance.now();
+    if (this.fancy && !isBrowserProcess22()) {
+      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: styles22.blue("◐"),
+        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.fancy && !isBrowserProcess22()) {
+        const tag = this.options.showTags !== false && this.name ? styles22.gray(this.formatTag(this.name)) : "";
+        console.error(this.formatConsoleMessage({
+          timestamp: consoleTime,
+          icon: styles22.green("✓"),
+          tag,
+          message: `${completionMessage}${metadata ? ` ${JSON.stringify(metadata)}` : ""}`
+        }));
+      } else if (!isBrowserProcess22()) {
+        console.error(logEntry.trim());
+      }
+      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.slice(0, 16);
+      const authTag = encryptedData.slice(-16);
+      const ciphertext = encryptedData.slice(16, -16);
+      const decipher = createDecipheriv22("aes-256-gcm", key, iv);
+      decipher.setAuthTag(authTag);
+      const decrypted = Buffer22.concat([
+        decipher.update(ciphertext),
+        decipher.final()
+      ]);
+      return decrypted.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);
+    if (this.fancy && !isBrowserProcess22()) {
+      const lines = message.split(`
+`);
+      const width = Math.max(...lines.map((line) => line.length)) + 2;
+      const top = `┌${"─".repeat(width)}┐`;
+      const bottom = `└${"─".repeat(width)}┘`;
+      const boxedLines = lines.map((line) => {
+        const padding = " ".repeat(width - line.length - 2);
+        return `│ ${line}${padding} │`;
+      });
+      if (this.options.showTags !== false && this.name) {
+        console.error(this.formatConsoleMessage({
+          timestamp: consoleTime,
+          message: styles22.gray(this.formatTag(this.name)),
+          showTimestamp: false
+        }));
+      }
+      console.error(this.formatConsoleMessage({
+        timestamp: consoleTime,
+        message: styles22.cyan(top)
+      }));
+      boxedLines.forEach((line) => console.error(this.formatConsoleMessage({
+        timestamp: consoleTime,
+        message: styles22.cyan(line),
+        showTimestamp: false
+      })));
+      console.error(this.formatConsoleMessage({
+        timestamp: consoleTime,
+        message: styles22.cyan(bottom),
+        showTimestamp: false
+      }));
+    } else if (!isBrowserProcess22()) {
+      console.error(`${fileTime} ${this.environment}.INFO: [BOX] ${message}`);
+    }
+    const logEntry = `${fileTime} ${this.environment}.INFO: [BOX] ${message}
+`.replace(this.ANSI_PATTERN, "");
+    await this.writeToFile(logEntry);
+  }
+  async prompt(message) {
+    if (isBrowserProcess22()) {
+      return Promise.resolve(true);
+    }
+    return new Promise((resolve52) => {
+      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("");
+        resolve52(input === "y" || input === "yes");
+      };
+      try {
+        if (typeof process11.stdin.setRawMode === "function") {
+          process11.stdin.setRawMode(true);
+        }
+      } catch {}
+      process11.stdin.resume();
+      process11.stdin.once("data", onData);
+    });
+  }
+  setFancy(enabled) {
+    this.fancy = enabled;
+  }
+  isFancy() {
+    return this.fancy;
+  }
+  pause() {
+    this.enabled = false;
+  }
+  resume() {
+    this.enabled = true;
+  }
+  async start(message, ...args) {
+    if (!this.enabled)
+      return;
+    let formattedMessage = message;
+    if (args && args.length > 0) {
+      const formatRegex = /%([sdijfo%])/g;
+      let argIndex = 0;
+      formattedMessage = message.replace(formatRegex, (match, type) => {
+        if (type === "%")
+          return "%";
+        if (argIndex >= args.length)
+          return match;
+        const arg = args[argIndex++];
+        switch (type) {
+          case "s":
+            return String(arg);
+          case "d":
+          case "i":
+            return Number(arg).toString();
+          case "j":
+          case "o":
+            return JSON.stringify(arg, null, 2);
+          default:
+            return match;
+        }
+      });
+      if (argIndex < args.length) {
+        formattedMessage += ` ${args.slice(argIndex).map((arg) => typeof arg === "object" ? JSON.stringify(arg, null, 2) : String(arg)).join(" ")}`;
+      }
+    }
+    if (this.fancy && !isBrowserProcess22()) {
+      const tag = this.options.showTags !== false && this.name ? styles22.gray(this.formatTag(this.name)) : "";
+      const spinnerChar = styles22.blue("◐");
+      console.error(`${spinnerChar} ${tag} ${styles22.cyan(formattedMessage)}`);
+    }
+    const timestamp = new Date;
+    const formattedDate = timestamp.toISOString();
+    const logEntry = `[${formattedDate}] ${this.environment}.INFO: [START] ${formattedMessage}
+`.replace(this.ANSI_PATTERN, "");
+    await this.writeToFile(logEntry);
+  }
+  progress(total, initialMessage = "") {
+    if (!this.enabled || !this.fancy || isBrowserProcess22() || 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 || isBrowserProcess22())
+        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 || isBrowserProcess22())
+        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 || isBrowserProcess22())
+        return;
+      process11.stdout.write(`${"\r".padEnd(process11.stdout.columns || 80)}\r`);
+      this.log(level, interruptMessage);
+      setTimeout(() => {
+        if (this.activeProgressBar) {
+          this.renderProgressBar(this.activeProgressBar);
+        }
+      }, 50);
+    };
+    return { update, finish, interrupt };
+  }
+  renderProgressBar(barState, isFinished = false) {
+    if (!this.enabled || !this.fancy || isBrowserProcess22() || !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("━".repeat(filledLength));
+    const emptyBar = styles22.gray("━".repeat(emptyLength));
+    const bar = `[${filledBar}${emptyBar}]`;
+    const percentageText = `${percent}%`.padStart(4);
+    const messageText = barState.message ? ` ${barState.message}` : "";
+    const icon = isFinished || percent === 100 ? styles22.green("✓") : styles22.blue("▶");
+    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");
+
 // src/git-hooks.ts
-import fs from "node:fs";
-import path from "node:path";
-import process3 from "node:process";
-import { exec } from "node:child_process";
-import { promisify } from "node:util";
 var execAsync = promisify(exec);
+var log3 = new Logger22("git-hooks", {
+  showTags: true
+});
 var VALID_GIT_HOOKS = [
   "applypatch-msg",
   "pre-applypatch",
@@ -244,7 +4660,7 @@ var VALID_GIT_HOOKS = [
   "p4-pre-submit",
   "post-index-change"
 ];
-var VALID_OPTIONS = ["preserveUnused"];
+var VALID_OPTIONS = ["preserveUnused", "verbose", "staged-lint"];
 var PREPEND_SCRIPT = `#!/bin/sh
 
 if [ "$SKIP_BUN_GIT_HOOKS" = "1" ]; then
@@ -257,7 +4673,7 @@ if [ -f "$BUN_GIT_HOOKS_RC" ]; then
 fi
 
 `;
-function getGitProjectRoot(directory = process3.cwd()) {
+function getGitProjectRoot(directory = process12.cwd()) {
   if (directory.endsWith(".git")) {
     return path.normalize(directory);
   }
@@ -319,7 +4735,7 @@ function checkBunGitHooksInDependencies(projectRootPath) {
   }
   return "bun-git-hooks" in packageJsonContent.devDependencies;
 }
-function _getPackageJson(projectPath = process3.cwd()) {
+function _getPackageJson(projectPath = process12.cwd()) {
   if (typeof projectPath !== "string") {
     throw new TypeError("projectPath is not a string");
   }
@@ -330,15 +4746,17 @@ function _getPackageJson(projectPath = process3.cwd()) {
   const packageJsonDataRaw = fs.readFileSync(targetPackageJson, { encoding: "utf-8" });
   return { packageJsonContent: JSON.parse(packageJsonDataRaw), packageJsonPath: targetPackageJson };
 }
-function setHooksFromConfig(projectRootPath = process3.cwd(), options) {
-  if (!config2 || Object.keys(config2).length === 0)
+function setHooksFromConfig(projectRootPath = process12.cwd(), options) {
+  if (!config3 || Object.keys(config3).length === 0)
     throw new Error("[ERROR] Config was not found! Please add `.git-hooks.config.{ts,js,mjs,cjs,mts,cts,json}` or `git-hooks.config.{ts,js,mjs,cjs,mts,cts,json}` or the `git-hooks` entry in package.json.\r\nCheck README for details");
-  const configFile = options?.configFile ? options.configFile : config2;
-  const hookKeys = Object.keys(configFile).filter((key) => key !== "preserveUnused" && key !== "verbose");
+  const configFile = options?.configFile ? options.configFile : config3;
+  const hookKeys = Object.keys(configFile).filter((key) => !VALID_OPTIONS.includes(key));
   const isValidConfig = hookKeys.every((key) => VALID_GIT_HOOKS.includes(key));
   if (!isValidConfig)
     throw new Error("[ERROR] Config was not in correct format. Please check git hooks or options name");
   const preserveUnused = Array.isArray(configFile.preserveUnused) ? configFile.preserveUnused : configFile.preserveUnused ? VALID_GIT_HOOKS : [];
+  const logKeys = Object.keys(configFile).filter((key) => !VALID_OPTIONS.includes(key)).sort().map((key) => italic22(key)).join(", ");
+  log3.debug(`Hook Keys: ${logKeys}`);
   for (const hook of VALID_GIT_HOOKS) {
     if (Object.prototype.hasOwnProperty.call(configFile, hook)) {
       if (!configFile[hook])
@@ -349,7 +4767,7 @@ function setHooksFromConfig(projectRootPath = process3.cwd(), options) {
     }
   }
 }
-async function getStagedFiles(projectRoot = process3.cwd()) {
+async function getStagedFiles(projectRoot = process12.cwd()) {
   try {
     const { stdout } = await execAsync("git diff --staged --name-only --diff-filter=ACMR", { cwd: projectRoot });
     return stdout.trim().split(`
@@ -370,7 +4788,7 @@ function matchesGlob(file, pattern) {
 function filterFilesByPattern(files, pattern) {
   return files.filter((file) => matchesGlob(file, pattern));
 }
-async function runCommandOnStagedFiles(command, files, projectRoot = process3.cwd(), verbose = false) {
+async function runCommandOnStagedFiles(command, files, projectRoot = process12.cwd(), verbose = false) {
   if (files.length === 0) {
     if (verbose)
       console.info("[INFO] No matching files for pattern");
@@ -414,7 +4832,7 @@ async function processStagedLint(stagedLintConfig, projectRoot, verbose = false)
   }
   return success;
 }
-function _setHook(hook, commandOrConfig, projectRoot = process3.cwd()) {
+function _setHook(hook, commandOrConfig, projectRoot = process12.cwd()) {
   const gitRoot = getGitProjectRoot(projectRoot);
   if (!gitRoot) {
     console.info("[INFO] No `.git` root folder found, skipping");
@@ -423,7 +4841,7 @@ function _setHook(hook, commandOrConfig, projectRoot = process3.cwd()) {
   let hookCommand;
   if (typeof commandOrConfig === "string") {
     hookCommand = PREPEND_SCRIPT + commandOrConfig;
-  } else if (commandOrConfig.stagedLint) {
+  } else if (commandOrConfig.stagedLint || commandOrConfig["staged-lint"]) {
     hookCommand = PREPEND_SCRIPT + `git-hooks run-staged-lint ${hook}`;
   } else {
     console.error(`[ERROR] Invalid command or config for hook ${hook}`);
@@ -434,38 +4852,45 @@ function _setHook(hook, commandOrConfig, projectRoot = process3.cwd()) {
   if (!fs.existsSync(hookDirectory)) {
     fs.mkdirSync(hookDirectory, { recursive: true });
   }
+  const addOrModify = fs.existsSync(hookPath) ? "Modify" : "Add";
+  log3.debug(`${addOrModify} ${italic22(hook)} hook`);
   fs.writeFileSync(hookPath, hookCommand, { mode: 493 });
 }
-function removeHooks(projectRoot = process3.cwd(), verbose = false) {
+function removeHooks(projectRoot = process12.cwd(), verbose = false) {
   for (const configEntry of VALID_GIT_HOOKS)
     _removeHook(configEntry, projectRoot, verbose);
 }
-function _removeHook(hook, projectRoot = process3.cwd(), verbose = false) {
+function _removeHook(hook, projectRoot = process12.cwd(), verbose = false) {
   const gitRoot = getGitProjectRoot(projectRoot);
   const hookPath = path.normalize(`${gitRoot}/hooks/${hook}`);
-  if (fs.existsSync(hookPath))
+  if (fs.existsSync(hookPath)) {
+    log3.debug(`Hook ${hook} is not set, removing!`);
     fs.unlinkSync(hookPath);
+  }
   if (verbose)
-    console.info(`[INFO] Successfully removed the ${hook} hook`);
+    log3.success(`Successfully removed the ${hook} hook`);
 }
 async function runStagedLint(hook) {
-  try {
-    const hookConfig = config2[hook];
-    if (!hookConfig || typeof hookConfig !== "object" || !("stagedLint" in hookConfig)) {
-      console.error(`[ERROR] No stagedLint configuration found for hook ${hook}`);
-      return false;
-    }
-    const stagedLintConfig = hookConfig.stagedLint;
-    if (!stagedLintConfig) {
-      console.error(`[ERROR] Invalid stagedLint configuration for hook ${hook}`);
-      return false;
-    }
-    const verbose = config2.verbose === true;
-    return await processStagedLint(stagedLintConfig, process3.cwd(), verbose);
-  } catch (error) {
-    console.error("[ERROR] Failed to run staged lint:", error);
+  const projectRoot = process12.cwd();
+  const configFile = config3;
+  if (!configFile) {
+    console.error(`[ERROR] No configuration found`);
     return false;
   }
+  if (hook in configFile) {
+    const hookConfig = configFile[hook];
+    if (typeof hookConfig === "object" && !Array.isArray(hookConfig)) {
+      const stagedLintConfig = hookConfig.stagedLint || hookConfig["staged-lint"];
+      if (stagedLintConfig) {
+        return processStagedLint(stagedLintConfig, projectRoot, configFile.verbose);
+      }
+    }
+  }
+  if (configFile["staged-lint"]) {
+    return processStagedLint(configFile["staged-lint"], projectRoot, configFile.verbose);
+  }
+  console.error(`[ERROR] No staged lint configuration found for hook ${hook}`);
+  return false;
 }
 export {
   setHooksFromConfig,
@@ -473,7 +4898,7 @@ export {
   removeHooks,
   getProjectRootDirectoryFromNodeModules,
   getGitProjectRoot,
-  config2 as config,
+  config3 as config,
   checkBunGitHooksInDependencies,
   VALID_OPTIONS,
   VALID_GIT_HOOKS,