@spfn/core 0.1.0-alpha.88 → 0.2.0-beta.2

package/dist/index.js

@@ -1,3674 +0,0 @@
-import { readFileSync, existsSync, readdirSync, statSync, mkdirSync, accessSync, constants, writeFileSync, unlinkSync, createWriteStream, renameSync } from 'fs';
-import { join, dirname, relative, basename } from 'path';
-import { config } from 'dotenv';
-import postgres from 'postgres';
-import { drizzle } from 'drizzle-orm/postgres-js';
-import { timestamp, bigserial, pgSchema } from 'drizzle-orm/pg-core';
-import { AsyncLocalStorage } from 'async_hooks';
-import { randomUUID, randomBytes } from 'crypto';
-import { createMiddleware } from 'hono/factory';
-import { eq, and } from 'drizzle-orm';
-import { Hono } from 'hono';
-import { cors } from 'hono/cors';
-import { readdir, stat } from 'fs/promises';
-import { serve } from '@hono/node-server';
-import { networkInterfaces } from 'os';
-
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
-// src/logger/types.ts
-var LOG_LEVEL_PRIORITY;
-var init_types = __esm({
-  "src/logger/types.ts"() {
-    LOG_LEVEL_PRIORITY = {
-      debug: 0,
-      info: 1,
-      warn: 2,
-      error: 3,
-      fatal: 4
-    };
-  }
-});
-
-// src/logger/formatters.ts
-function isSensitiveKey(key) {
-  const lowerKey = key.toLowerCase();
-  return SENSITIVE_KEYS.some((sensitive) => lowerKey.includes(sensitive));
-}
-function maskSensitiveData(data) {
-  if (data === null || data === void 0) {
-    return data;
-  }
-  if (Array.isArray(data)) {
-    return data.map((item) => maskSensitiveData(item));
-  }
-  if (typeof data === "object") {
-    const masked = {};
-    for (const [key, value] of Object.entries(data)) {
-      if (isSensitiveKey(key)) {
-        masked[key] = MASKED_VALUE;
-      } else if (typeof value === "object" && value !== null) {
-        masked[key] = maskSensitiveData(value);
-      } else {
-        masked[key] = value;
-      }
-    }
-    return masked;
-  }
-  return data;
-}
-function formatTimestamp(date) {
-  return date.toISOString();
-}
-function formatTimestampHuman(date) {
-  const year = date.getFullYear();
-  const month = String(date.getMonth() + 1).padStart(2, "0");
-  const day = String(date.getDate()).padStart(2, "0");
-  const hours = String(date.getHours()).padStart(2, "0");
-  const minutes = String(date.getMinutes()).padStart(2, "0");
-  const seconds = String(date.getSeconds()).padStart(2, "0");
-  const ms = String(date.getMilliseconds()).padStart(3, "0");
-  return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}.${ms}`;
-}
-function formatError(error) {
-  const lines = [];
-  lines.push(`${error.name}: ${error.message}`);
-  if (error.stack) {
-    const stackLines = error.stack.split("\n").slice(1);
-    lines.push(...stackLines);
-  }
-  return lines.join("\n");
-}
-function formatConsole(metadata, colorize = true) {
-  const parts = [];
-  const timestamp2 = formatTimestampHuman(metadata.timestamp);
-  if (colorize) {
-    parts.push(`${COLORS.gray}[${timestamp2}]${COLORS.reset}`);
-  } else {
-    parts.push(`[${timestamp2}]`);
-  }
-  if (metadata.module) {
-    if (colorize) {
-      parts.push(`${COLORS.dim}[module=${metadata.module}]${COLORS.reset}`);
-    } else {
-      parts.push(`[module=${metadata.module}]`);
-    }
-  }
-  if (metadata.context && Object.keys(metadata.context).length > 0) {
-    Object.entries(metadata.context).forEach(([key, value]) => {
-      let valueStr;
-      if (typeof value === "string") {
-        valueStr = value;
-      } else if (typeof value === "object" && value !== null) {
-        try {
-          valueStr = JSON.stringify(value);
-        } catch (error) {
-          valueStr = "[circular]";
-        }
-      } else {
-        valueStr = String(value);
-      }
-      if (colorize) {
-        parts.push(`${COLORS.dim}[${key}=${valueStr}]${COLORS.reset}`);
-      } else {
-        parts.push(`[${key}=${valueStr}]`);
-      }
-    });
-  }
-  const levelStr = metadata.level.toUpperCase();
-  if (colorize) {
-    const color = COLORS[metadata.level];
-    parts.push(`${color}(${levelStr})${COLORS.reset}:`);
-  } else {
-    parts.push(`(${levelStr}):`);
-  }
-  if (colorize) {
-    parts.push(`${COLORS.bright}${metadata.message}${COLORS.reset}`);
-  } else {
-    parts.push(metadata.message);
-  }
-  let output = parts.join(" ");
-  if (metadata.error) {
-    output += "\n" + formatError(metadata.error);
-  }
-  return output;
-}
-function formatJSON(metadata) {
-  const obj = {
-    timestamp: formatTimestamp(metadata.timestamp),
-    level: metadata.level,
-    message: metadata.message
-  };
-  if (metadata.module) {
-    obj.module = metadata.module;
-  }
-  if (metadata.context) {
-    obj.context = metadata.context;
-  }
-  if (metadata.error) {
-    obj.error = {
-      name: metadata.error.name,
-      message: metadata.error.message,
-      stack: metadata.error.stack
-    };
-  }
-  return JSON.stringify(obj);
-}
-var SENSITIVE_KEYS, MASKED_VALUE, COLORS;
-var init_formatters = __esm({
-  "src/logger/formatters.ts"() {
-    SENSITIVE_KEYS = [
-      "password",
-      "passwd",
-      "pwd",
-      "secret",
-      "token",
-      "apikey",
-      "api_key",
-      "accesstoken",
-      "access_token",
-      "refreshtoken",
-      "refresh_token",
-      "authorization",
-      "auth",
-      "cookie",
-      "session",
-      "sessionid",
-      "session_id",
-      "privatekey",
-      "private_key",
-      "creditcard",
-      "credit_card",
-      "cardnumber",
-      "card_number",
-      "cvv",
-      "ssn",
-      "pin"
-    ];
-    MASKED_VALUE = "***MASKED***";
-    COLORS = {
-      reset: "\x1B[0m",
-      bright: "\x1B[1m",
-      dim: "\x1B[2m",
-      // 로그 레벨 컬러
-      debug: "\x1B[36m",
-      // cyan
-      info: "\x1B[32m",
-      // green
-      warn: "\x1B[33m",
-      // yellow
-      error: "\x1B[31m",
-      // red
-      fatal: "\x1B[35m",
-      // magenta
-      // 추가 컬러
-      gray: "\x1B[90m"
-    };
-  }
-});
-
-// src/logger/logger.ts
-var Logger;
-var init_logger = __esm({
-  "src/logger/logger.ts"() {
-    init_types();
-    init_formatters();
-    Logger = class _Logger {
-      config;
-      module;
-      constructor(config) {
-        this.config = config;
-        this.module = config.module;
-      }
-      /**
-       * Get current log level
-       */
-      get level() {
-        return this.config.level;
-      }
-      /**
-       * Create child logger (per module)
-       */
-      child(module) {
-        return new _Logger({
-          ...this.config,
-          module
-        });
-      }
-      /**
-       * Debug log
-       */
-      debug(message, context) {
-        this.log("debug", message, void 0, context);
-      }
-      /**
-       * Info log
-       */
-      info(message, context) {
-        this.log("info", message, void 0, context);
-      }
-      warn(message, errorOrContext, context) {
-        if (errorOrContext instanceof Error) {
-          this.log("warn", message, errorOrContext, context);
-        } else {
-          this.log("warn", message, void 0, errorOrContext);
-        }
-      }
-      error(message, errorOrContext, context) {
-        if (errorOrContext instanceof Error) {
-          this.log("error", message, errorOrContext, context);
-        } else {
-          this.log("error", message, void 0, errorOrContext);
-        }
-      }
-      fatal(message, errorOrContext, context) {
-        if (errorOrContext instanceof Error) {
-          this.log("fatal", message, errorOrContext, context);
-        } else {
-          this.log("fatal", message, void 0, errorOrContext);
-        }
-      }
-      /**
-       * Log processing (internal)
-       */
-      log(level, message, error, context) {
-        if (LOG_LEVEL_PRIORITY[level] < LOG_LEVEL_PRIORITY[this.config.level]) {
-          return;
-        }
-        const metadata = {
-          timestamp: /* @__PURE__ */ new Date(),
-          level,
-          message,
-          module: this.module,
-          error,
-          // Mask sensitive information in context to prevent credential leaks
-          context: context ? maskSensitiveData(context) : void 0
-        };
-        this.processTransports(metadata);
-      }
-      /**
-       * Process Transports
-       */
-      processTransports(metadata) {
-        const promises = this.config.transports.filter((transport) => transport.enabled).map((transport) => this.safeTransportLog(transport, metadata));
-        Promise.all(promises).catch((error) => {
-          const errorMessage = error instanceof Error ? error.message : String(error);
-          process.stderr.write(`[Logger] Transport error: ${errorMessage}
-`);
-        });
-      }
-      /**
-       * Transport log (error-safe)
-       */
-      async safeTransportLog(transport, metadata) {
-        try {
-          await transport.log(metadata);
-        } catch (error) {
-          const errorMessage = error instanceof Error ? error.message : String(error);
-          process.stderr.write(`[Logger] Transport "${transport.name}" failed: ${errorMessage}
-`);
-        }
-      }
-      /**
-       * Close all Transports
-       */
-      async close() {
-        const closePromises = this.config.transports.filter((transport) => transport.close).map((transport) => transport.close());
-        await Promise.all(closePromises);
-      }
-    };
-  }
-});
-
-// src/logger/transports/console.ts
-var ConsoleTransport;
-var init_console = __esm({
-  "src/logger/transports/console.ts"() {
-    init_types();
-    init_formatters();
-    ConsoleTransport = class {
-      name = "console";
-      level;
-      enabled;
-      colorize;
-      constructor(config) {
-        this.level = config.level;
-        this.enabled = config.enabled;
-        this.colorize = config.colorize ?? true;
-      }
-      async log(metadata) {
-        if (!this.enabled) {
-          return;
-        }
-        if (LOG_LEVEL_PRIORITY[metadata.level] < LOG_LEVEL_PRIORITY[this.level]) {
-          return;
-        }
-        const message = formatConsole(metadata, this.colorize);
-        if (metadata.level === "warn" || metadata.level === "error" || metadata.level === "fatal") {
-          console.error(message);
-        } else {
-          console.log(message);
-        }
-      }
-    };
-  }
-});
-var FileTransport;
-var init_file = __esm({
-  "src/logger/transports/file.ts"() {
-    init_types();
-    init_formatters();
-    FileTransport = class {
-      name = "file";
-      level;
-      enabled;
-      logDir;
-      maxFileSize;
-      maxFiles;
-      currentStream = null;
-      currentFilename = null;
-      constructor(config) {
-        this.level = config.level;
-        this.enabled = config.enabled;
-        this.logDir = config.logDir;
-        this.maxFileSize = config.maxFileSize ?? 10 * 1024 * 1024;
-        this.maxFiles = config.maxFiles ?? 10;
-        if (!existsSync(this.logDir)) {
-          mkdirSync(this.logDir, { recursive: true });
-        }
-      }
-      async log(metadata) {
-        if (!this.enabled) {
-          return;
-        }
-        if (LOG_LEVEL_PRIORITY[metadata.level] < LOG_LEVEL_PRIORITY[this.level]) {
-          return;
-        }
-        const message = formatJSON(metadata);
-        const filename = this.getLogFilename(metadata.timestamp);
-        if (this.currentFilename !== filename) {
-          await this.rotateStream(filename);
-          await this.cleanOldFiles();
-        } else if (this.currentFilename) {
-          await this.checkAndRotateBySize();
-        }
-        if (this.currentStream) {
-          return new Promise((resolve, reject) => {
-            this.currentStream.write(message + "\n", "utf-8", (error) => {
-              if (error) {
-                process.stderr.write(`[FileTransport] Failed to write log: ${error.message}
-`);
-                reject(error);
-              } else {
-                resolve();
-              }
-            });
-          });
-        }
-      }
-      /**
-       * 스트림 교체 (날짜 변경 시)
-       */
-      async rotateStream(filename) {
-        if (this.currentStream) {
-          await this.closeStream();
-        }
-        const filepath = join(this.logDir, filename);
-        this.currentStream = createWriteStream(filepath, {
-          flags: "a",
-          // append mode
-          encoding: "utf-8"
-        });
-        this.currentFilename = filename;
-        this.currentStream.on("error", (error) => {
-          process.stderr.write(`[FileTransport] Stream error: ${error.message}
-`);
-          this.currentStream = null;
-          this.currentFilename = null;
-        });
-      }
-      /**
-       * 현재 스트림 닫기
-       */
-      async closeStream() {
-        if (!this.currentStream) {
-          return;
-        }
-        return new Promise((resolve, reject) => {
-          this.currentStream.end((error) => {
-            if (error) {
-              reject(error);
-            } else {
-              this.currentStream = null;
-              this.currentFilename = null;
-              resolve();
-            }
-          });
-        });
-      }
-      /**
-       * 파일 크기 체크 및 크기 기반 로테이션
-       */
-      async checkAndRotateBySize() {
-        if (!this.currentFilename) {
-          return;
-        }
-        const filepath = join(this.logDir, this.currentFilename);
-        if (!existsSync(filepath)) {
-          return;
-        }
-        try {
-          const stats = statSync(filepath);
-          if (stats.size >= this.maxFileSize) {
-            await this.rotateBySize();
-          }
-        } catch (error) {
-          const errorMessage = error instanceof Error ? error.message : String(error);
-          process.stderr.write(`[FileTransport] Failed to check file size: ${errorMessage}
-`);
-        }
-      }
-      /**
-       * 크기 기반 로테이션 수행
-       * 예: 2025-01-01.log -> 2025-01-01.1.log, 2025-01-01.1.log -> 2025-01-01.2.log
-       */
-      async rotateBySize() {
-        if (!this.currentFilename) {
-          return;
-        }
-        await this.closeStream();
-        const baseName = this.currentFilename.replace(/\.log$/, "");
-        const files = readdirSync(this.logDir);
-        const relatedFiles = files.filter((file) => file.startsWith(baseName) && file.endsWith(".log")).sort().reverse();
-        for (const file of relatedFiles) {
-          const match = file.match(/\.(\d+)\.log$/);
-          if (match) {
-            const oldNum = parseInt(match[1], 10);
-            const newNum = oldNum + 1;
-            const oldPath = join(this.logDir, file);
-            const newPath2 = join(this.logDir, `${baseName}.${newNum}.log`);
-            try {
-              renameSync(oldPath, newPath2);
-            } catch (error) {
-              const errorMessage = error instanceof Error ? error.message : String(error);
-              process.stderr.write(`[FileTransport] Failed to rotate file: ${errorMessage}
-`);
-            }
-          }
-        }
-        const currentPath = join(this.logDir, this.currentFilename);
-        const newPath = join(this.logDir, `${baseName}.1.log`);
-        try {
-          if (existsSync(currentPath)) {
-            renameSync(currentPath, newPath);
-          }
-        } catch (error) {
-          const errorMessage = error instanceof Error ? error.message : String(error);
-          process.stderr.write(`[FileTransport] Failed to rotate current file: ${errorMessage}
-`);
-        }
-        await this.rotateStream(this.currentFilename);
-      }
-      /**
-       * 오래된 로그 파일 정리
-       * maxFiles 개수를 초과하는 로그 파일 삭제
-       */
-      async cleanOldFiles() {
-        try {
-          if (!existsSync(this.logDir)) {
-            return;
-          }
-          const files = readdirSync(this.logDir);
-          const logFiles = files.filter((file) => file.endsWith(".log")).map((file) => {
-            const filepath = join(this.logDir, file);
-            const stats = statSync(filepath);
-            return { file, mtime: stats.mtime };
-          }).sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
-          if (logFiles.length > this.maxFiles) {
-            const filesToDelete = logFiles.slice(this.maxFiles);
-            for (const { file } of filesToDelete) {
-              const filepath = join(this.logDir, file);
-              try {
-                unlinkSync(filepath);
-              } catch (error) {
-                const errorMessage = error instanceof Error ? error.message : String(error);
-                process.stderr.write(`[FileTransport] Failed to delete old file "${file}": ${errorMessage}
-`);
-              }
-            }
-          }
-        } catch (error) {
-          const errorMessage = error instanceof Error ? error.message : String(error);
-          process.stderr.write(`[FileTransport] Failed to clean old files: ${errorMessage}
-`);
-        }
-      }
-      /**
-       * 날짜별 로그 파일명 생성
-       */
-      getLogFilename(date) {
-        const year = date.getFullYear();
-        const month = String(date.getMonth() + 1).padStart(2, "0");
-        const day = String(date.getDate()).padStart(2, "0");
-        return `${year}-${month}-${day}.log`;
-      }
-      async close() {
-        await this.closeStream();
-      }
-    };
-  }
-});
-function isFileLoggingEnabled() {
-  return process.env.LOGGER_FILE_ENABLED === "true";
-}
-function getDefaultLogLevel() {
-  const isProduction = process.env.NODE_ENV === "production";
-  const isDevelopment = process.env.NODE_ENV === "development";
-  if (isDevelopment) {
-    return "debug";
-  }
-  if (isProduction) {
-    return "info";
-  }
-  return "warn";
-}
-function getConsoleConfig() {
-  const isProduction = process.env.NODE_ENV === "production";
-  return {
-    level: "debug",
-    enabled: true,
-    colorize: !isProduction
-    // Dev: colored output, Production: plain text
-  };
-}
-function getFileConfig() {
-  const isProduction = process.env.NODE_ENV === "production";
-  return {
-    level: "info",
-    enabled: isProduction,
-    // File logging in production only
-    logDir: process.env.LOG_DIR || "./logs",
-    maxFileSize: 10 * 1024 * 1024,
-    // 10MB
-    maxFiles: 10
-  };
-}
-function validateDirectoryWritable(dirPath) {
-  if (!existsSync(dirPath)) {
-    try {
-      mkdirSync(dirPath, { recursive: true });
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      throw new Error(`Failed to create log directory "${dirPath}": ${errorMessage}`);
-    }
-  }
-  try {
-    accessSync(dirPath, constants.W_OK);
-  } catch {
-    throw new Error(`Log directory "${dirPath}" is not writable. Please check permissions.`);
-  }
-  const testFile = join(dirPath, ".logger-write-test");
-  try {
-    writeFileSync(testFile, "test", "utf-8");
-    unlinkSync(testFile);
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    throw new Error(`Cannot write to log directory "${dirPath}": ${errorMessage}`);
-  }
-}
-function validateFileConfig() {
-  if (!isFileLoggingEnabled()) {
-    return;
-  }
-  const logDir = process.env.LOG_DIR;
-  if (!logDir) {
-    throw new Error(
-      "LOG_DIR environment variable is required when LOGGER_FILE_ENABLED=true. Example: LOG_DIR=/var/log/myapp"
-    );
-  }
-  validateDirectoryWritable(logDir);
-}
-function validateSlackConfig() {
-  const webhookUrl = process.env.SLACK_WEBHOOK_URL;
-  if (!webhookUrl) {
-    return;
-  }
-  if (!webhookUrl.startsWith("https://hooks.slack.com/")) {
-    throw new Error(
-      `Invalid SLACK_WEBHOOK_URL: "${webhookUrl}". Slack webhook URLs must start with "https://hooks.slack.com/"`
-    );
-  }
-}
-function validateEmailConfig() {
-  const smtpHost = process.env.SMTP_HOST;
-  const smtpPort = process.env.SMTP_PORT;
-  const emailFrom = process.env.EMAIL_FROM;
-  const emailTo = process.env.EMAIL_TO;
-  const hasAnyEmailConfig = smtpHost || smtpPort || emailFrom || emailTo;
-  if (!hasAnyEmailConfig) {
-    return;
-  }
-  const missingFields = [];
-  if (!smtpHost) missingFields.push("SMTP_HOST");
-  if (!smtpPort) missingFields.push("SMTP_PORT");
-  if (!emailFrom) missingFields.push("EMAIL_FROM");
-  if (!emailTo) missingFields.push("EMAIL_TO");
-  if (missingFields.length > 0) {
-    throw new Error(
-      `Email transport configuration incomplete. Missing: ${missingFields.join(", ")}. Either set all required fields or remove all email configuration.`
-    );
-  }
-  const port = parseInt(smtpPort, 10);
-  if (isNaN(port) || port < 1 || port > 65535) {
-    throw new Error(
-      `Invalid SMTP_PORT: "${smtpPort}". Must be a number between 1 and 65535.`
-    );
-  }
-  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-  if (!emailRegex.test(emailFrom)) {
-    throw new Error(`Invalid EMAIL_FROM format: "${emailFrom}"`);
-  }
-  const recipients = emailTo.split(",").map((e) => e.trim());
-  for (const email of recipients) {
-    if (!emailRegex.test(email)) {
-      throw new Error(`Invalid email address in EMAIL_TO: "${email}"`);
-    }
-  }
-}
-function validateEnvironment() {
-  const nodeEnv = process.env.NODE_ENV;
-  if (!nodeEnv) {
-    process.stderr.write(
-      "[Logger] Warning: NODE_ENV is not set. Defaulting to test environment.\n"
-    );
-  }
-}
-function validateConfig() {
-  try {
-    validateEnvironment();
-    validateFileConfig();
-    validateSlackConfig();
-    validateEmailConfig();
-  } catch (error) {
-    if (error instanceof Error) {
-      throw new Error(`[Logger] Configuration validation failed: ${error.message}`);
-    }
-    throw error;
-  }
-}
-var init_config = __esm({
-  "src/logger/config.ts"() {
-  }
-});
-
-// src/logger/factory.ts
-function initializeTransports() {
-  const transports = [];
-  const consoleConfig = getConsoleConfig();
-  transports.push(new ConsoleTransport(consoleConfig));
-  const fileConfig = getFileConfig();
-  if (fileConfig.enabled) {
-    transports.push(new FileTransport(fileConfig));
-  }
-  return transports;
-}
-function initializeLogger() {
-  validateConfig();
-  return new Logger({
-    level: getDefaultLogLevel(),
-    transports: initializeTransports()
-  });
-}
-var logger;
-var init_factory = __esm({
-  "src/logger/factory.ts"() {
-    init_logger();
-    init_console();
-    init_file();
-    init_config();
-    logger = initializeLogger();
-  }
-});
-
-// src/logger/index.ts
-var init_logger2 = __esm({
-  "src/logger/index.ts"() {
-    init_factory();
-    init_logger();
-  }
-});
-
-// src/route/function-routes.ts
-var function_routes_exports = {};
-__export(function_routes_exports, {
-  discoverFunctionRoutes: () => discoverFunctionRoutes
-});
-function discoverFunctionRoutes(cwd = process.cwd()) {
-  const functions = [];
-  const nodeModulesPath = join(cwd, "node_modules");
-  try {
-    const projectPkgPath = join(cwd, "package.json");
-    const projectPkg = JSON.parse(readFileSync(projectPkgPath, "utf-8"));
-    const dependencies = {
-      ...projectPkg.dependencies,
-      ...projectPkg.devDependencies
-    };
-    for (const [packageName] of Object.entries(dependencies)) {
-      if (!packageName.startsWith("@spfn/") && !packageName.startsWith("spfn-")) {
-        continue;
-      }
-      try {
-        const pkgPath = join(nodeModulesPath, ...packageName.split("/"), "package.json");
-        const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
-        if (pkg.spfn?.routes?.dir) {
-          const { dir } = pkg.spfn.routes;
-          const prefix = pkg.spfn.prefix;
-          const packagePath = dirname(pkgPath);
-          const routesDir = join(packagePath, dir);
-          functions.push({
-            packageName,
-            routesDir,
-            packagePath,
-            prefix
-            // Include prefix in function info
-          });
-          routeLogger.debug("Discovered function routes", {
-            package: packageName,
-            dir,
-            prefix: prefix || "(none)"
-          });
-        }
-      } catch (error) {
-      }
-    }
-  } catch (error) {
-    routeLogger.warn("Failed to discover function routes", {
-      error: error instanceof Error ? error.message : "Unknown error"
-    });
-  }
-  return functions;
-}
-var routeLogger;
-var init_function_routes = __esm({
-  "src/route/function-routes.ts"() {
-    init_logger2();
-    routeLogger = logger.child("function-routes");
-  }
-});
-
-// src/errors/database-errors.ts
-var DatabaseError, ConnectionError, QueryError, ConstraintViolationError, TransactionError, DeadlockError, DuplicateEntryError;
-var init_database_errors = __esm({
-  "src/errors/database-errors.ts"() {
-    DatabaseError = class extends Error {
-      statusCode;
-      details;
-      timestamp;
-      constructor(message, statusCode = 500, details) {
-        super(message);
-        this.name = "DatabaseError";
-        this.statusCode = statusCode;
-        this.details = details;
-        this.timestamp = /* @__PURE__ */ new Date();
-        Error.captureStackTrace(this, this.constructor);
-      }
-      /**
-       * Serialize error for API response
-       */
-      toJSON() {
-        return {
-          name: this.name,
-          message: this.message,
-          statusCode: this.statusCode,
-          details: this.details,
-          timestamp: this.timestamp.toISOString()
-        };
-      }
-    };
-    ConnectionError = class extends DatabaseError {
-      constructor(message, details) {
-        super(message, 503, details);
-        this.name = "ConnectionError";
-      }
-    };
-    QueryError = class extends DatabaseError {
-      constructor(message, statusCode = 500, details) {
-        super(message, statusCode, details);
-        this.name = "QueryError";
-      }
-    };
-    ConstraintViolationError = class extends QueryError {
-      constructor(message, details) {
-        super(message, 400, details);
-        this.name = "ConstraintViolationError";
-      }
-    };
-    TransactionError = class extends DatabaseError {
-      constructor(message, statusCode = 500, details) {
-        super(message, statusCode, details);
-        this.name = "TransactionError";
-      }
-    };
-    DeadlockError = class extends TransactionError {
-      constructor(message, details) {
-        super(message, 409, details);
-        this.name = "DeadlockError";
-      }
-    };
-    DuplicateEntryError = class extends QueryError {
-      constructor(field, value) {
-        super(`${field} '${value}' already exists`, 409, { field, value });
-        this.name = "DuplicateEntryError";
-      }
-    };
-  }
-});
-
-// src/errors/http-errors.ts
-var init_http_errors = __esm({
-  "src/errors/http-errors.ts"() {
-  }
-});
-
-// src/errors/error-utils.ts
-var init_error_utils = __esm({
-  "src/errors/error-utils.ts"() {
-    init_database_errors();
-    init_http_errors();
-  }
-});
-
-// src/errors/index.ts
-var init_errors = __esm({
-  "src/errors/index.ts"() {
-    init_database_errors();
-    init_http_errors();
-    init_error_utils();
-  }
-});
-
-// src/env/config.ts
-var ENV_FILE_PRIORITY, TEST_ONLY_FILES;
-var init_config2 = __esm({
-  "src/env/config.ts"() {
-    ENV_FILE_PRIORITY = [
-      ".env",
-      // Base configuration (lowest priority)
-      ".env.{NODE_ENV}",
-      // Environment-specific
-      ".env.local",
-      // Local overrides (excluded in test)
-      ".env.{NODE_ENV}.local"
-      // Local environment-specific (highest priority)
-    ];
-    TEST_ONLY_FILES = [
-      ".env.test",
-      ".env.test.local"
-    ];
-  }
-});
-function buildFileList(basePath, nodeEnv) {
-  const files = [];
-  if (!nodeEnv) {
-    files.push(join(basePath, ".env"));
-    files.push(join(basePath, ".env.local"));
-    return files;
-  }
-  for (const pattern of ENV_FILE_PRIORITY) {
-    const fileName = pattern.replace("{NODE_ENV}", nodeEnv);
-    if (nodeEnv === "test" && fileName === ".env.local") {
-      continue;
-    }
-    if (nodeEnv === "local" && pattern === ".env.local") {
-      continue;
-    }
-    if (nodeEnv !== "test" && TEST_ONLY_FILES.includes(fileName)) {
-      continue;
-    }
-    files.push(join(basePath, fileName));
-  }
-  return files;
-}
-function loadSingleFile(filePath, debug) {
-  if (!existsSync(filePath)) {
-    if (debug) {
-      envLogger.debug("Environment file not found (optional)", {
-        path: filePath
-      });
-    }
-    return { success: false, parsed: {}, error: "File not found" };
-  }
-  try {
-    const result = config({ path: filePath });
-    if (result.error) {
-      envLogger.warn("Failed to parse environment file", {
-        path: filePath,
-        error: result.error.message
-      });
-      return {
-        success: false,
-        parsed: {},
-        error: result.error.message
-      };
-    }
-    const parsed = result.parsed || {};
-    if (debug) {
-      envLogger.debug("Environment file loaded successfully", {
-        path: filePath,
-        variables: Object.keys(parsed),
-        count: Object.keys(parsed).length
-      });
-    }
-    return { success: true, parsed };
-  } catch (error) {
-    const message = error instanceof Error ? error.message : "Unknown error";
-    envLogger.error("Error loading environment file", {
-      path: filePath,
-      error: message
-    });
-    return { success: false, parsed: {}, error: message };
-  }
-}
-function validateRequiredVars(required, debug) {
-  const missing = [];
-  for (const varName of required) {
-    if (!process.env[varName]) {
-      missing.push(varName);
-    }
-  }
-  if (missing.length > 0) {
-    const error = `Required environment variables missing: ${missing.join(", ")}`;
-    envLogger.error("Environment validation failed", {
-      missing,
-      required
-    });
-    throw new Error(error);
-  }
-  if (debug) {
-    envLogger.debug("Required environment variables validated", {
-      required,
-      allPresent: true
-    });
-  }
-}
-function loadEnvironment(options = {}) {
-  const {
-    basePath = process.cwd(),
-    customPaths = [],
-    debug = false,
-    nodeEnv = process.env.NODE_ENV || "",
-    required = [],
-    useCache = true
-  } = options;
-  if (useCache && environmentLoaded && cachedLoadResult) {
-    if (debug) {
-      envLogger.debug("Returning cached environment", {
-        loaded: cachedLoadResult.loaded.length,
-        variables: Object.keys(cachedLoadResult.parsed).length
-      });
-    }
-    return cachedLoadResult;
-  }
-  if (debug) {
-    envLogger.debug("Loading environment variables", {
-      basePath,
-      nodeEnv,
-      customPaths,
-      required
-    });
-  }
-  const result = {
-    success: true,
-    loaded: [],
-    failed: [],
-    parsed: {},
-    warnings: []
-  };
-  const standardFiles = buildFileList(basePath, nodeEnv);
-  const allFiles = [...standardFiles, ...customPaths];
-  if (debug) {
-    envLogger.debug("Environment files to load", {
-      standardFiles,
-      customPaths,
-      total: allFiles.length
-    });
-  }
-  const reversedFiles = [...allFiles].reverse();
-  for (const filePath of reversedFiles) {
-    const fileResult = loadSingleFile(filePath, debug);
-    if (fileResult.success) {
-      result.loaded.push(filePath);
-      Object.assign(result.parsed, fileResult.parsed);
-      if (fileResult.parsed["NODE_ENV"]) {
-        const fileName = filePath.split("/").pop() || filePath;
-        result.warnings.push(
-          `NODE_ENV found in ${fileName}. It's recommended to set NODE_ENV via CLI (e.g., 'spfn dev', 'spfn build') instead of .env files for consistent environment behavior.`
-        );
-      }
-    } else if (fileResult.error) {
-      result.failed.push({
-        path: filePath,
-        reason: fileResult.error
-      });
-    }
-  }
-  if (debug || result.loaded.length > 0) {
-    envLogger.info("Environment loading complete", {
-      loaded: result.loaded.length,
-      failed: result.failed.length,
-      variables: Object.keys(result.parsed).length,
-      files: result.loaded
-    });
-  }
-  if (required.length > 0) {
-    try {
-      validateRequiredVars(required, debug);
-    } catch (error) {
-      result.success = false;
-      result.errors = [
-        error instanceof Error ? error.message : "Validation failed"
-      ];
-      throw error;
-    }
-  }
-  if (result.warnings.length > 0) {
-    for (const warning of result.warnings) {
-      envLogger.warn(warning);
-    }
-  }
-  environmentLoaded = true;
-  cachedLoadResult = result;
-  return result;
-}
-var envLogger, environmentLoaded, cachedLoadResult;
-var init_loader = __esm({
-  "src/env/loader.ts"() {
-    init_logger2();
-    init_config2();
-    envLogger = logger.child("environment");
-    environmentLoaded = false;
-  }
-});
-
-// src/env/validator.ts
-var init_validator = __esm({
-  "src/env/validator.ts"() {
-  }
-});
-
-// src/env/index.ts
-var init_env = __esm({
-  "src/env/index.ts"() {
-    init_loader();
-    init_config2();
-    init_validator();
-  }
-});
-
-// src/db/postgres-errors.ts
-function parseUniqueViolation(message) {
-  const patterns = [
-    // Standard format: Key (field)=(value)
-    /Key \(([^)]+)\)=\(([^)]+)\)/i,
-    // With quotes: Key ("field")=('value')
-    /Key \(["']?([^)"']+)["']?\)=\(["']?([^)"']+)["']?\)/i,
-    // Alternative format
-    /Key `([^`]+)`=`([^`]+)`/i
-  ];
-  for (const pattern of patterns) {
-    const match = message.match(pattern);
-    if (match) {
-      const field = match[1].trim().replace(/["'`]/g, "");
-      const value = match[2].trim().replace(/["'`]/g, "");
-      return { field, value };
-    }
-  }
-  return null;
-}
-function fromPostgresError(error) {
-  const code = error?.code;
-  const message = error?.message || "Database error occurred";
-  switch (code) {
-    // Class 08 — Connection Exception
-    case "08000":
-    // connection_exception
-    case "08001":
-    // sqlclient_unable_to_establish_sqlconnection
-    case "08003":
-    // connection_does_not_exist
-    case "08004":
-    // sqlserver_rejected_establishment_of_sqlconnection
-    case "08006":
-    // connection_failure
-    case "08007":
-    // transaction_resolution_unknown
-    case "08P01":
-      return new ConnectionError(message, { code });
-    // Class 23 — Integrity Constraint Violation
-    case "23000":
-    // integrity_constraint_violation
-    case "23001":
-      return new ConstraintViolationError(message, { code, constraint: "integrity" });
-    case "23502":
-      return new ConstraintViolationError(message, { code, constraint: "not_null" });
-    case "23503":
-      return new ConstraintViolationError(message, { code, constraint: "foreign_key" });
-    case "23505":
-      const parsed = parseUniqueViolation(message);
-      if (parsed) {
-        return new DuplicateEntryError(parsed.field, parsed.value);
-      }
-      return new DuplicateEntryError("field", "value");
-    case "23514":
-      return new ConstraintViolationError(message, { code, constraint: "check" });
-    // Class 40 — Transaction Rollback
-    case "40000":
-    // transaction_rollback
-    case "40001":
-    // serialization_failure
-    case "40002":
-    // transaction_integrity_constraint_violation
-    case "40003":
-      return new TransactionError(message, 500, { code });
-    case "40P01":
-      return new DeadlockError(message, { code });
-    // Class 42 — Syntax Error or Access Rule Violation
-    case "42000":
-    // syntax_error_or_access_rule_violation
-    case "42601":
-    // syntax_error
-    case "42501":
-    // insufficient_privilege
-    case "42602":
-    // invalid_name
-    case "42622":
-    // name_too_long
-    case "42701":
-    // duplicate_column
-    case "42702":
-    // ambiguous_column
-    case "42703":
-    // undefined_column
-    case "42704":
-    // undefined_object
-    case "42P01":
-    // undefined_table
-    case "42P02":
-      return new QueryError(message, 400, { code });
-    // Class 53 — Insufficient Resources
-    case "53000":
-    // insufficient_resources
-    case "53100":
-    // disk_full
-    case "53200":
-    // out_of_memory
-    case "53300":
-      return new ConnectionError(message, { code });
-    // Class 57 — Operator Intervention
-    case "57000":
-    // operator_intervention
-    case "57014":
-    // query_canceled
-    case "57P01":
-    // admin_shutdown
-    case "57P02":
-    // crash_shutdown
-    case "57P03":
-      return new ConnectionError(message, { code });
-    // Default: Unknown error
-    default:
-      return new QueryError(message, 500, { code });
-  }
-}
-var init_postgres_errors = __esm({
-  "src/db/postgres-errors.ts"() {
-    init_errors();
-  }
-});
-function delay(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-async function createDatabaseConnection(connectionString, poolConfig, retryConfig) {
-  let lastError;
-  for (let attempt = 0; attempt <= retryConfig.maxRetries; attempt++) {
-    try {
-      const client = postgres(connectionString, {
-        max: poolConfig.max,
-        idle_timeout: poolConfig.idleTimeout
-      });
-      await client`SELECT 1 as test`;
-      if (attempt > 0) {
-        dbLogger.info(`Database connected successfully after ${attempt} retries`);
-      } else {
-        dbLogger.info("Database connected successfully");
-      }
-      return client;
-    } catch (error) {
-      lastError = fromPostgresError(error);
-      if (attempt < retryConfig.maxRetries) {
-        const delayMs = Math.min(
-          retryConfig.initialDelay * Math.pow(retryConfig.factor, attempt),
-          retryConfig.maxDelay
-        );
-        dbLogger.warn(
-          `Connection failed (attempt ${attempt + 1}/${retryConfig.maxRetries + 1}), retrying in ${delayMs}ms...`,
-          lastError,
-          {
-            attempt: attempt + 1,
-            maxRetries: retryConfig.maxRetries + 1,
-            delayMs
-          }
-        );
-        await delay(delayMs);
-      }
-    }
-  }
-  const errorMessage = `Failed to connect to database after ${retryConfig.maxRetries + 1} attempts: ${lastError?.message || "Unknown error"}`;
-  throw new ConnectionError(errorMessage);
-}
-async function checkConnection(client) {
-  try {
-    await client`SELECT 1 as health_check`;
-    return true;
-  } catch (error) {
-    dbLogger.error("Database health check failed", error);
-    return false;
-  }
-}
-var dbLogger;
-var init_connection = __esm({
-  "src/db/manager/connection.ts"() {
-    init_logger2();
-    init_errors();
-    init_postgres_errors();
-    dbLogger = logger.child("database");
-  }
-});
-
-// src/db/manager/config.ts
-function parseEnvNumber(key, prodDefault, devDefault) {
-  const isProduction = process.env.NODE_ENV === "production";
-  const envValue = parseInt(process.env[key] || "", 10);
-  return isNaN(envValue) ? isProduction ? prodDefault : devDefault : envValue;
-}
-function parseEnvBoolean(key, defaultValue) {
-  const value = process.env[key];
-  if (value === void 0) return defaultValue;
-  return value.toLowerCase() === "true";
-}
-function getPoolConfig(options) {
-  return {
-    max: options?.max ?? parseEnvNumber("DB_POOL_MAX", 20, 10),
-    idleTimeout: options?.idleTimeout ?? parseEnvNumber("DB_POOL_IDLE_TIMEOUT", 30, 20)
-  };
-}
-function getRetryConfig() {
-  return {
-    maxRetries: parseEnvNumber("DB_RETRY_MAX", 5, 3),
-    initialDelay: parseEnvNumber("DB_RETRY_INITIAL_DELAY", 100, 50),
-    maxDelay: parseEnvNumber("DB_RETRY_MAX_DELAY", 1e4, 5e3),
-    factor: parseEnvNumber("DB_RETRY_FACTOR", 2, 2)
-  };
-}
-function buildHealthCheckConfig(options) {
-  return {
-    enabled: options?.enabled ?? parseEnvBoolean("DB_HEALTH_CHECK_ENABLED", true),
-    interval: options?.interval ?? parseEnvNumber("DB_HEALTH_CHECK_INTERVAL", 6e4, 6e4),
-    reconnect: options?.reconnect ?? parseEnvBoolean("DB_HEALTH_CHECK_RECONNECT", true),
-    maxRetries: options?.maxRetries ?? parseEnvNumber("DB_HEALTH_CHECK_MAX_RETRIES", 3, 3),
-    retryInterval: options?.retryInterval ?? parseEnvNumber("DB_HEALTH_CHECK_RETRY_INTERVAL", 5e3, 5e3)
-  };
-}
-function buildMonitoringConfig(options) {
-  const isDevelopment = process.env.NODE_ENV !== "production";
-  return {
-    enabled: options?.enabled ?? parseEnvBoolean("DB_MONITORING_ENABLED", isDevelopment),
-    slowThreshold: options?.slowThreshold ?? parseEnvNumber("DB_MONITORING_SLOW_THRESHOLD", 1e3, 1e3),
-    logQueries: options?.logQueries ?? parseEnvBoolean("DB_MONITORING_LOG_QUERIES", false)
-  };
-}
-var init_config3 = __esm({
-  "src/db/manager/config.ts"() {
-  }
-});
-function hasDatabaseConfig() {
-  return !!(process.env.DATABASE_URL || process.env.DATABASE_WRITE_URL || process.env.DATABASE_READ_URL);
-}
-function detectDatabasePattern() {
-  if (process.env.DATABASE_WRITE_URL && process.env.DATABASE_READ_URL) {
-    return {
-      type: "write-read",
-      write: process.env.DATABASE_WRITE_URL,
-      read: process.env.DATABASE_READ_URL
-    };
-  }
-  if (process.env.DATABASE_URL && process.env.DATABASE_REPLICA_URL) {
-    return {
-      type: "legacy",
-      primary: process.env.DATABASE_URL,
-      replica: process.env.DATABASE_REPLICA_URL
-    };
-  }
-  if (process.env.DATABASE_URL) {
-    return {
-      type: "single",
-      url: process.env.DATABASE_URL
-    };
-  }
-  if (process.env.DATABASE_WRITE_URL) {
-    return {
-      type: "single",
-      url: process.env.DATABASE_WRITE_URL
-    };
-  }
-  return { type: "none" };
-}
-async function createWriteReadClients(writeUrl, readUrl, poolConfig, retryConfig) {
-  const writeClient = await createDatabaseConnection(writeUrl, poolConfig, retryConfig);
-  const readClient = await createDatabaseConnection(readUrl, poolConfig, retryConfig);
-  return {
-    write: drizzle(writeClient),
-    read: drizzle(readClient),
-    writeClient,
-    readClient
-  };
-}
-async function createSingleClient(url, poolConfig, retryConfig) {
-  const client = await createDatabaseConnection(url, poolConfig, retryConfig);
-  const db = drizzle(client);
-  return {
-    write: db,
-    read: db,
-    writeClient: client,
-    readClient: client
-  };
-}
-async function createDatabaseFromEnv(options) {
-  if (!hasDatabaseConfig()) {
-    dbLogger2.debug("No DATABASE_URL found, loading environment variables");
-    const result = loadEnvironment({
-      debug: true
-    });
-    dbLogger2.debug("Environment variables loaded", {
-      success: result.success,
-      loaded: result.loaded.length,
-      hasDatabaseUrl: !!process.env.DATABASE_URL,
-      hasWriteUrl: !!process.env.DATABASE_WRITE_URL,
-      hasReadUrl: !!process.env.DATABASE_READ_URL
-    });
-  }
-  if (!hasDatabaseConfig()) {
-    dbLogger2.warn("No database configuration found", {
-      cwd: process.cwd(),
-      nodeEnv: process.env.NODE_ENV,
-      checkedVars: ["DATABASE_URL", "DATABASE_WRITE_URL", "DATABASE_READ_URL"]
-    });
-    return { write: void 0, read: void 0 };
-  }
-  try {
-    const poolConfig = getPoolConfig(options?.pool);
-    const retryConfig = getRetryConfig();
-    const pattern = detectDatabasePattern();
-    switch (pattern.type) {
-      case "write-read":
-        dbLogger2.debug("Using write-read pattern", {
-          write: pattern.write.replace(/:[^:@]+@/, ":***@"),
-          read: pattern.read.replace(/:[^:@]+@/, ":***@")
-        });
-        return await createWriteReadClients(
-          pattern.write,
-          pattern.read,
-          poolConfig,
-          retryConfig
-        );
-      case "legacy":
-        dbLogger2.debug("Using legacy replica pattern", {
-          primary: pattern.primary.replace(/:[^:@]+@/, ":***@"),
-          replica: pattern.replica.replace(/:[^:@]+@/, ":***@")
-        });
-        return await createWriteReadClients(
-          pattern.primary,
-          pattern.replica,
-          poolConfig,
-          retryConfig
-        );
-      case "single":
-        dbLogger2.debug("Using single database pattern", {
-          url: pattern.url.replace(/:[^:@]+@/, ":***@")
-        });
-        return await createSingleClient(pattern.url, poolConfig, retryConfig);
-      case "none":
-        dbLogger2.warn("No database pattern detected");
-        return { write: void 0, read: void 0 };
-    }
-  } catch (error) {
-    const message = error instanceof Error ? error.message : "Unknown error";
-    dbLogger2.error("Failed to create database connection", {
-      error: message,
-      stage: "initialization",
-      hasWriteUrl: !!process.env.DATABASE_WRITE_URL,
-      hasReadUrl: !!process.env.DATABASE_READ_URL,
-      hasUrl: !!process.env.DATABASE_URL,
-      hasReplicaUrl: !!process.env.DATABASE_REPLICA_URL
-    });
-    throw new Error(`Database connection failed: ${message}`, { cause: error });
-  }
-}
-var dbLogger2;
-var init_factory2 = __esm({
-  "src/db/manager/factory.ts"() {
-    init_logger2();
-    init_env();
-    init_connection();
-    init_config3();
-    dbLogger2 = logger.child("database");
-  }
-});
-
-// src/db/manager/global-state.ts
-var getWriteInstance, setWriteInstance, getReadInstance, setReadInstance, getWriteClient, setWriteClient, getReadClient, setReadClient, getHealthCheckInterval, setHealthCheckInterval, setMonitoringConfig;
-var init_global_state = __esm({
-  "src/db/manager/global-state.ts"() {
-    getWriteInstance = () => globalThis.__SPFN_DB_WRITE__;
-    setWriteInstance = (instance) => {
-      globalThis.__SPFN_DB_WRITE__ = instance;
-    };
-    getReadInstance = () => globalThis.__SPFN_DB_READ__;
-    setReadInstance = (instance) => {
-      globalThis.__SPFN_DB_READ__ = instance;
-    };
-    getWriteClient = () => globalThis.__SPFN_DB_WRITE_CLIENT__;
-    setWriteClient = (client) => {
-      globalThis.__SPFN_DB_WRITE_CLIENT__ = client;
-    };
-    getReadClient = () => globalThis.__SPFN_DB_READ_CLIENT__;
-    setReadClient = (client) => {
-      globalThis.__SPFN_DB_READ_CLIENT__ = client;
-    };
-    getHealthCheckInterval = () => globalThis.__SPFN_DB_HEALTH_CHECK__;
-    setHealthCheckInterval = (interval) => {
-      globalThis.__SPFN_DB_HEALTH_CHECK__ = interval;
-    };
-    setMonitoringConfig = (config) => {
-      globalThis.__SPFN_DB_MONITORING__ = config;
-    };
-  }
-});
-
-// src/db/manager/health-check.ts
-function startHealthCheck(config, options, getDatabase2, closeDatabase2) {
-  const healthCheck = getHealthCheckInterval();
-  if (healthCheck) {
-    dbLogger3.debug("Health check already running");
-    return;
-  }
-  dbLogger3.info("Starting database health check", {
-    interval: `${config.interval}ms`,
-    reconnect: config.reconnect
-  });
-  const interval = setInterval(async () => {
-    try {
-      const write = getDatabase2("write");
-      const read = getDatabase2("read");
-      if (write) {
-        await write.execute("SELECT 1");
-      }
-      if (read && read !== write) {
-        await read.execute("SELECT 1");
-      }
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Unknown error";
-      dbLogger3.error("Database health check failed", { error: message });
-      if (config.reconnect) {
-        await attemptReconnection(config, options, closeDatabase2);
-      }
-    }
-  }, config.interval);
-  setHealthCheckInterval(interval);
-}
-async function attemptReconnection(config, options, closeDatabase2) {
-  dbLogger3.warn("Attempting database reconnection", {
-    maxRetries: config.maxRetries,
-    retryInterval: `${config.retryInterval}ms`
-  });
-  for (let attempt = 1; attempt <= config.maxRetries; attempt++) {
-    try {
-      dbLogger3.debug(`Reconnection attempt ${attempt}/${config.maxRetries}`);
-      await closeDatabase2();
-      await new Promise((resolve) => setTimeout(resolve, config.retryInterval));
-      const result = await createDatabaseFromEnv(options);
-      if (result.write) {
-        await result.write.execute("SELECT 1");
-        setWriteInstance(result.write);
-        setReadInstance(result.read);
-        setWriteClient(result.writeClient);
-        setReadClient(result.readClient);
-        dbLogger3.info("Database reconnection successful", { attempt });
-        return;
-      }
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Unknown error";
-      dbLogger3.error(`Reconnection attempt ${attempt} failed`, {
-        error: message,
-        attempt,
-        maxRetries: config.maxRetries
-      });
-      if (attempt === config.maxRetries) {
-        dbLogger3.error("Max reconnection attempts reached, giving up");
-      }
-    }
-  }
-}
-function stopHealthCheck() {
-  const healthCheck = getHealthCheckInterval();
-  if (healthCheck) {
-    clearInterval(healthCheck);
-    setHealthCheckInterval(void 0);
-    dbLogger3.info("Database health check stopped");
-  }
-}
-var dbLogger3;
-var init_health_check = __esm({
-  "src/db/manager/health-check.ts"() {
-    init_logger2();
-    init_factory2();
-    init_global_state();
-    dbLogger3 = logger.child("database");
-  }
-});
-
-// src/db/manager/manager.ts
-function getCallerInfo() {
-  try {
-    const stack = new Error().stack;
-    if (!stack) return void 0;
-    const lines = stack.split("\n");
-    for (let i = 3; i < lines.length; i++) {
-      const line = lines[i];
-      if (!line.includes("node_modules") && !line.includes("/db/manager/")) {
-        const match = line.match(/\((.+):(\d+):(\d+)\)/) || line.match(/at (.+):(\d+):(\d+)/);
-        if (match) {
-          const fullPath = match[1];
-          const parts = fullPath.split("/");
-          const srcIndex = parts.lastIndexOf("src");
-          if (srcIndex !== -1) {
-            const relativePath = parts.slice(srcIndex).join("/");
-            return `${relativePath}:${match[2]}`;
-          }
-          return `${fullPath}:${match[2]}`;
-        }
-        break;
-      }
-    }
-  } catch {
-  }
-  return void 0;
-}
-function getDatabase(type) {
-  const writeInst = getWriteInstance();
-  const readInst = getReadInstance();
-  if (process.env.DB_DEBUG_TRACE === "true") {
-    const caller = getCallerInfo();
-    dbLogger4.debug("getDatabase() called", {
-      type: type || "write",
-      hasWrite: !!writeInst,
-      hasRead: !!readInst,
-      caller
-    });
-  }
-  if (type === "read") {
-    return readInst ?? writeInst;
-  }
-  return writeInst;
-}
-function setDatabase(write, read) {
-  setWriteInstance(write);
-  setReadInstance(read ?? write);
-}
-async function initDatabase(options) {
-  const writeInst = getWriteInstance();
-  if (writeInst) {
-    dbLogger4.debug("Database already initialized");
-    return { write: writeInst, read: getReadInstance() };
-  }
-  const result = await createDatabaseFromEnv(options);
-  if (result.write) {
-    try {
-      await result.write.execute("SELECT 1");
-      if (result.read && result.read !== result.write) {
-        await result.read.execute("SELECT 1");
-      }
-      setWriteInstance(result.write);
-      setReadInstance(result.read);
-      setWriteClient(result.writeClient);
-      setReadClient(result.readClient);
-      const hasReplica = result.read && result.read !== result.write;
-      dbLogger4.info(
-        hasReplica ? "Database connected (Primary + Replica)" : "Database connected"
-      );
-      const healthCheckConfig = buildHealthCheckConfig(options?.healthCheck);
-      if (healthCheckConfig.enabled) {
-        startHealthCheck(healthCheckConfig, options, getDatabase, closeDatabase);
-      }
-      const monConfig = buildMonitoringConfig(options?.monitoring);
-      setMonitoringConfig(monConfig);
-      if (monConfig.enabled) {
-        dbLogger4.info("Database query monitoring enabled", {
-          slowThreshold: `${monConfig.slowThreshold}ms`,
-          logQueries: monConfig.logQueries
-        });
-      }
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Unknown error";
-      dbLogger4.error("Database connection failed", { error: message });
-      await closeDatabase();
-      throw new Error(`Database connection test failed: ${message}`, { cause: error });
-    }
-  } else {
-    dbLogger4.warn("No database configuration found");
-    dbLogger4.warn("Set DATABASE_URL environment variable to enable database");
-  }
-  return { write: getWriteInstance(), read: getReadInstance() };
-}
-async function closeDatabase() {
-  const writeInst = getWriteInstance();
-  const readInst = getReadInstance();
-  if (!writeInst && !readInst) {
-    dbLogger4.debug("No database connections to close");
-    return;
-  }
-  stopHealthCheck();
-  try {
-    const closePromises = [];
-    const writeC = getWriteClient();
-    if (writeC) {
-      dbLogger4.debug("Closing write connection...");
-      closePromises.push(
-        writeC.end({ timeout: 5 }).then(() => dbLogger4.debug("Write connection closed")).catch((err) => dbLogger4.error("Error closing write connection", err))
-      );
-    }
-    const readC = getReadClient();
-    if (readC && readC !== writeC) {
-      dbLogger4.debug("Closing read connection...");
-      closePromises.push(
-        readC.end({ timeout: 5 }).then(() => dbLogger4.debug("Read connection closed")).catch((err) => dbLogger4.error("Error closing read connection", err))
-      );
-    }
-    await Promise.all(closePromises);
-    dbLogger4.info("All database connections closed");
-  } catch (error) {
-    dbLogger4.error("Error during database cleanup", error);
-    throw error;
-  } finally {
-    setWriteInstance(void 0);
-    setReadInstance(void 0);
-    setWriteClient(void 0);
-    setReadClient(void 0);
-    setMonitoringConfig(void 0);
-  }
-}
-function getDatabaseInfo() {
-  const writeInst = getWriteInstance();
-  const readInst = getReadInstance();
-  return {
-    hasWrite: !!writeInst,
-    hasRead: !!readInst,
-    isReplica: !!(readInst && readInst !== writeInst)
-  };
-}
-var dbLogger4;
-var init_manager = __esm({
-  "src/db/manager/manager.ts"() {
-    init_logger2();
-    init_factory2();
-    init_config3();
-    init_global_state();
-    init_health_check();
-    dbLogger4 = logger.child("database");
-  }
-});
-
-// src/db/manager/index.ts
-var init_manager2 = __esm({
-  "src/db/manager/index.ts"() {
-    init_factory2();
-    init_manager();
-    init_connection();
-  }
-});
-function expandGlobPattern(pattern) {
-  if (!pattern.includes("*")) {
-    return existsSync(pattern) ? [pattern] : [];
-  }
-  const files = [];
-  if (pattern.includes("**")) {
-    const [baseDir, ...rest] = pattern.split("**");
-    const extension = rest.join("").replace(/[\/\\]\*\./g, "").trim();
-    const scanRecursive = (dir) => {
-      if (!existsSync(dir)) return;
-      try {
-        const entries = readdirSync(dir);
-        for (const entry of entries) {
-          const fullPath = join(dir, entry);
-          try {
-            const stat2 = statSync(fullPath);
-            if (stat2.isDirectory()) {
-              scanRecursive(fullPath);
-            } else if (stat2.isFile()) {
-              if (!extension || fullPath.endsWith(extension)) {
-                files.push(fullPath);
-              }
-            }
-          } catch {
-          }
-        }
-      } catch {
-      }
-    };
-    scanRecursive(baseDir.trim() || ".");
-  } else if (pattern.includes("*")) {
-    const dir = dirname(pattern);
-    const filePattern = basename(pattern);
-    if (!existsSync(dir)) return [];
-    try {
-      const entries = readdirSync(dir);
-      for (const entry of entries) {
-        const fullPath = join(dir, entry);
-        try {
-          const stat2 = statSync(fullPath);
-          if (stat2.isFile()) {
-            if (filePattern === "*" || filePattern.startsWith("*.") && entry.endsWith(filePattern.slice(1))) {
-              files.push(fullPath);
-            }
-          }
-        } catch {
-        }
-      }
-    } catch {
-    }
-  }
-  return files;
-}
-function discoverPackageSchemas(cwd) {
-  const schemas = [];
-  const nodeModulesPath = join(cwd, "node_modules");
-  if (!existsSync(nodeModulesPath)) {
-    return schemas;
-  }
-  const projectPkgPath = join(cwd, "package.json");
-  let directDeps = /* @__PURE__ */ new Set();
-  if (existsSync(projectPkgPath)) {
-    try {
-      const projectPkg = JSON.parse(readFileSync(projectPkgPath, "utf-8"));
-      directDeps = /* @__PURE__ */ new Set([
-        ...Object.keys(projectPkg.dependencies || {}),
-        ...Object.keys(projectPkg.devDependencies || {})
-      ]);
-    } catch (error) {
-    }
-  }
-  const checkPackage = (_pkgName, pkgPath) => {
-    const pkgJsonPath = join(pkgPath, "package.json");
-    if (!existsSync(pkgJsonPath)) return;
-    try {
-      const pkgJson = JSON.parse(readFileSync(pkgJsonPath, "utf-8"));
-      if (pkgJson.spfn?.schemas) {
-        const packageSchemas = Array.isArray(pkgJson.spfn.schemas) ? pkgJson.spfn.schemas : [pkgJson.spfn.schemas];
-        for (const schema of packageSchemas) {
-          const absolutePath = join(pkgPath, schema);
-          const expandedFiles = expandGlobPattern(absolutePath);
-          const schemaFiles = expandedFiles.filter(
-            (file) => !file.endsWith("/index.js") && !file.endsWith("/index.ts") && !file.endsWith("/index.mjs") && !file.endsWith("\\index.js") && !file.endsWith("\\index.ts") && !file.endsWith("\\index.mjs")
-          );
-          schemas.push(...schemaFiles);
-        }
-      }
-    } catch (error) {
-    }
-  };
-  const spfnDir = join(nodeModulesPath, "@spfn");
-  if (existsSync(spfnDir)) {
-    try {
-      const spfnPackages = readdirSync(spfnDir);
-      for (const pkg of spfnPackages) {
-        checkPackage(`@spfn/${pkg}`, join(spfnDir, pkg));
-      }
-    } catch (error) {
-    }
-  }
-  for (const depName of directDeps) {
-    if (depName.startsWith("@spfn/")) continue;
-    const pkgPath = depName.startsWith("@") ? join(nodeModulesPath, ...depName.split("/")) : join(nodeModulesPath, depName);
-    checkPackage(depName, pkgPath);
-  }
-  return schemas;
-}
-function detectDialect(url) {
-  if (url.startsWith("postgres://") || url.startsWith("postgresql://")) {
-    return "postgresql";
-  }
-  if (url.startsWith("mysql://")) {
-    return "mysql";
-  }
-  if (url.startsWith("sqlite://") || url.includes(".db") || url.includes(".sqlite")) {
-    return "sqlite";
-  }
-  throw new Error(
-    `Unsupported database URL format: ${url}. Supported: postgresql://, mysql://, sqlite://`
-  );
-}
-function getDrizzleConfig(options = {}) {
-  const databaseUrl = options.databaseUrl ?? process.env.DATABASE_URL;
-  if (!databaseUrl) {
-    throw new Error(
-      "DATABASE_URL is required. Set it in .env or pass it to getDrizzleConfig()"
-    );
-  }
-  const dialect = options.dialect ?? detectDialect(databaseUrl);
-  const out = options.out ?? "./src/server/drizzle";
-  if (options.packageFilter) {
-    const packageSchemas2 = options.disablePackageDiscovery ? [] : discoverPackageSchemas(options.cwd ?? process.cwd());
-    const filteredSchemas = packageSchemas2.filter(
-      (schemaPath) => schemaPath.includes(`node_modules/${options.packageFilter}/`)
-    );
-    if (filteredSchemas.length === 0) {
-      throw new Error(
-        `No schemas found for package ${options.packageFilter}. Make sure the package is installed and has "spfn.schemas" in package.json.`
-      );
-    }
-    const schema2 = filteredSchemas.length === 1 ? filteredSchemas[0] : filteredSchemas;
-    return {
-      schema: schema2,
-      out,
-      dialect,
-      dbCredentials: getDbCredentials(dialect, databaseUrl)
-    };
-  }
-  const userSchema = options.schema ?? "./src/server/entities/**/*.ts";
-  const userSchemas = Array.isArray(userSchema) ? userSchema : [userSchema];
-  const packageSchemas = options.disablePackageDiscovery ? [] : discoverPackageSchemas(options.cwd ?? process.cwd());
-  const allSchemas = [...userSchemas, ...packageSchemas];
-  const schema = allSchemas.length === 1 ? allSchemas[0] : allSchemas;
-  return {
-    schema,
-    out,
-    dialect,
-    dbCredentials: getDbCredentials(dialect, databaseUrl)
-  };
-}
-function getDbCredentials(dialect, url) {
-  switch (dialect) {
-    case "postgresql":
-    case "mysql":
-      return { url };
-    case "sqlite":
-      const dbPath = url.replace("sqlite://", "").replace("sqlite:", "");
-      return { url: dbPath };
-    default:
-      throw new Error(`Unsupported dialect: ${dialect}`);
-  }
-}
-function generateDrizzleConfigFile(options = {}) {
-  const config = getDrizzleConfig(options);
-  const schemaValue = Array.isArray(config.schema) ? `[
-        ${config.schema.map((s) => `'${s}'`).join(",\n        ")}
-    ]` : `'${config.schema}'`;
-  return `import { defineConfig } from 'drizzle-kit';
-
-export default defineConfig({
-    schema: ${schemaValue},
-    out: '${config.out}',
-    dialect: '${config.dialect}',
-    dbCredentials: ${JSON.stringify(config.dbCredentials, null, 4)},
-});
-`;
-}
-var init_config_generator = __esm({
-  "src/db/manager/config-generator.ts"() {
-  }
-});
-function id() {
-  return bigserial("id", { mode: "number" }).primaryKey();
-}
-function timestamps(options) {
-  const updatedAtColumn = timestamp("updated_at", { withTimezone: true, mode: "date" }).defaultNow().notNull();
-  if (options?.autoUpdate) {
-    updatedAtColumn.__autoUpdate = true;
-  }
-  return {
-    createdAt: timestamp("created_at", { withTimezone: true, mode: "date" }).defaultNow().notNull(),
-    updatedAt: updatedAtColumn
-  };
-}
-function foreignKey(name, reference, options) {
-  return bigserial(`${name}_id`, { mode: "number" }).notNull().references(reference, { onDelete: options?.onDelete ?? "cascade" });
-}
-function optionalForeignKey(name, reference, options) {
-  return bigserial(`${name}_id`, { mode: "number" }).references(reference, { onDelete: options?.onDelete ?? "set null" });
-}
-var init_helpers = __esm({
-  "src/db/schema/helpers.ts"() {
-  }
-});
-
-// src/db/schema/index.ts
-var init_schema = __esm({
-  "src/db/schema/index.ts"() {
-    init_helpers();
-  }
-});
-function createFunctionSchema(packageName) {
-  const schemaName = packageNameToSchema(packageName);
-  return pgSchema(schemaName);
-}
-function packageNameToSchema(packageName) {
-  return packageName.replace("@", "").replace("/", "_").replace(/-/g, "_");
-}
-function getSchemaInfo(packageName) {
-  const isScoped = packageName.startsWith("@");
-  const scope = isScoped ? packageName.split("/")[0].substring(1) : null;
-  const schemaName = packageNameToSchema(packageName);
-  return {
-    schemaName,
-    isScoped,
-    scope
-  };
-}
-var init_schema_helper = __esm({
-  "src/db/schema-helper.ts"() {
-  }
-});
-function getTransactionContext() {
-  return asyncContext.getStore() ?? null;
-}
-function getTransaction() {
-  const context = getTransactionContext();
-  return context?.tx ?? null;
-}
-function runWithTransaction(tx, txId, callback) {
-  const existingContext = getTransactionContext();
-  const newLevel = existingContext ? existingContext.level + 1 : 1;
-  if (existingContext) {
-    txLogger.info("Nested transaction started (SAVEPOINT)", {
-      outerTxId: existingContext.txId,
-      innerTxId: txId,
-      level: newLevel
-    });
-  } else {
-    txLogger.debug("Root transaction context set", { txId, level: newLevel });
-  }
-  return asyncContext.run({ tx, txId, level: newLevel }, callback);
-}
-var txLogger, asyncContext;
-var init_context = __esm({
-  "src/db/transaction/context.ts"() {
-    init_logger2();
-    txLogger = logger.child("transaction");
-    asyncContext = new AsyncLocalStorage();
-  }
-});
-function Transactional(options = {}) {
-  const defaultTimeout = parseInt(process.env.TRANSACTION_TIMEOUT || "30000", 10);
-  const {
-    slowThreshold = 1e3,
-    enableLogging = true,
-    timeout = defaultTimeout
-  } = options;
-  const txLogger2 = logger.child("transaction");
-  return createMiddleware(async (c, next) => {
-    const txId = `tx_${randomUUID()}`;
-    const startTime = Date.now();
-    const route = `${c.req.method} ${c.req.path}`;
-    if (enableLogging) {
-      txLogger2.debug("Transaction started", { txId, route });
-    }
-    try {
-      const writeDb = getDatabase("write");
-      if (!writeDb) {
-        throw new TransactionError(
-          "Database not initialized. Cannot start transaction.",
-          500,
-          { txId, route }
-        );
-      }
-      const transactionPromise = writeDb.transaction(async (tx) => {
-        await runWithTransaction(tx, txId, async () => {
-          await next();
-          const contextWithError = c;
-          if (contextWithError.error) {
-            throw contextWithError.error;
-          }
-        });
-      });
-      if (timeout > 0) {
-        const timeoutPromise = new Promise((_, reject) => {
-          setTimeout(() => {
-            reject(
-              new TransactionError(
-                `Transaction timeout after ${timeout}ms`,
-                500,
-                {
-                  txId,
-                  route,
-                  timeout: `${timeout}ms`
-                }
-              )
-            );
-          }, timeout);
-        });
-        await Promise.race([transactionPromise, timeoutPromise]);
-      } else {
-        await transactionPromise;
-      }
-      const duration = Date.now() - startTime;
-      if (enableLogging) {
-        if (duration >= slowThreshold) {
-          txLogger2.warn("Slow transaction committed", {
-            txId,
-            route,
-            duration: `${duration}ms`,
-            threshold: `${slowThreshold}ms`
-          });
-        } else {
-          txLogger2.debug("Transaction committed", {
-            txId,
-            route,
-            duration: `${duration}ms`
-          });
-        }
-      }
-    } catch (error) {
-      const duration = Date.now() - startTime;
-      const customError = error instanceof TransactionError ? error : fromPostgresError(error);
-      if (enableLogging) {
-        txLogger2.error("Transaction rolled back", {
-          txId,
-          route,
-          duration: `${duration}ms`,
-          error: customError.message,
-          errorType: customError.name
-        });
-      }
-      throw customError;
-    }
-  });
-}
-var init_middleware = __esm({
-  "src/db/transaction/middleware.ts"() {
-    init_logger2();
-    init_manager2();
-    init_context();
-    init_errors();
-    init_postgres_errors();
-  }
-});
-
-// src/db/transaction/index.ts
-var init_transaction = __esm({
-  "src/db/transaction/index.ts"() {
-    init_context();
-    init_middleware();
-  }
-});
-function isSQLWrapper(value) {
-  return value && typeof value === "object" && "queryChunks" in value;
-}
-function buildWhereFromObject(table, where) {
-  const entries = Object.entries(where).filter(([_, value]) => value !== void 0);
-  if (entries.length === 0) return void 0;
-  const conditions = entries.map(
-    ([key, value]) => eq(table[key], value)
-  );
-  return conditions.length === 1 ? conditions[0] : and(...conditions);
-}
-async function findOne(table, where) {
-  const db = getDatabase("read");
-  if (!db) {
-    throw new Error("Database not initialized. Call initDatabase() first.");
-  }
-  const whereClause = isSQLWrapper(where) ? where : where ? buildWhereFromObject(table, where) : void 0;
-  if (!whereClause) {
-    throw new Error("findOne requires at least one where condition");
-  }
-  const results = await db.select().from(table).where(whereClause).limit(1);
-  return results[0] ?? null;
-}
-async function findMany(table, options) {
-  const db = getDatabase("read");
-  if (!db) {
-    throw new Error("Database not initialized. Call initDatabase() first.");
-  }
-  let query = db.select().from(table);
-  if (options?.where) {
-    const whereClause = isSQLWrapper(options.where) ? options.where : options.where ? buildWhereFromObject(table, options.where) : void 0;
-    if (whereClause) {
-      query = query.where(whereClause);
-    }
-  }
-  if (options?.orderBy) {
-    const orderByArray = Array.isArray(options.orderBy) ? options.orderBy : [options.orderBy];
-    query = query.orderBy(...orderByArray);
-  }
-  if (options?.limit) {
-    query = query.limit(options.limit);
-  }
-  if (options?.offset) {
-    query = query.offset(options.offset);
-  }
-  return query;
-}
-async function create(table, data) {
-  const db = getDatabase("write");
-  if (!db) {
-    throw new Error("Database not initialized. Call initDatabase() first.");
-  }
-  const [result] = await db.insert(table).values(data).returning();
-  return result;
-}
-async function createMany(table, data) {
-  const db = getDatabase("write");
-  if (!db) {
-    throw new Error("Database not initialized. Call initDatabase() first.");
-  }
-  const results = await db.insert(table).values(data).returning();
-  return results;
-}
-async function upsert(table, data, options) {
-  const db = getDatabase("write");
-  if (!db) {
-    throw new Error("Database not initialized. Call initDatabase() first.");
-  }
-  const [result] = await db.insert(table).values(data).onConflictDoUpdate({
-    target: options.target,
-    set: options.set || data
-  }).returning();
-  return result;
-}
-async function updateOne(table, where, data) {
-  const db = getDatabase("write");
-  if (!db) {
-    throw new Error("Database not initialized. Call initDatabase() first.");
-  }
-  const whereClause = isSQLWrapper(where) ? where : where ? buildWhereFromObject(table, where) : void 0;
-  if (!whereClause) {
-    throw new Error("updateOne requires at least one where condition");
-  }
-  const [result] = await db.update(table).set(data).where(whereClause).returning();
-  return result ?? null;
-}
-async function updateMany(table, where, data) {
-  const db = getDatabase("write");
-  if (!db) {
-    throw new Error("Database not initialized. Call initDatabase() first.");
-  }
-  const whereClause = isSQLWrapper(where) ? where : where ? buildWhereFromObject(table, where) : void 0;
-  if (!whereClause) {
-    throw new Error("updateMany requires at least one where condition");
-  }
-  const results = await db.update(table).set(data).where(whereClause).returning();
-  return results;
-}
-async function deleteOne(table, where) {
-  const db = getDatabase("write");
-  if (!db) {
-    throw new Error("Database not initialized. Call initDatabase() first.");
-  }
-  const whereClause = isSQLWrapper(where) ? where : where ? buildWhereFromObject(table, where) : void 0;
-  if (!whereClause) {
-    throw new Error("deleteOne requires at least one where condition");
-  }
-  const [result] = await db.delete(table).where(whereClause).returning();
-  return result ?? null;
-}
-async function deleteMany(table, where) {
-  const db = getDatabase("write");
-  if (!db) {
-    throw new Error("Database not initialized. Call initDatabase() first.");
-  }
-  const whereClause = isSQLWrapper(where) ? where : where ? buildWhereFromObject(table, where) : void 0;
-  if (!whereClause) {
-    throw new Error("deleteMany requires at least one where condition");
-  }
-  const results = await db.delete(table).where(whereClause).returning();
-  return results;
-}
-async function count(table, where) {
-  const db = getDatabase("read");
-  if (!db) {
-    throw new Error("Database not initialized. Call initDatabase() first.");
-  }
-  let query = db.select().from(table);
-  if (where) {
-    const whereClause = isSQLWrapper(where) ? where : where ? buildWhereFromObject(table, where) : void 0;
-    if (whereClause) {
-      query = query.where(whereClause);
-    }
-  }
-  const results = await query;
-  return results.length;
-}
-var init_helpers2 = __esm({
-  "src/db/helpers.ts"() {
-    init_manager2();
-  }
-});
-
-// src/db/index.ts
-var db_exports = {};
-__export(db_exports, {
-  Transactional: () => Transactional,
-  checkConnection: () => checkConnection,
-  closeDatabase: () => closeDatabase,
-  count: () => count,
-  create: () => create,
-  createDatabaseConnection: () => createDatabaseConnection,
-  createDatabaseFromEnv: () => createDatabaseFromEnv,
-  createFunctionSchema: () => createFunctionSchema,
-  createMany: () => createMany,
-  deleteMany: () => deleteMany,
-  deleteOne: () => deleteOne,
-  detectDialect: () => detectDialect,
-  findMany: () => findMany,
-  findOne: () => findOne,
-  foreignKey: () => foreignKey,
-  fromPostgresError: () => fromPostgresError,
-  generateDrizzleConfigFile: () => generateDrizzleConfigFile,
-  getDatabase: () => getDatabase,
-  getDatabaseInfo: () => getDatabaseInfo,
-  getDrizzleConfig: () => getDrizzleConfig,
-  getSchemaInfo: () => getSchemaInfo,
-  getTransaction: () => getTransaction,
-  id: () => id,
-  initDatabase: () => initDatabase,
-  optionalForeignKey: () => optionalForeignKey,
-  packageNameToSchema: () => packageNameToSchema,
-  runWithTransaction: () => runWithTransaction,
-  setDatabase: () => setDatabase,
-  timestamps: () => timestamps,
-  updateMany: () => updateMany,
-  updateOne: () => updateOne,
-  upsert: () => upsert
-});
-var init_db = __esm({
-  "src/db/index.ts"() {
-    init_manager2();
-    init_config_generator();
-    init_schema();
-    init_schema_helper();
-    init_transaction();
-    init_postgres_errors();
-    init_helpers2();
-  }
-});
-
-// src/cache/cache-factory.ts
-function hasCacheConfig() {
-  return !!// Modern (Valkey/Cache)
-  (process.env.VALKEY_URL || process.env.CACHE_URL || process.env.VALKEY_WRITE_URL || process.env.VALKEY_READ_URL || process.env.CACHE_WRITE_URL || process.env.CACHE_READ_URL || process.env.VALKEY_SENTINEL_HOSTS || process.env.VALKEY_CLUSTER_NODES || // Legacy (Redis - backward compatibility)
-  process.env.REDIS_URL || process.env.REDIS_WRITE_URL || process.env.REDIS_READ_URL || process.env.REDIS_SENTINEL_HOSTS || process.env.REDIS_CLUSTER_NODES);
-}
-function getEnv(valkeyKey, cacheKey, redisKey) {
-  return process.env[valkeyKey] || process.env[cacheKey] || process.env[redisKey];
-}
-function createClient(RedisClient, url) {
-  const options = {};
-  if (url.startsWith("rediss://") || url.startsWith("valkeys://")) {
-    const rejectUnauthorized = getEnv(
-      "VALKEY_TLS_REJECT_UNAUTHORIZED",
-      "CACHE_TLS_REJECT_UNAUTHORIZED",
-      "REDIS_TLS_REJECT_UNAUTHORIZED"
-    );
-    options.tls = {
-      rejectUnauthorized: rejectUnauthorized !== "false"
-    };
-  }
-  return new RedisClient(url, options);
-}
-async function createCacheFromEnv() {
-  if (!hasCacheConfig()) {
-    cacheLogger.info("No cache configuration found - running without cache");
-    return { write: void 0, read: void 0 };
-  }
-  try {
-    const ioredis = await import('ioredis');
-    const RedisClient = ioredis.default;
-    const singleUrl = getEnv("VALKEY_URL", "CACHE_URL", "REDIS_URL");
-    const writeUrl = getEnv("VALKEY_WRITE_URL", "CACHE_WRITE_URL", "REDIS_WRITE_URL");
-    const readUrl = getEnv("VALKEY_READ_URL", "CACHE_READ_URL", "REDIS_READ_URL");
-    const clusterNodes = getEnv("VALKEY_CLUSTER_NODES", "CACHE_CLUSTER_NODES", "REDIS_CLUSTER_NODES");
-    const sentinelHosts = getEnv("VALKEY_SENTINEL_HOSTS", "CACHE_SENTINEL_HOSTS", "REDIS_SENTINEL_HOSTS");
-    const masterName = getEnv("VALKEY_MASTER_NAME", "CACHE_MASTER_NAME", "REDIS_MASTER_NAME");
-    const password = getEnv("VALKEY_PASSWORD", "CACHE_PASSWORD", "REDIS_PASSWORD");
-    if (singleUrl && !writeUrl && !readUrl && !clusterNodes) {
-      const client = createClient(RedisClient, singleUrl);
-      cacheLogger.debug("Created single cache instance", { url: singleUrl.replace(/:[^:@]+@/, ":***@") });
-      return { write: client, read: client };
-    }
-    if (writeUrl && readUrl) {
-      const write = createClient(RedisClient, writeUrl);
-      const read = createClient(RedisClient, readUrl);
-      cacheLogger.debug("Created master-replica cache instances");
-      return { write, read };
-    }
-    if (sentinelHosts && masterName) {
-      const sentinels = sentinelHosts.split(",").map((host) => {
-        const [hostname, port] = host.trim().split(":");
-        return { host: hostname, port: Number(port) || 26379 };
-      });
-      const options = {
-        sentinels,
-        name: masterName,
-        password
-      };
-      const client = new RedisClient(options);
-      cacheLogger.debug("Created sentinel cache instance", { masterName, sentinels: sentinels.length });
-      return { write: client, read: client };
-    }
-    if (clusterNodes) {
-      const nodes = clusterNodes.split(",").map((node) => {
-        const [host, port] = node.trim().split(":");
-        return { host, port: Number(port) || 6379 };
-      });
-      const clusterOptions = {
-        redisOptions: {
-          password
-        }
-      };
-      const cluster = new RedisClient.Cluster(nodes, clusterOptions);
-      cacheLogger.debug("Created cluster cache instance", { nodes: nodes.length });
-      return { write: cluster, read: cluster };
-    }
-    if (singleUrl) {
-      const client = createClient(RedisClient, singleUrl);
-      cacheLogger.debug("Created cache instance (fallback)", { url: singleUrl.replace(/:[^:@]+@/, ":***@") });
-      return { write: client, read: client };
-    }
-    cacheLogger.info("No valid cache configuration found - running without cache");
-    return { write: void 0, read: void 0 };
-  } catch (error) {
-    if (error instanceof Error) {
-      if (error.message.includes("Cannot find module")) {
-        cacheLogger.warn(
-          "Cache client library not installed",
-          error,
-          {
-            suggestion: "Install ioredis to enable cache: pnpm install ioredis",
-            mode: "disabled"
-          }
-        );
-      } else {
-        cacheLogger.warn(
-          "Failed to create cache client",
-          error,
-          { mode: "disabled" }
-        );
-      }
-    } else {
-      cacheLogger.warn(
-        "Failed to create cache client",
-        { error: String(error), mode: "disabled" }
-      );
-    }
-    return { write: void 0, read: void 0 };
-  }
-}
-async function createSingleCacheFromEnv() {
-  const { write } = await createCacheFromEnv();
-  return write;
-}
-var cacheLogger;
-var init_cache_factory = __esm({
-  "src/cache/cache-factory.ts"() {
-    init_logger2();
-    cacheLogger = logger.child("cache");
-  }
-});
-
-// src/cache/cache-manager.ts
-function getCache() {
-  return writeInstance;
-}
-function getCacheRead() {
-  return readInstance ?? writeInstance;
-}
-function isCacheDisabled() {
-  return isDisabled;
-}
-function setCache(write, read) {
-  writeInstance = write;
-  readInstance = read ?? write;
-  isDisabled = !write;
-}
-async function initCache() {
-  if (writeInstance) {
-    return { write: writeInstance, read: readInstance, disabled: isDisabled };
-  }
-  const { write, read } = await createCacheFromEnv();
-  if (write) {
-    try {
-      await write.ping();
-      if (read && read !== write) {
-        await read.ping();
-      }
-      writeInstance = write;
-      readInstance = read;
-      isDisabled = false;
-      const hasReplica = read && read !== write;
-      cacheLogger2.info(
-        hasReplica ? "Cache connected (Master-Replica)" : "Cache connected",
-        { mode: "enabled" }
-      );
-      return { write: writeInstance, read: readInstance, disabled: false };
-    } catch (error) {
-      cacheLogger2.error(
-        "Cache connection failed - running in disabled mode",
-        error instanceof Error ? error : new Error(String(error)),
-        { mode: "disabled" }
-      );
-      try {
-        await write.quit();
-        if (read && read !== write) {
-          await read.quit();
-        }
-      } catch {
-      }
-      isDisabled = true;
-      return { write: void 0, read: void 0, disabled: true };
-    }
-  }
-  isDisabled = true;
-  cacheLogger2.info("Cache disabled - no configuration or library not installed", { mode: "disabled" });
-  return { write: void 0, read: void 0, disabled: true };
-}
-async function closeCache() {
-  if (isDisabled) {
-    cacheLogger2.debug("Cache already disabled, nothing to close");
-    return;
-  }
-  const closePromises = [];
-  if (writeInstance) {
-    closePromises.push(
-      writeInstance.quit().catch((err) => {
-        cacheLogger2.error("Error closing cache write instance", err);
-      })
-    );
-  }
-  if (readInstance && readInstance !== writeInstance) {
-    closePromises.push(
-      readInstance.quit().catch((err) => {
-        cacheLogger2.error("Error closing cache read instance", err);
-      })
-    );
-  }
-  await Promise.all(closePromises);
-  writeInstance = void 0;
-  readInstance = void 0;
-  isDisabled = true;
-  cacheLogger2.info("Cache connections closed", { mode: "disabled" });
-}
-function getCacheInfo() {
-  return {
-    hasWrite: !!writeInstance,
-    hasRead: !!readInstance,
-    isReplica: !!(readInstance && readInstance !== writeInstance),
-    disabled: isDisabled
-  };
-}
-var cacheLogger2, writeInstance, readInstance, isDisabled, getRedis, getRedisRead, setRedis, initRedis, closeRedis, getRedisInfo;
-var init_cache_manager = __esm({
-  "src/cache/cache-manager.ts"() {
-    init_cache_factory();
-    init_logger2();
-    cacheLogger2 = logger.child("cache");
-    isDisabled = false;
-    getRedis = getCache;
-    getRedisRead = getCacheRead;
-    setRedis = setCache;
-    initRedis = initCache;
-    closeRedis = closeCache;
-    getRedisInfo = getCacheInfo;
-  }
-});
-
-// src/cache/index.ts
-var cache_exports = {};
-__export(cache_exports, {
-  closeCache: () => closeCache,
-  closeRedis: () => closeRedis,
-  createCacheFromEnv: () => createCacheFromEnv,
-  createRedisFromEnv: () => createCacheFromEnv,
-  createSingleCacheFromEnv: () => createSingleCacheFromEnv,
-  createSingleRedisFromEnv: () => createSingleCacheFromEnv,
-  getCache: () => getCache,
-  getCacheInfo: () => getCacheInfo,
-  getCacheRead: () => getCacheRead,
-  getRedis: () => getRedis,
-  getRedisInfo: () => getRedisInfo,
-  getRedisRead: () => getRedisRead,
-  initCache: () => initCache,
-  initRedis: () => initRedis,
-  isCacheDisabled: () => isCacheDisabled,
-  setCache: () => setCache,
-  setRedis: () => setRedis
-});
-var init_cache = __esm({
-  "src/cache/index.ts"() {
-    init_cache_factory();
-    init_cache_manager();
-    init_cache_manager();
-    init_cache_factory();
-  }
-});
-
-// src/route/auto-loader.ts
-init_logger2();
-var routeLogger2 = logger.child("route");
-var AutoRouteLoader = class {
-  constructor(routesDir, debug = false, middlewares = []) {
-    this.routesDir = routesDir;
-    this.debug = debug;
-    this.middlewares = middlewares;
-  }
-  routes = [];
-  debug;
-  middlewares;
-  async load(app) {
-    const startTime = Date.now();
-    const files = await this.scanFiles(this.routesDir);
-    if (files.length === 0) {
-      routeLogger2.warn("No route files found");
-      return this.getStats();
-    }
-    let failureCount = 0;
-    for (const file of files) {
-      const success = await this.loadRoute(app, file);
-      if (success) ; else {
-        failureCount++;
-      }
-    }
-    const elapsed = Date.now() - startTime;
-    const stats = this.getStats();
-    if (this.debug) {
-      this.logStats(stats, elapsed);
-    }
-    if (failureCount > 0) {
-      routeLogger2.warn("Some routes failed to load", { failureCount });
-    }
-    return stats;
-  }
-  /**
-   * Load routes from an external directory (e.g., from SPFN function packages)
-   * Reads package.json spfn.prefix and mounts routes under that prefix
-   *
-   * @param app - Hono app instance
-   * @param routesDir - Directory containing route handlers
-   * @param packageName - Name of the package (for logging)
-   * @param prefix - Optional prefix to mount routes under (from package.json spfn.prefix)
-   * @returns Route statistics
-   */
-  async loadExternalRoutes(app, routesDir, packageName, prefix) {
-    const startTime = Date.now();
-    const tempRoutesDir = this.routesDir;
-    this.routesDir = routesDir;
-    const files = await this.scanFiles(routesDir);
-    if (files.length === 0) {
-      routeLogger2.warn("No route files found", { dir: routesDir, package: packageName });
-      this.routesDir = tempRoutesDir;
-      return this.getStats();
-    }
-    let successCount = 0;
-    let failureCount = 0;
-    for (const file of files) {
-      const success = await this.loadRoute(app, file, prefix);
-      if (success) {
-        successCount++;
-      } else {
-        failureCount++;
-      }
-    }
-    const elapsed = Date.now() - startTime;
-    if (this.debug) {
-      routeLogger2.info("External routes loaded", {
-        package: packageName,
-        prefix: prefix || "/",
-        total: successCount,
-        failed: failureCount,
-        elapsed: `${elapsed}ms`
-      });
-    }
-    this.routesDir = tempRoutesDir;
-    return this.getStats();
-  }
-  getStats() {
-    const stats = {
-      total: this.routes.length,
-      byPriority: { static: 0, dynamic: 0, catchAll: 0 },
-      byTag: {},
-      routes: this.routes
-    };
-    for (const route of this.routes) {
-      if (route.priority === 1) stats.byPriority.static++;
-      else if (route.priority === 2) stats.byPriority.dynamic++;
-      else if (route.priority === 3) stats.byPriority.catchAll++;
-      if (route.meta?.tags) {
-        for (const tag of route.meta.tags) {
-          stats.byTag[tag] = (stats.byTag[tag] || 0) + 1;
-        }
-      }
-    }
-    return stats;
-  }
-  async scanFiles(dir, files = []) {
-    const entries = await readdir(dir);
-    for (const entry of entries) {
-      const fullPath = join(dir, entry);
-      const fileStat = await stat(fullPath);
-      if (fileStat.isDirectory()) {
-        await this.scanFiles(fullPath, files);
-      } else if (this.isValidRouteFile(entry)) {
-        files.push(fullPath);
-      }
-    }
-    return files;
-  }
-  isValidRouteFile(fileName) {
-    return fileName === "index.ts" || fileName === "index.js" || fileName === "index.mjs";
-  }
-  async loadRoute(app, absolutePath, prefix) {
-    const relativePath = relative(this.routesDir, absolutePath);
-    try {
-      const module = await import(absolutePath);
-      if (!this.validateModule(module, relativePath)) {
-        return false;
-      }
-      const hasContractMetas = module.default._contractMetas && module.default._contractMetas.size > 0;
-      if (!hasContractMetas) {
-        routeLogger2.error("Route must use contract-based routing", {
-          file: relativePath,
-          hint: "Export contracts using satisfies RouteContract and use app.bind()"
-        });
-        return false;
-      }
-      const contractPaths = this.extractContractPaths(module);
-      if (prefix) {
-        const invalidPaths = contractPaths.filter((path) => !path.startsWith(prefix));
-        if (invalidPaths.length > 0) {
-          routeLogger2.error("Contract paths must include the package prefix", {
-            file: relativePath,
-            prefix,
-            invalidPaths,
-            hint: `Contract paths should start with "${prefix}". Example: path: "${prefix}/labels"`
-          });
-          return false;
-        }
-      }
-      this.registerContractBasedMiddlewares(app, contractPaths, module);
-      app.route("/", module.default);
-      contractPaths.forEach((path) => {
-        this.routes.push({
-          path,
-          // Use contract path as-is (already includes prefix)
-          file: relativePath,
-          meta: module.meta,
-          priority: this.calculateContractPriority(path)
-        });
-        if (this.debug) {
-          const icon = path.includes("*") ? "\u2B50" : path.includes(":") ? "\u{1F538}" : "\u{1F539}";
-          routeLogger2.debug(`Registered route: ${path}`, { icon, file: relativePath });
-        }
-      });
-      return true;
-    } catch (error) {
-      this.categorizeAndLogError(error, relativePath);
-      return false;
-    }
-  }
-  extractContractPaths(module) {
-    const paths = /* @__PURE__ */ new Set();
-    if (module.default._contractMetas) {
-      for (const key of module.default._contractMetas.keys()) {
-        const path = key.split(" ")[1];
-        if (path) {
-          paths.add(path);
-        }
-      }
-    }
-    return Array.from(paths);
-  }
-  calculateContractPriority(path) {
-    if (path.includes("*")) return 3;
-    if (path.includes(":")) return 2;
-    return 1;
-  }
-  validateModule(module, relativePath) {
-    if (!module.default) {
-      routeLogger2.error("Route must export Hono instance as default", { file: relativePath });
-      return false;
-    }
-    if (typeof module.default.route !== "function") {
-      routeLogger2.error("Default export is not a Hono instance", { file: relativePath });
-      return false;
-    }
-    return true;
-  }
-  registerContractBasedMiddlewares(app, contractPaths, module) {
-    app.use("*", (c, next) => {
-      const method = c.req.method;
-      const requestPath = new URL(c.req.url).pathname;
-      const key = `${method} ${requestPath}`;
-      const meta = module.default._contractMetas?.get(key);
-      if (meta?.skipMiddlewares) {
-        c.set("_skipMiddlewares", meta.skipMiddlewares);
-      }
-      return next();
-    });
-    for (const contractPath of contractPaths) {
-      const middlewarePath = contractPath === "/" ? "/*" : `${contractPath}/*`;
-      for (const middleware of this.middlewares) {
-        app.use(middlewarePath, async (c, next) => {
-          const skipList = c.get("_skipMiddlewares") || [];
-          if (skipList.includes(middleware.name)) {
-            return next();
-          }
-          return middleware.handler(c, next);
-        });
-      }
-    }
-  }
-  categorizeAndLogError(error, relativePath) {
-    const message = error.message;
-    const stack = error.stack;
-    if (message.includes("Cannot find module") || message.includes("MODULE_NOT_FOUND")) {
-      routeLogger2.error("Missing dependency", {
-        file: relativePath,
-        error: message,
-        hint: "Run: npm install"
-      });
-    } else if (message.includes("SyntaxError") || stack?.includes("SyntaxError")) {
-      routeLogger2.error("Syntax error", {
-        file: relativePath,
-        error: message,
-        ...this.debug && stack && {
-          stack: stack.split("\n").slice(0, 5).join("\n")
-        }
-      });
-    } else if (message.includes("Unexpected token")) {
-      routeLogger2.error("Parse error", {
-        file: relativePath,
-        error: message,
-        hint: "Check for syntax errors or invalid TypeScript"
-      });
-    } else {
-      routeLogger2.error("Route loading failed", {
-        file: relativePath,
-        error: message,
-        ...this.debug && stack && { stack }
-      });
-    }
-  }
-  logStats(stats, elapsed) {
-    const tagCounts = Object.entries(stats.byTag).map(([tag, count2]) => `${tag}(${count2})`).join(", ");
-    routeLogger2.info("Routes loaded successfully", {
-      total: stats.total,
-      priority: {
-        static: stats.byPriority.static,
-        dynamic: stats.byPriority.dynamic,
-        catchAll: stats.byPriority.catchAll
-      },
-      ...tagCounts && { tags: tagCounts },
-      elapsed: `${elapsed}ms`
-    });
-  }
-};
-async function loadRoutes(app, options) {
-  const routesDir = options?.routesDir ?? join(process.cwd(), "src", "server", "routes");
-  const debug = options?.debug ?? false;
-  const middlewares = options?.middlewares ?? [];
-  const includeFunctionRoutes = options?.includeFunctionRoutes ?? true;
-  const loader = new AutoRouteLoader(routesDir, debug, middlewares);
-  const stats = await loader.load(app);
-  if (includeFunctionRoutes) {
-    const { discoverFunctionRoutes: discoverFunctionRoutes2 } = await Promise.resolve().then(() => (init_function_routes(), function_routes_exports));
-    const functionRoutes = discoverFunctionRoutes2();
-    if (functionRoutes.length > 0) {
-      routeLogger2.info("Loading function routes", { count: functionRoutes.length });
-      for (const func of functionRoutes) {
-        try {
-          await loader.loadExternalRoutes(app, func.routesDir, func.packageName, func.prefix);
-          routeLogger2.info("Function routes loaded", {
-            package: func.packageName,
-            routesDir: func.routesDir,
-            prefix: func.prefix || "/"
-          });
-        } catch (error) {
-          routeLogger2.error("Failed to load function routes", {
-            package: func.packageName,
-            error: error instanceof Error ? error.message : "Unknown error"
-          });
-        }
-      }
-    }
-  }
-  return stats;
-}
-
-// src/route/bind.ts
-init_errors();
-init_logger2();
-
-// src/middleware/error-handler.ts
-init_logger2();
-var errorLogger = logger.child("error-handler");
-function ErrorHandler(options = {}) {
-  const {
-    includeStack = process.env.NODE_ENV !== "production",
-    enableLogging = true
-  } = options;
-  return (err, c) => {
-    const errorWithCode = err;
-    const statusCode = errorWithCode.statusCode || 500;
-    const errorType = err.name || "Error";
-    if (enableLogging) {
-      const logLevel = statusCode >= 500 ? "error" : "warn";
-      const logData = {
-        type: errorType,
-        message: err.message,
-        statusCode,
-        path: c.req.path,
-        method: c.req.method
-      };
-      if (errorWithCode.details) {
-        logData.details = errorWithCode.details;
-      }
-      if (statusCode >= 500 && includeStack) {
-        logData.stack = err.stack;
-      }
-      errorLogger[logLevel]("Error occurred", logData);
-    }
-    const response = {
-      success: false,
-      error: {
-        message: err.message || "Internal Server Error",
-        type: errorType,
-        statusCode
-      }
-    };
-    if (errorWithCode.details) {
-      response.error.details = errorWithCode.details;
-    }
-    if (includeStack) {
-      response.error.stack = err.stack;
-    }
-    return c.json(response, statusCode);
-  };
-}
-
-// src/middleware/request-logger.ts
-init_logger2();
-var DEFAULT_CONFIG = {
-  excludePaths: ["/health", "/ping", "/favicon.ico"],
-  sensitiveFields: ["password", "token", "apiKey", "secret", "authorization"],
-  slowRequestThreshold: 1e3
-};
-function generateRequestId() {
-  const timestamp2 = Date.now();
-  const randomPart = randomBytes(6).toString("hex");
-  return `req_${timestamp2}_${randomPart}`;
-}
-function maskSensitiveData2(obj, sensitiveFields, seen = /* @__PURE__ */ new WeakSet()) {
-  if (!obj || typeof obj !== "object") return obj;
-  if (seen.has(obj)) return "[Circular]";
-  seen.add(obj);
-  const lowerFields = sensitiveFields.map((f) => f.toLowerCase());
-  const masked = Array.isArray(obj) ? [...obj] : { ...obj };
-  for (const key in masked) {
-    const lowerKey = key.toLowerCase();
-    if (lowerFields.some((field) => lowerKey.includes(field))) {
-      masked[key] = "***MASKED***";
-    } else if (typeof masked[key] === "object" && masked[key] !== null) {
-      masked[key] = maskSensitiveData2(masked[key], sensitiveFields, seen);
-    }
-  }
-  return masked;
-}
-function RequestLogger(config) {
-  const cfg = { ...DEFAULT_CONFIG, ...config };
-  const apiLogger = logger.child("api");
-  return async (c, next) => {
-    const path = new URL(c.req.url).pathname;
-    if (cfg.excludePaths.includes(path)) {
-      return next();
-    }
-    const requestId = generateRequestId();
-    c.set("requestId", requestId);
-    const method = c.req.method;
-    const userAgent = c.req.header("user-agent");
-    const ip = c.req.header("x-forwarded-for") || c.req.header("x-real-ip") || "unknown";
-    const startTime = Date.now();
-    apiLogger.info("Request received", {
-      requestId,
-      method,
-      path,
-      ip,
-      userAgent
-    });
-    try {
-      await next();
-      const duration = Date.now() - startTime;
-      const status = c.res.status;
-      const logData = {
-        requestId,
-        method,
-        path,
-        status,
-        duration
-      };
-      const isSlowRequest = duration >= cfg.slowRequestThreshold;
-      if (isSlowRequest) {
-        logData.slow = true;
-      }
-      if (status >= 400) {
-        try {
-          const responseBody = await c.res.clone().json();
-          logData.response = responseBody;
-        } catch {
-        }
-        if (["POST", "PUT", "PATCH"].includes(method)) {
-          try {
-            const requestBody = await c.req.json();
-            logData.request = maskSensitiveData2(requestBody, cfg.sensitiveFields);
-          } catch {
-          }
-        }
-      }
-      const logLevel = status >= 500 ? "error" : status >= 400 ? "warn" : "info";
-      apiLogger[logLevel]("Request completed", logData);
-    } catch (error) {
-      const duration = Date.now() - startTime;
-      apiLogger.error("Request failed", error, {
-        requestId,
-        method,
-        path,
-        duration
-      });
-      throw error;
-    }
-  };
-}
-
-// src/route/types.ts
-function isHttpMethod(value) {
-  return typeof value === "string" && ["GET", "POST", "PUT", "PATCH", "DELETE"].includes(value);
-}
-
-// src/server/create-server.ts
-init_logger2();
-
-// src/server/helpers.ts
-function createHealthCheckHandler(detailed) {
-  return async (c) => {
-    const response = {
-      status: "ok",
-      timestamp: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    if (detailed) {
-      const { getDatabase: getDatabase2 } = await Promise.resolve().then(() => (init_db(), db_exports));
-      const { getRedis: getRedis2 } = await Promise.resolve().then(() => (init_cache(), cache_exports));
-      const db = getDatabase2();
-      let dbStatus = "disconnected";
-      let dbError;
-      if (db) {
-        try {
-          await db.execute("SELECT 1");
-          dbStatus = "connected";
-        } catch (error) {
-          dbStatus = "error";
-          dbError = error instanceof Error ? error.message : String(error);
-        }
-      }
-      const redis = getRedis2();
-      let redisStatus = "disconnected";
-      let redisError;
-      if (redis) {
-        try {
-          await redis.ping();
-          redisStatus = "connected";
-        } catch (error) {
-          redisStatus = "error";
-          redisError = error instanceof Error ? error.message : String(error);
-        }
-      }
-      response.services = {
-        database: {
-          status: dbStatus,
-          ...dbError && { error: dbError }
-        },
-        redis: {
-          status: redisStatus,
-          ...redisError && { error: redisError }
-        }
-      };
-      const hasErrors = dbStatus === "error" || redisStatus === "error";
-      response.status = hasErrors ? "degraded" : "ok";
-    }
-    const statusCode = response.status === "ok" ? 200 : 503;
-    return c.json(response, statusCode);
-  };
-}
-function applyServerTimeouts(server, timeouts) {
-  if ("timeout" in server) {
-    server.timeout = timeouts.request;
-    server.keepAliveTimeout = timeouts.keepAlive;
-    server.headersTimeout = timeouts.headers;
-  }
-}
-function getTimeoutConfig(config) {
-  return {
-    request: config?.request ?? (parseInt(process.env.SERVER_TIMEOUT || "", 10) || 12e4),
-    keepAlive: config?.keepAlive ?? (parseInt(process.env.SERVER_KEEPALIVE_TIMEOUT || "", 10) || 65e3),
-    headers: config?.headers ?? (parseInt(process.env.SERVER_HEADERS_TIMEOUT || "", 10) || 6e4)
-  };
-}
-function getShutdownTimeout(config) {
-  return config?.timeout ?? (parseInt(process.env.SHUTDOWN_TIMEOUT || "", 10) || 3e4);
-}
-function buildMiddlewareOrder(config) {
-  const order = [];
-  const middlewareConfig = config.middleware ?? {};
-  const enableLogger = middlewareConfig.logger !== false;
-  const enableCors = middlewareConfig.cors !== false;
-  const enableErrorHandler = middlewareConfig.errorHandler !== false;
-  if (enableLogger) order.push("RequestLogger");
-  if (enableCors) order.push("CORS");
-  config.use?.forEach((_, i) => order.push(`Custom[${i}]`));
-  if (config.beforeRoutes) order.push("beforeRoutes hook");
-  order.push("Routes");
-  if (config.afterRoutes) order.push("afterRoutes hook");
-  if (enableErrorHandler) order.push("ErrorHandler");
-  return order;
-}
-function buildStartupConfig(config, timeouts) {
-  const middlewareConfig = config.middleware ?? {};
-  const healthCheckConfig = config.healthCheck ?? {};
-  const healthCheckEnabled = healthCheckConfig.enabled !== false;
-  const healthCheckPath = healthCheckConfig.path ?? "/health";
-  const healthCheckDetailed = healthCheckConfig.detailed ?? process.env.NODE_ENV === "development";
-  return {
-    middleware: {
-      logger: middlewareConfig.logger !== false,
-      cors: middlewareConfig.cors !== false,
-      errorHandler: middlewareConfig.errorHandler !== false,
-      custom: config.use?.length ?? 0
-    },
-    healthCheck: healthCheckEnabled ? {
-      enabled: true,
-      path: healthCheckPath,
-      detailed: healthCheckDetailed
-    } : { enabled: false },
-    hooks: {
-      beforeRoutes: !!config.beforeRoutes,
-      afterRoutes: !!config.afterRoutes
-    },
-    timeout: {
-      request: `${timeouts.request}ms`,
-      keepAlive: `${timeouts.keepAlive}ms`,
-      headers: `${timeouts.headers}ms`
-    },
-    shutdown: {
-      timeout: `${config.shutdown?.timeout ?? 3e4}ms`
-    }
-  };
-}
-
-// src/server/plugin-discovery.ts
-init_logger2();
-var pluginLogger = logger.child("plugin");
-async function discoverPlugins(cwd = process.cwd()) {
-  const plugins = [];
-  const nodeModulesPath = join(cwd, "node_modules");
-  try {
-    const projectPkgPath = join(cwd, "package.json");
-    if (!existsSync(projectPkgPath)) {
-      pluginLogger.debug("No package.json found, skipping plugin discovery");
-      return plugins;
-    }
-    const projectPkg = JSON.parse(readFileSync(projectPkgPath, "utf-8"));
-    const dependencies = {
-      ...projectPkg.dependencies,
-      ...projectPkg.devDependencies
-    };
-    for (const [packageName] of Object.entries(dependencies)) {
-      if (!packageName.startsWith("@spfn/")) {
-        continue;
-      }
-      try {
-        const plugin = await loadPluginFromPackage(packageName, nodeModulesPath);
-        if (plugin) {
-          plugins.push(plugin);
-          pluginLogger.info("Plugin discovered", {
-            name: plugin.name,
-            hooks: getPluginHookNames(plugin)
-          });
-        }
-      } catch (error) {
-        pluginLogger.debug("Failed to load plugin", {
-          package: packageName,
-          error: error instanceof Error ? error.message : "Unknown error"
-        });
-      }
-    }
-  } catch (error) {
-    pluginLogger.warn("Plugin discovery failed", {
-      error: error instanceof Error ? error.message : "Unknown error"
-    });
-  }
-  return plugins;
-}
-async function loadPluginFromPackage(packageName, nodeModulesPath) {
-  const pkgPath = join(nodeModulesPath, ...packageName.split("/"), "package.json");
-  if (!existsSync(pkgPath)) {
-    return null;
-  }
-  const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
-  const packageDir = dirname(pkgPath);
-  const mainEntry = pkg.main || "dist/index.js";
-  const mainPath = join(packageDir, mainEntry);
-  if (!existsSync(mainPath)) {
-    return null;
-  }
-  try {
-    const module = await import(mainPath);
-    if (module.spfnPlugin && isValidPlugin(module.spfnPlugin)) {
-      return module.spfnPlugin;
-    }
-    return null;
-  } catch (error) {
-    return null;
-  }
-}
-function isValidPlugin(plugin) {
-  return plugin && typeof plugin === "object" && typeof plugin.name === "string" && (typeof plugin.afterInfrastructure === "function" || typeof plugin.beforeRoutes === "function" || typeof plugin.afterRoutes === "function" || typeof plugin.afterStart === "function" || typeof plugin.beforeShutdown === "function");
-}
-function getPluginHookNames(plugin) {
-  const hooks = [];
-  if (plugin.afterInfrastructure) hooks.push("afterInfrastructure");
-  if (plugin.beforeRoutes) hooks.push("beforeRoutes");
-  if (plugin.afterRoutes) hooks.push("afterRoutes");
-  if (plugin.afterStart) hooks.push("afterStart");
-  if (plugin.beforeShutdown) hooks.push("beforeShutdown");
-  return hooks;
-}
-async function executePluginHooks(plugins, hookName, ...args) {
-  for (const plugin of plugins) {
-    const hook = plugin[hookName];
-    if (typeof hook === "function") {
-      try {
-        pluginLogger.debug("Executing plugin hook", {
-          plugin: plugin.name,
-          hook: hookName
-        });
-        await hook(...args);
-      } catch (error) {
-        pluginLogger.error("Plugin hook failed", {
-          plugin: plugin.name,
-          hook: hookName,
-          error: error instanceof Error ? error.message : "Unknown error"
-        });
-        throw new Error(
-          `Plugin ${plugin.name} failed in ${hookName} hook: ${error instanceof Error ? error.message : "Unknown error"}`
-        );
-      }
-    }
-  }
-}
-
-// src/server/create-server.ts
-var serverLogger = logger.child("server");
-async function createServer(config, plugins = []) {
-  const cwd = process.cwd();
-  const appPath = join(cwd, "src", "server", "app.ts");
-  const appJsPath = join(cwd, "src", "server", "app.js");
-  if (existsSync(appPath) || existsSync(appJsPath)) {
-    return await loadCustomApp(appPath, appJsPath, config, plugins);
-  }
-  return await createAutoConfiguredApp(config, plugins);
-}
-async function loadCustomApp(appPath, appJsPath, config, plugins = []) {
-  const appModule = await (existsSync(appPath) ? import(appPath) : import(appJsPath));
-  const appFactory = appModule.default;
-  if (!appFactory) {
-    throw new Error("app.ts must export a default function that returns a Hono app");
-  }
-  const app = await appFactory();
-  await executePluginHooks(plugins, "beforeRoutes", app);
-  const debug = config?.debug ?? process.env.NODE_ENV === "development";
-  await loadRoutes(app, { routesDir: config?.routesPath, debug });
-  await executePluginHooks(plugins, "afterRoutes", app);
-  return app;
-}
-async function createAutoConfiguredApp(config, plugins = []) {
-  const app = new Hono();
-  const middlewareConfig = config?.middleware ?? {};
-  const enableLogger = middlewareConfig.logger !== false;
-  const enableCors = middlewareConfig.cors !== false;
-  const enableErrorHandler = middlewareConfig.errorHandler !== false;
-  if (enableErrorHandler) {
-    app.use("*", async (c, next) => {
-      c.set("errorHandlerEnabled", true);
-      await next();
-    });
-  }
-  applyDefaultMiddleware(app, config, enableLogger, enableCors);
-  config?.use?.forEach((mw) => app.use("*", mw));
-  registerHealthCheckEndpoint(app, config);
-  await executeBeforeRoutesHook(app, config);
-  await executePluginHooks(plugins, "beforeRoutes", app);
-  await loadAppRoutes(app, config);
-  await executeAfterRoutesHook(app, config);
-  await executePluginHooks(plugins, "afterRoutes", app);
-  if (enableErrorHandler) {
-    app.onError(ErrorHandler());
-  }
-  return app;
-}
-function applyDefaultMiddleware(app, config, enableLogger, enableCors) {
-  if (enableLogger) {
-    app.use("*", RequestLogger());
-  }
-  if (enableCors && config?.cors !== false) {
-    app.use("*", cors(config?.cors));
-  }
-}
-function registerHealthCheckEndpoint(app, config) {
-  const healthCheckConfig = config?.healthCheck ?? {};
-  const healthCheckEnabled = healthCheckConfig.enabled !== false;
-  const healthCheckPath = healthCheckConfig.path ?? "/health";
-  const healthCheckDetailed = healthCheckConfig.detailed ?? process.env.NODE_ENV === "development";
-  if (healthCheckEnabled) {
-    app.get(healthCheckPath, createHealthCheckHandler(healthCheckDetailed));
-    serverLogger.debug(`Health check endpoint enabled at ${healthCheckPath}`);
-  }
-}
-async function executeBeforeRoutesHook(app, config) {
-  if (!config?.lifecycle?.beforeRoutes) {
-    return;
-  }
-  try {
-    await config.lifecycle.beforeRoutes(app);
-  } catch (error) {
-    serverLogger.error("beforeRoutes hook failed", error);
-    throw new Error("Server initialization failed in beforeRoutes hook");
-  }
-}
-async function loadAppRoutes(app, config) {
-  const debug = config?.debug ?? process.env.NODE_ENV === "development";
-  await loadRoutes(app, {
-    routesDir: config?.routesPath,
-    debug,
-    middlewares: config?.middlewares
-  });
-}
-async function executeAfterRoutesHook(app, config) {
-  if (!config?.lifecycle?.afterRoutes) {
-    return;
-  }
-  try {
-    await config.lifecycle.afterRoutes(app);
-  } catch (error) {
-    serverLogger.error("afterRoutes hook failed", error);
-    throw new Error("Server initialization failed in afterRoutes hook");
-  }
-}
-
-// src/server/start-server.ts
-init_cache();
-init_db();
-init_logger2();
-function getNetworkAddress() {
-  const nets = networkInterfaces();
-  for (const name of Object.keys(nets)) {
-    const netGroup = nets[name];
-    if (!netGroup) continue;
-    for (const net of netGroup) {
-      if (net.family === "IPv4" && !net.internal) {
-        return net.address;
-      }
-    }
-  }
-  return null;
-}
-function printBanner(options) {
-  const { mode, host, port } = options;
-  console.log("");
-  console.log("      _____ ____  ______ _   _");
-  console.log("     / ____|  _ \\|  ____| \\ | |");
-  console.log("    | (___ | |_) | |__  |  \\| |");
-  console.log("     \\___ \\|  __/|  __| | . ` |");
-  console.log("     ____) | |   | |    | |\\  |");
-  console.log("    |_____/|_|   |_|    |_| \\_|");
-  console.log("");
-  console.log(`    Mode: ${mode}`);
-  if (host === "0.0.0.0") {
-    const networkIP = getNetworkAddress();
-    console.log(`   \u25B2 Local:        http://localhost:${port}`);
-    if (networkIP) {
-      console.log(`   \u25B2 Network:      http://${networkIP}:${port}`);
-    }
-  } else {
-    console.log(`   \u25B2 Local:        http://${host}:${port}`);
-  }
-  console.log("");
-}
-
-// src/server/validation.ts
-function validateServerConfig(config) {
-  if (config.port !== void 0) {
-    if (!Number.isInteger(config.port) || config.port < 0 || config.port > 65535) {
-      throw new Error(
-        `Invalid port: ${config.port}. Port must be an integer between 0 and 65535.`
-      );
-    }
-  }
-  if (config.timeout) {
-    const { request, keepAlive, headers } = config.timeout;
-    if (request !== void 0 && (request < 0 || !Number.isFinite(request))) {
-      throw new Error(`Invalid timeout.request: ${request}. Must be a positive number.`);
-    }
-    if (keepAlive !== void 0 && (keepAlive < 0 || !Number.isFinite(keepAlive))) {
-      throw new Error(`Invalid timeout.keepAlive: ${keepAlive}. Must be a positive number.`);
-    }
-    if (headers !== void 0 && (headers < 0 || !Number.isFinite(headers))) {
-      throw new Error(`Invalid timeout.headers: ${headers}. Must be a positive number.`);
-    }
-    if (headers && request && headers > request) {
-      throw new Error(
-        `Invalid timeout configuration: headers timeout (${headers}ms) cannot exceed request timeout (${request}ms).`
-      );
-    }
-  }
-  if (config.shutdown?.timeout !== void 0) {
-    const timeout = config.shutdown.timeout;
-    if (timeout < 0 || !Number.isFinite(timeout)) {
-      throw new Error(`Invalid shutdown.timeout: ${timeout}. Must be a positive number.`);
-    }
-  }
-  if (config.healthCheck?.path) {
-    if (!config.healthCheck.path.startsWith("/")) {
-      throw new Error(
-        `Invalid healthCheck.path: "${config.healthCheck.path}". Must start with "/".`
-      );
-    }
-  }
-}
-
-// src/server/start-server.ts
-var serverLogger2 = logger.child("server");
-async function startServer(config) {
-  const finalConfig = await loadAndMergeConfig(config);
-  const { host, port, debug } = finalConfig;
-  validateServerConfig(finalConfig);
-  if (debug) {
-    logMiddlewareOrder(finalConfig);
-  }
-  serverLogger2.debug("Discovering plugins...");
-  const plugins = await discoverPlugins();
-  if (plugins.length > 0) {
-    serverLogger2.info("Plugins discovered", {
-      count: plugins.length,
-      plugins: plugins.map((p) => p.name)
-    });
-  }
-  try {
-    await initializeInfrastructure(finalConfig, plugins);
-    const app = await createServer(finalConfig, plugins);
-    const server = startHttpServer(app, host, port);
-    const timeouts = getTimeoutConfig(finalConfig.timeout);
-    applyServerTimeouts(server, timeouts);
-    logServerTimeouts(timeouts);
-    printBanner({
-      mode: debug ? "Development" : "Production",
-      host,
-      port
-    });
-    logServerStarted(debug, host, port, finalConfig, timeouts);
-    const shutdownServer = createShutdownHandler(server, finalConfig, plugins);
-    const shutdown = createGracefulShutdown(shutdownServer, finalConfig);
-    registerShutdownHandlers(shutdown);
-    const serverInstance = {
-      server,
-      app,
-      config: finalConfig,
-      close: async () => {
-        serverLogger2.info("Manual server shutdown requested");
-        await shutdownServer();
-      }
-    };
-    if (finalConfig.lifecycle?.afterStart) {
-      serverLogger2.debug("Executing afterStart hook...");
-      try {
-        await finalConfig.lifecycle.afterStart(serverInstance);
-      } catch (error) {
-        serverLogger2.error("afterStart hook failed", error);
-      }
-    }
-    await executePluginHooks(plugins, "afterStart", serverInstance);
-    return serverInstance;
-  } catch (error) {
-    const err = error;
-    serverLogger2.error("Server initialization failed", err);
-    await cleanupOnFailure(finalConfig);
-    throw error;
-  }
-}
-async function loadAndMergeConfig(config) {
-  const cwd = process.cwd();
-  const configPath = join(cwd, "src", "server", "server.config.ts");
-  const configJsPath = join(cwd, "src", "server", "server.config.js");
-  const builtConfigMjsPath = join(cwd, ".spfn", "server", "server.config.mjs");
-  const builtConfigPath = join(cwd, ".spfn", "server", "server.config.js");
-  let fileConfig = {};
-  if (existsSync(builtConfigMjsPath)) {
-    const configModule = await import(builtConfigMjsPath);
-    fileConfig = configModule.default ?? {};
-  } else if (existsSync(builtConfigPath)) {
-    const configModule = await import(builtConfigPath);
-    fileConfig = configModule.default ?? {};
-  } else if (existsSync(configJsPath)) {
-    const configModule = await import(configJsPath);
-    fileConfig = configModule.default ?? {};
-  } else if (existsSync(configPath)) {
-    const configModule = await import(configPath);
-    fileConfig = configModule.default ?? {};
-  }
-  return {
-    ...fileConfig,
-    ...config,
-    port: config?.port ?? fileConfig?.port ?? (parseInt(process.env.PORT || "", 10) || 4e3),
-    host: config?.host ?? fileConfig?.host ?? (process.env.HOST || "localhost")
-  };
-}
-function logMiddlewareOrder(config) {
-  const middlewareOrder = buildMiddlewareOrder(config);
-  serverLogger2.debug("Middleware execution order", {
-    order: middlewareOrder
-  });
-}
-async function initializeInfrastructure(config, plugins) {
-  if (config.lifecycle?.beforeInfrastructure) {
-    serverLogger2.debug("Executing beforeInfrastructure hook...");
-    try {
-      await config.lifecycle.beforeInfrastructure(config);
-    } catch (error) {
-      serverLogger2.error("beforeInfrastructure hook failed", error);
-      throw new Error("Server initialization failed in beforeInfrastructure hook");
-    }
-  }
-  const shouldInitDatabase = config.infrastructure?.database !== false;
-  if (shouldInitDatabase) {
-    serverLogger2.debug("Initializing database...");
-    await initDatabase(config.database);
-  } else {
-    serverLogger2.debug("Database initialization disabled");
-  }
-  const shouldInitRedis = config.infrastructure?.redis !== false;
-  if (shouldInitRedis) {
-    serverLogger2.debug("Initializing Redis...");
-    await initRedis();
-  } else {
-    serverLogger2.debug("Redis initialization disabled");
-  }
-  if (config.lifecycle?.afterInfrastructure) {
-    serverLogger2.debug("Executing afterInfrastructure hook...");
-    try {
-      await config.lifecycle.afterInfrastructure();
-    } catch (error) {
-      serverLogger2.error("afterInfrastructure hook failed", error);
-      throw new Error("Server initialization failed in afterInfrastructure hook");
-    }
-  }
-  await executePluginHooks(plugins, "afterInfrastructure");
-}
-function startHttpServer(app, host, port) {
-  serverLogger2.debug(`Starting server on ${host}:${port}...`);
-  const server = serve({
-    fetch: app.fetch,
-    port,
-    hostname: host
-  });
-  return server;
-}
-function logServerTimeouts(timeouts) {
-  serverLogger2.info("Server timeouts configured", {
-    request: `${timeouts.request}ms`,
-    keepAlive: `${timeouts.keepAlive}ms`,
-    headers: `${timeouts.headers}ms`
-  });
-}
-function logServerStarted(debug, host, port, config, timeouts) {
-  const startupConfig = buildStartupConfig(config, timeouts);
-  serverLogger2.info("Server started successfully", {
-    mode: debug ? "development" : "production",
-    host,
-    port,
-    config: startupConfig
-  });
-}
-function createShutdownHandler(server, config, plugins) {
-  return async () => {
-    serverLogger2.debug("Closing HTTP server...");
-    await new Promise((resolve) => {
-      server.close(() => {
-        serverLogger2.info("HTTP server closed");
-        resolve();
-      });
-    });
-    if (config.lifecycle?.beforeShutdown) {
-      serverLogger2.debug("Executing beforeShutdown hook...");
-      try {
-        await config.lifecycle.beforeShutdown();
-      } catch (error) {
-        serverLogger2.error("beforeShutdown hook failed", error);
-      }
-    }
-    try {
-      await executePluginHooks(plugins, "beforeShutdown");
-    } catch (error) {
-      serverLogger2.error("Plugin beforeShutdown hooks failed", error);
-    }
-    const shouldCloseDatabase = config.infrastructure?.database !== false;
-    const shouldCloseRedis = config.infrastructure?.redis !== false;
-    if (shouldCloseDatabase) {
-      serverLogger2.debug("Closing database connections...");
-      await closeDatabase();
-    }
-    if (shouldCloseRedis) {
-      serverLogger2.debug("Closing Redis connections...");
-      await closeRedis();
-    }
-    serverLogger2.info("Server shutdown completed");
-  };
-}
-function createGracefulShutdown(shutdownServer, config) {
-  return async (signal) => {
-    serverLogger2.info(`${signal} received, starting graceful shutdown...`);
-    const shutdownTimeout = getShutdownTimeout(config.shutdown);
-    const timeoutPromise = new Promise((_, reject) => {
-      setTimeout(() => {
-        reject(new Error(`Graceful shutdown timeout after ${shutdownTimeout}ms`));
-      }, shutdownTimeout);
-    });
-    try {
-      await Promise.race([
-        shutdownServer(),
-        timeoutPromise
-      ]);
-      serverLogger2.info("Graceful shutdown completed successfully");
-      process.exit(0);
-    } catch (error) {
-      const err = error;
-      if (err.message && err.message.includes("timeout")) {
-        serverLogger2.error("Graceful shutdown timeout, forcing exit", err);
-      } else {
-        serverLogger2.error("Error during graceful shutdown", err);
-      }
-      process.exit(1);
-    }
-  };
-}
-function registerShutdownHandlers(shutdown) {
-  process.setMaxListeners(15);
-  process.on("SIGTERM", () => shutdown("SIGTERM"));
-  process.on("SIGINT", () => shutdown("SIGINT"));
-  process.on("uncaughtException", (error) => {
-    if (error.message?.includes("EADDRINUSE")) {
-      serverLogger2.error("Port conflict detected - detailed trace:", {
-        error: error.message,
-        stack: error.stack,
-        code: error.code,
-        port: error.port,
-        address: error.address,
-        syscall: error.syscall
-      });
-    } else {
-      serverLogger2.error("Uncaught exception", error);
-    }
-    serverLogger2.info("Exiting immediately for clean restart");
-    process.exit(1);
-  });
-  process.on("unhandledRejection", (reason, promise) => {
-    serverLogger2.error("Unhandled promise rejection", {
-      reason,
-      promise
-    });
-    serverLogger2.info("Exiting immediately for clean restart");
-    process.exit(1);
-  });
-}
-async function cleanupOnFailure(config) {
-  try {
-    serverLogger2.debug("Cleaning up after initialization failure...");
-    const shouldCleanupDatabase = config.infrastructure?.database !== false;
-    const shouldCleanupRedis = config.infrastructure?.redis !== false;
-    if (shouldCleanupDatabase) {
-      await closeDatabase();
-    }
-    if (shouldCleanupRedis) {
-      await closeRedis();
-    }
-    serverLogger2.debug("Cleanup completed");
-  } catch (cleanupError) {
-    serverLogger2.error("Cleanup failed", cleanupError);
-  }
-}
-
-export { createServer, isHttpMethod, startServer };
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map