@spfn/core 0.1.0-alpha.8 → 0.1.0-alpha.81

package/dist/server/index.js

@@ -1,18 +1,19 @@
 import pino from 'pino';
-import { existsSync, mkdirSync, createWriteStream } from 'fs';
-import { join, relative } from 'path';
-import postgres from 'postgres';
+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 { and, desc, asc, sql, isNull, isNotNull, notInArray, inArray, like, lte, lt, gte, gt, ne, eq } from 'drizzle-orm';
-import { timestamp, bigserial } from 'drizzle-orm/pg-core';
+import { eq, and } from 'drizzle-orm';
 import { Hono } from 'hono';
-import { serve } from '@hono/node-server';
 import { cors } from 'hono/cors';
 import { readdir, stat } from 'fs/promises';
-import { randomBytes } from 'crypto';
+import { serve } from '@hono/node-server';
+import { networkInterfaces } from 'os';
 
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
@@ -23,117 +24,16 @@ var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
-
-// src/errors/database-errors.ts
-var DatabaseError, ConnectionError, QueryError, ValidationError, 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";
-      }
-    };
-    ValidationError = class extends QueryError {
-      constructor(message, details) {
-        super(message, 400, details);
-        this.name = "ValidationError";
-      }
-    };
-    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";
-      }
-    };
-  }
-});
 var PinoAdapter;
 var init_pino = __esm({
   "src/logger/adapters/pino.ts"() {
     PinoAdapter = class _PinoAdapter {
       logger;
-      constructor(config2) {
-        const isProduction = process.env.NODE_ENV === "production";
-        const isDevelopment = process.env.NODE_ENV === "development";
-        const fileLoggingEnabled = process.env.LOGGER_FILE_ENABLED === "true";
-        const targets = [];
-        if (!isProduction && isDevelopment) {
-          targets.push({
-            target: "pino-pretty",
-            level: "debug",
-            options: {
-              colorize: true,
-              translateTime: "SYS:yyyy-mm-dd HH:MM:ss.l",
-              ignore: "pid,hostname"
-            }
-          });
-        }
-        if (fileLoggingEnabled && isProduction) {
-          const logDir = process.env.LOG_DIR || "./logs";
-          const maxFileSize = process.env.LOG_MAX_FILE_SIZE || "10M";
-          const maxFiles = parseInt(process.env.LOG_MAX_FILES || "10", 10);
-          targets.push({
-            target: "pino-roll",
-            level: "info",
-            options: {
-              file: `${logDir}/app.log`,
-              frequency: "daily",
-              size: maxFileSize,
-              limit: { count: maxFiles },
-              mkdir: true
-            }
-          });
-        }
+      constructor(config) {
         this.logger = pino({
-          level: config2.level,
-          // Transport 설정 (targets가 있으면 사용, 없으면 기본 stdout)
-          transport: targets.length > 0 ? { targets } : void 0,
+          level: config.level,
           // 기본 필드
-          base: config2.module ? { module: config2.module } : void 0
+          base: config.module ? { module: config.module } : void 0
         });
       }
       child(module) {
@@ -174,16 +74,198 @@ var init_pino = __esm({
   }
 });
 
+// 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]) => {
+      const valueStr = typeof value === "string" ? value : 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(config2) {
-        this.config = config2;
-        this.module = config2.module;
+      constructor(config) {
+        this.config = config;
+        this.module = config.module;
       }
       /**
        * Get current log level
@@ -237,13 +319,17 @@ var init_logger = __esm({
        * 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,
-          context
+          // Mask sensitive information in context to prevent credential leaks
+          context: context ? maskSensitiveData(context) : void 0
         };
         this.processTransports(metadata);
       }
@@ -281,160 +367,36 @@ var init_logger = __esm({
   }
 });
 
-// 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 colorizeLevel(level) {
-  const color = COLORS[level];
-  const levelStr = level.toUpperCase().padEnd(5);
-  return `${color}${levelStr}${COLORS.reset}`;
-}
-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 formatContext(context) {
-  try {
-    return JSON.stringify(context, null, 2);
-  } catch (error) {
-    return "[Context serialization failed]";
-  }
-}
-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 (colorize) {
-    parts.push(colorizeLevel(metadata.level));
-  } else {
-    parts.push(metadata.level.toUpperCase().padEnd(5));
-  }
-  if (metadata.module) {
-    if (colorize) {
-      parts.push(`${COLORS.dim}[${metadata.module}]${COLORS.reset}`);
-    } else {
-      parts.push(`[${metadata.module}]`);
-    }
-  }
-  parts.push(metadata.message);
-  let output = parts.join(" ");
-  if (metadata.context && Object.keys(metadata.context).length > 0) {
-    output += "\n" + formatContext(metadata.context);
-  }
-  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 COLORS;
-var init_formatters = __esm({
-  "src/logger/formatters.ts"() {
-    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/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(config2) {
-        this.level = config2.level;
-        this.enabled = config2.enabled;
-        this.colorize = config2.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);
-        }
-      }
+// 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);
+        }
+      }
     };
   }
 });
@@ -448,12 +410,16 @@ var init_file = __esm({
       level;
       enabled;
       logDir;
+      maxFileSize;
+      maxFiles;
       currentStream = null;
       currentFilename = null;
-      constructor(config2) {
-        this.level = config2.level;
-        this.enabled = config2.enabled;
-        this.logDir = config2.logDir;
+      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 });
         }
@@ -469,6 +435,9 @@ var init_file = __esm({
         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) => {
@@ -524,6 +493,103 @@ var init_file = __esm({
           });
         });
       }
+      /**
+       * 파일 크기 체크 및 크기 기반 로테이션
+       */
+      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}
+`);
+        }
+      }
       /**
        * 날짜별 로그 파일명 생성
        */
@@ -539,8 +605,9 @@ var init_file = __esm({
     };
   }
 });
-
-// src/logger/config.ts
+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";
@@ -573,6 +640,109 @@ function getFileConfig() {
     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"() {
   }
@@ -598,10 +768,10 @@ var init_custom = __esm({
     init_config();
     CustomAdapter = class _CustomAdapter {
       logger;
-      constructor(config2) {
+      constructor(config) {
         this.logger = new Logger({
-          level: config2.level,
-          module: config2.module,
+          level: config.level,
+          module: config.module,
           transports: initializeTransports()
         });
       }
@@ -663,13 +833,17 @@ function getAdapterType() {
   }
   return "pino";
 }
+function initializeLogger() {
+  validateConfig();
+  return createAdapter(getAdapterType());
+}
 var logger;
 var init_adapter_factory = __esm({
   "src/logger/adapter-factory.ts"() {
     init_pino();
     init_custom();
     init_config();
-    logger = createAdapter(getAdapterType());
+    logger = initializeLogger();
   }
 });
 
@@ -680,192 +854,129 @@ var init_logger2 = __esm({
   }
 });
 
-// src/cache/redis-factory.ts
-function hasRedisConfig() {
-  return !!(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 createClient(RedisClient, url) {
-  const options = {};
-  if (url.startsWith("rediss://")) {
-    options.tls = {
-      rejectUnauthorized: process.env.REDIS_TLS_REJECT_UNAUTHORIZED !== "false"
-    };
-  }
-  return new RedisClient(url, options);
-}
-async function createRedisFromEnv() {
-  if (!hasRedisConfig()) {
-    return { write: void 0, read: void 0 };
-  }
+// 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 ioredis = await import('ioredis');
-    const RedisClient = ioredis.default;
-    if (process.env.REDIS_URL && !process.env.REDIS_WRITE_URL && !process.env.REDIS_READ_URL && !process.env.REDIS_CLUSTER_NODES) {
-      const client = createClient(RedisClient, process.env.REDIS_URL);
-      return { write: client, read: client };
-    }
-    if (process.env.REDIS_WRITE_URL && process.env.REDIS_READ_URL) {
-      const write = createClient(RedisClient, process.env.REDIS_WRITE_URL);
-      const read = createClient(RedisClient, process.env.REDIS_READ_URL);
-      return { write, read };
-    }
-    if (process.env.REDIS_SENTINEL_HOSTS && process.env.REDIS_MASTER_NAME) {
-      const sentinels = process.env.REDIS_SENTINEL_HOSTS.split(",").map((host) => {
-        const [hostname, port] = host.trim().split(":");
-        return { host: hostname, port: Number(port) || 26379 };
-      });
-      const options = {
-        sentinels,
-        name: process.env.REDIS_MASTER_NAME,
-        password: process.env.REDIS_PASSWORD
-      };
-      const client = new RedisClient(options);
-      return { write: client, read: client };
-    }
-    if (process.env.REDIS_CLUSTER_NODES) {
-      const nodes = process.env.REDIS_CLUSTER_NODES.split(",").map((node) => {
-        const [host, port] = node.trim().split(":");
-        return { host, port: Number(port) || 6379 };
-      });
-      const clusterOptions = {
-        redisOptions: {
-          password: process.env.REDIS_PASSWORD
+    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)"
+          });
         }
-      };
-      const cluster = new RedisClient.Cluster(nodes, clusterOptions);
-      return { write: cluster, read: cluster };
-    }
-    if (process.env.REDIS_URL) {
-      const client = createClient(RedisClient, process.env.REDIS_URL);
-      return { write: client, read: client };
+      } catch (error) {
+      }
     }
-    return { write: void 0, read: void 0 };
   } catch (error) {
-    if (error instanceof Error) {
-      cacheLogger.warn(
-        "Failed to create Redis client",
-        error,
-        { suggestion: "Using memory-only cache. Install ioredis: npm install ioredis" }
-      );
-    } else {
-      cacheLogger.warn(
-        "Failed to create Redis client",
-        { error: String(error), suggestion: "Using memory-only cache. Install ioredis: npm install ioredis" }
-      );
-    }
-    return { write: void 0, read: void 0 };
+    routeLogger.warn("Failed to discover function routes", {
+      error: error instanceof Error ? error.message : "Unknown error"
+    });
   }
+  return functions;
 }
-async function createSingleRedisFromEnv() {
-  const { write } = await createRedisFromEnv();
-  return write;
-}
-var cacheLogger;
-var init_redis_factory = __esm({
-  "src/cache/redis-factory.ts"() {
+var routeLogger;
+var init_function_routes = __esm({
+  "src/route/function-routes.ts"() {
     init_logger2();
-    cacheLogger = logger.child("cache");
+    routeLogger = logger.child("function-routes");
   }
 });
 
-// src/cache/redis-manager.ts
-function getRedis() {
-  return writeInstance;
-}
-function getRedisRead() {
-  return readInstance ?? writeInstance;
-}
-function setRedis(write, read) {
-  writeInstance = write;
-  readInstance = read ?? write;
-}
-async function initRedis() {
-  if (writeInstance) {
-    return { write: writeInstance, read: readInstance };
-  }
-  const { write, read } = await createRedisFromEnv();
-  if (write) {
-    try {
-      await write.ping();
-      if (read && read !== write) {
-        await read.ping();
+// 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);
       }
-      writeInstance = write;
-      readInstance = read;
-      const hasReplica = read && read !== write;
-      cacheLogger2.info(
-        hasReplica ? "Redis connected (Master-Replica)" : "Redis connected"
-      );
-    } catch (error) {
-      cacheLogger2.error(
-        "Redis connection failed",
-        error instanceof Error ? error : new Error(String(error))
-      );
-      try {
-        await write.quit();
-        if (read && read !== write) {
-          await read.quit();
-        }
-      } catch {
+      /**
+       * Serialize error for API response
+       */
+      toJSON() {
+        return {
+          name: this.name,
+          message: this.message,
+          statusCode: this.statusCode,
+          details: this.details,
+          timestamp: this.timestamp.toISOString()
+        };
       }
-      return { write: void 0, read: void 0 };
-    }
-  }
-  return { write: writeInstance, read: readInstance };
-}
-async function closeRedis() {
-  const closePromises = [];
-  if (writeInstance) {
-    closePromises.push(
-      writeInstance.quit().catch((err) => {
-        cacheLogger2.error("Error closing Redis write instance", err);
-      })
-    );
-  }
-  if (readInstance && readInstance !== writeInstance) {
-    closePromises.push(
-      readInstance.quit().catch((err) => {
-        cacheLogger2.error("Error closing Redis read instance", err);
-      })
-    );
-  }
-  await Promise.all(closePromises);
-  writeInstance = void 0;
-  readInstance = void 0;
-  cacheLogger2.info("Redis connections closed");
-}
-function getRedisInfo() {
-  return {
-    hasWrite: !!writeInstance,
-    hasRead: !!readInstance,
-    isReplica: !!(readInstance && readInstance !== writeInstance)
-  };
-}
-var cacheLogger2, writeInstance, readInstance;
-var init_redis_manager = __esm({
-  "src/cache/redis-manager.ts"() {
-    init_redis_factory();
-    init_logger2();
-    cacheLogger2 = logger.child("cache");
-  }
-});
-
-// src/cache/index.ts
-var cache_exports = {};
-__export(cache_exports, {
-  closeRedis: () => closeRedis,
-  createRedisFromEnv: () => createRedisFromEnv,
-  createSingleRedisFromEnv: () => createSingleRedisFromEnv,
-  getRedis: () => getRedis,
-  getRedisInfo: () => getRedisInfo,
-  getRedisRead: () => getRedisRead,
-  initRedis: () => initRedis,
-  setRedis: () => setRedis
-});
-var init_cache = __esm({
-  "src/cache/index.ts"() {
-    init_redis_factory();
-    init_redis_manager();
+    };
+    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";
+      }
+    };
   }
 });
 
@@ -892,6 +1003,224 @@ var init_errors = __esm({
   }
 });
 
+// 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 = [
@@ -935,11 +1264,11 @@ function fromPostgresError(error) {
     case "23000":
     // integrity_constraint_violation
     case "23001":
-      return new ValidationError(message, { code, constraint: "integrity" });
+      return new ConstraintViolationError(message, { code, constraint: "integrity" });
     case "23502":
-      return new ValidationError(message, { code, constraint: "not_null" });
+      return new ConstraintViolationError(message, { code, constraint: "not_null" });
     case "23503":
-      return new ValidationError(message, { code, constraint: "foreign_key" });
+      return new ConstraintViolationError(message, { code, constraint: "foreign_key" });
     case "23505":
       const parsed = parseUniqueViolation(message);
       if (parsed) {
@@ -947,7 +1276,7 @@ function fromPostgresError(error) {
       }
       return new DuplicateEntryError("field", "value");
     case "23514":
-      return new ValidationError(message, { code, constraint: "check" });
+      return new ConstraintViolationError(message, { code, constraint: "check" });
     // Class 40 — Transaction Rollback
     case "40000":
     // transaction_rollback
@@ -1009,7 +1338,7 @@ function fromPostgresError(error) {
 }
 var init_postgres_errors = __esm({
   "src/db/postgres-errors.ts"() {
-    init_database_errors();
+    init_errors();
   }
 });
 function delay(ms) {
@@ -1073,107 +1402,161 @@ var init_connection = __esm({
 });
 
 // src/db/manager/config.ts
-function getPoolConfig(options) {
+function parseEnvNumber(key, prodDefault, devDefault) {
   const isProduction = process.env.NODE_ENV === "production";
-  const max = options?.max ?? (parseInt(process.env.DB_POOL_MAX || "", 10) || (isProduction ? 20 : 10));
-  const idleTimeout = options?.idleTimeout ?? (parseInt(process.env.DB_POOL_IDLE_TIMEOUT || "", 10) || (isProduction ? 30 : 20));
-  return { max, idleTimeout };
+  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() {
-  const isProduction = process.env.NODE_ENV === "production";
   return {
-    maxRetries: isProduction ? 5 : 3,
-    // 프로덕션: 5회, 개발: 3회
-    initialDelay: 1e3,
-    // 1초
-    maxDelay: 16e3,
-    // 16초
-    factor: 2
-    // 2배씩 증가 (1s → 2s → 4s → 8s → 16s)
+    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)
   };
 }
-var init_config2 = __esm({
+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()) {
-    config({ path: ".env.local" });
+    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();
-    if (process.env.DATABASE_WRITE_URL && process.env.DATABASE_READ_URL) {
-      const writeClient2 = await createDatabaseConnection(
-        process.env.DATABASE_WRITE_URL,
-        poolConfig,
-        retryConfig
-      );
-      const readClient2 = await createDatabaseConnection(
-        process.env.DATABASE_READ_URL,
-        poolConfig,
-        retryConfig
-      );
-      return {
-        write: drizzle(writeClient2),
-        read: drizzle(readClient2),
-        writeClient: writeClient2,
-        readClient: readClient2
-      };
-    }
-    if (process.env.DATABASE_URL && process.env.DATABASE_REPLICA_URL) {
-      const writeClient2 = await createDatabaseConnection(
-        process.env.DATABASE_URL,
-        poolConfig,
-        retryConfig
-      );
-      const readClient2 = await createDatabaseConnection(
-        process.env.DATABASE_REPLICA_URL,
-        poolConfig,
-        retryConfig
-      );
-      return {
-        write: drizzle(writeClient2),
-        read: drizzle(readClient2),
-        writeClient: writeClient2,
-        readClient: readClient2
-      };
-    }
-    if (process.env.DATABASE_URL) {
-      const client = await createDatabaseConnection(
-        process.env.DATABASE_URL,
-        poolConfig,
-        retryConfig
-      );
-      const db2 = drizzle(client);
-      return {
-        write: db2,
-        read: db2,
-        writeClient: client,
-        readClient: client
-      };
-    }
-    if (process.env.DATABASE_WRITE_URL) {
-      const client = await createDatabaseConnection(
-        process.env.DATABASE_WRITE_URL,
-        poolConfig,
-        retryConfig
-      );
-      const db2 = drizzle(client);
-      return {
-        write: db2,
-        read: db2,
-        writeClient: client,
-        readClient: client
-      };
+    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 };
     }
-    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", {
@@ -1184,59 +1567,151 @@ async function createDatabaseFromEnv(options) {
       hasUrl: !!process.env.DATABASE_URL,
       hasReplicaUrl: !!process.env.DATABASE_REPLICA_URL
     });
-    return { write: void 0, read: void 0 };
+    throw new Error(`Database connection failed: ${message}`, { cause: error });
   }
 }
 var dbLogger2;
 var init_factory = __esm({
   "src/db/manager/factory.ts"() {
-    init_connection();
-    init_config2();
     init_logger2();
+    init_env();
+    init_connection();
+    init_config3();
     dbLogger2 = logger.child("database");
   }
 });
 
-// src/db/manager/manager.ts
+// 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_factory();
+    init_global_state();
+    dbLogger3 = logger.child("database");
+  }
+});
+
+// src/db/manager/manager.ts
 function getDatabase(type) {
+  const writeInst = getWriteInstance();
+  const readInst = getReadInstance();
+  dbLogger4.debug(`getDatabase() called with type=${type}, writeInstance=${!!writeInst}, readInstance=${!!readInst}`);
   if (type === "read") {
-    return readInstance2 ?? writeInstance2;
+    return readInst ?? writeInst;
   }
-  return writeInstance2;
+  return writeInst;
 }
 function setDatabase(write, read) {
-  writeInstance2 = write;
-  readInstance2 = read ?? write;
-}
-function getHealthCheckConfig(options) {
-  const parseBoolean = (value, defaultValue) => {
-    if (value === void 0) return defaultValue;
-    return value.toLowerCase() === "true";
-  };
-  return {
-    enabled: options?.enabled ?? parseBoolean(process.env.DB_HEALTH_CHECK_ENABLED, true),
-    interval: options?.interval ?? (parseInt(process.env.DB_HEALTH_CHECK_INTERVAL || "", 10) || 6e4),
-    reconnect: options?.reconnect ?? parseBoolean(process.env.DB_HEALTH_CHECK_RECONNECT, true),
-    maxRetries: options?.maxRetries ?? (parseInt(process.env.DB_HEALTH_CHECK_MAX_RETRIES || "", 10) || 3),
-    retryInterval: options?.retryInterval ?? (parseInt(process.env.DB_HEALTH_CHECK_RETRY_INTERVAL || "", 10) || 5e3)
-  };
-}
-function getMonitoringConfig(options) {
-  const isDevelopment = process.env.NODE_ENV !== "production";
-  const parseBoolean = (value, defaultValue) => {
-    if (value === void 0) return defaultValue;
-    return value.toLowerCase() === "true";
-  };
-  return {
-    enabled: options?.enabled ?? parseBoolean(process.env.DB_MONITORING_ENABLED, isDevelopment),
-    slowThreshold: options?.slowThreshold ?? (parseInt(process.env.DB_MONITORING_SLOW_THRESHOLD || "", 10) || 1e3),
-    logQueries: options?.logQueries ?? parseBoolean(process.env.DB_MONITORING_LOG_QUERIES, false)
-  };
+  setWriteInstance(write);
+  setReadInstance(read ?? write);
 }
 async function initDatabase(options) {
-  if (writeInstance2) {
-    dbLogger3.debug("Database already initialized");
-    return { write: writeInstance2, read: readInstance2 };
+  const writeInst = getWriteInstance();
+  if (writeInst) {
+    dbLogger4.debug("Database already initialized");
+    return { write: writeInst, read: getReadInstance() };
   }
   const result = await createDatabaseFromEnv(options);
   if (result.write) {
@@ -1245,195 +1720,372 @@ async function initDatabase(options) {
       if (result.read && result.read !== result.write) {
         await result.read.execute("SELECT 1");
       }
-      writeInstance2 = result.write;
-      readInstance2 = result.read;
-      writeClient = result.writeClient;
-      readClient = result.readClient;
+      setWriteInstance(result.write);
+      setReadInstance(result.read);
+      setWriteClient(result.writeClient);
+      setReadClient(result.readClient);
       const hasReplica = result.read && result.read !== result.write;
-      dbLogger3.info(
+      dbLogger4.info(
         hasReplica ? "Database connected (Primary + Replica)" : "Database connected"
       );
-      const healthCheckConfig = getHealthCheckConfig(options?.healthCheck);
+      const healthCheckConfig = buildHealthCheckConfig(options?.healthCheck);
       if (healthCheckConfig.enabled) {
-        startHealthCheck(healthCheckConfig);
-      }
-      monitoringConfig = getMonitoringConfig(options?.monitoring);
-      if (monitoringConfig.enabled) {
-        dbLogger3.info("Database query monitoring enabled", {
-          slowThreshold: `${monitoringConfig.slowThreshold}ms`,
-          logQueries: monitoringConfig.logQueries
+        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";
-      dbLogger3.error("Database connection failed", { error: message });
+      dbLogger4.error("Database connection failed", { error: message });
       await closeDatabase();
-      return { write: void 0, read: void 0 };
+      throw new Error(`Database connection test failed: ${message}`, { cause: error });
     }
   } else {
-    dbLogger3.warn("No database configuration found");
-    dbLogger3.warn("Set DATABASE_URL environment variable to enable database");
+    dbLogger4.warn("No database configuration found");
+    dbLogger4.warn("Set DATABASE_URL environment variable to enable database");
   }
-  return { write: writeInstance2, read: readInstance2 };
+  return { write: getWriteInstance(), read: getReadInstance() };
 }
 async function closeDatabase() {
-  if (!writeInstance2 && !readInstance2) {
-    dbLogger3.debug("No database connections to close");
+  const writeInst = getWriteInstance();
+  const readInst = getReadInstance();
+  if (!writeInst && !readInst) {
+    dbLogger4.debug("No database connections to close");
     return;
   }
   stopHealthCheck();
   try {
     const closePromises = [];
-    if (writeClient) {
-      dbLogger3.debug("Closing write connection...");
+    const writeC = getWriteClient();
+    if (writeC) {
+      dbLogger4.debug("Closing write connection...");
       closePromises.push(
-        writeClient.end({ timeout: 5 }).then(() => dbLogger3.debug("Write connection closed")).catch((err) => dbLogger3.error("Error closing write connection", err))
+        writeC.end({ timeout: 5 }).then(() => dbLogger4.debug("Write connection closed")).catch((err) => dbLogger4.error("Error closing write connection", err))
       );
     }
-    if (readClient && readClient !== writeClient) {
-      dbLogger3.debug("Closing read connection...");
+    const readC = getReadClient();
+    if (readC && readC !== writeC) {
+      dbLogger4.debug("Closing read connection...");
       closePromises.push(
-        readClient.end({ timeout: 5 }).then(() => dbLogger3.debug("Read connection closed")).catch((err) => dbLogger3.error("Error closing read connection", err))
+        readC.end({ timeout: 5 }).then(() => dbLogger4.debug("Read connection closed")).catch((err) => dbLogger4.error("Error closing read connection", err))
       );
     }
     await Promise.all(closePromises);
-    dbLogger3.info("All database connections closed");
+    dbLogger4.info("All database connections closed");
   } catch (error) {
-    dbLogger3.error("Error during database cleanup", error);
+    dbLogger4.error("Error during database cleanup", error);
     throw error;
   } finally {
-    writeInstance2 = void 0;
-    readInstance2 = void 0;
-    writeClient = void 0;
-    readClient = void 0;
-    monitoringConfig = void 0;
+    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: !!writeInstance2,
-    hasRead: !!readInstance2,
-    isReplica: !!(readInstance2 && readInstance2 !== writeInstance2)
+    hasWrite: !!writeInst,
+    hasRead: !!readInst,
+    isReplica: !!(readInst && readInst !== writeInst)
   };
 }
-function startHealthCheck(config2) {
-  if (healthCheckInterval) {
-    dbLogger3.debug("Health check already running");
-    return;
+var dbLogger4;
+var init_manager = __esm({
+  "src/db/manager/manager.ts"() {
+    init_logger2();
+    init_factory();
+    init_config3();
+    init_global_state();
+    init_health_check();
+    dbLogger4 = logger.child("database");
   }
-  dbLogger3.info("Starting database health check", {
-    interval: `${config2.interval}ms`,
-    reconnect: config2.reconnect
-  });
-  healthCheckInterval = setInterval(async () => {
-    try {
-      const write = getDatabase("write");
-      const read = getDatabase("read");
-      if (write) {
-        await write.execute("SELECT 1");
-      }
-      if (read && read !== write) {
-        await read.execute("SELECT 1");
+});
+
+// src/db/manager/index.ts
+var init_manager2 = __esm({
+  "src/db/manager/index.ts"() {
+    init_factory();
+    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 {
       }
-      dbLogger3.debug("Database health check passed");
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Unknown error";
-      dbLogger3.error("Database health check failed", { error: message });
-      if (config2.reconnect) {
-        await attemptReconnection(config2);
+    };
+    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 {
     }
-  }, config2.interval);
+  }
+  return files;
 }
-async function attemptReconnection(config2) {
-  dbLogger3.warn("Attempting database reconnection", {
-    maxRetries: config2.maxRetries,
-    retryInterval: `${config2.retryInterval}ms`
-  });
-  for (let attempt = 1; attempt <= config2.maxRetries; attempt++) {
+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 {
-      dbLogger3.debug(`Reconnection attempt ${attempt}/${config2.maxRetries}`);
-      await closeDatabase();
-      await new Promise((resolve) => setTimeout(resolve, config2.retryInterval));
-      const result = await createDatabaseFromEnv();
-      if (result.write) {
-        await result.write.execute("SELECT 1");
-        writeInstance2 = result.write;
-        readInstance2 = result.read;
-        writeClient = result.writeClient;
-        readClient = result.readClient;
-        dbLogger3.info("Database reconnection successful", { attempt });
-        return;
+      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 message = error instanceof Error ? error.message : "Unknown error";
-      dbLogger3.error(`Reconnection attempt ${attempt} failed`, {
-        error: message,
-        attempt,
-        maxRetries: config2.maxRetries
-      });
-      if (attempt === config2.maxRetries) {
-        dbLogger3.error("Max reconnection attempts reached, giving up");
+    }
+  };
+  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 stopHealthCheck() {
-  if (healthCheckInterval) {
-    clearInterval(healthCheckInterval);
-    healthCheckInterval = void 0;
-    dbLogger3.info("Database health check stopped");
+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 getDatabaseMonitoringConfig() {
-  return monitoringConfig;
+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 dbLogger3, writeInstance2, readInstance2, writeClient, readClient, healthCheckInterval, monitoringConfig;
-var init_manager = __esm({
-  "src/db/manager/manager.ts"() {
-    init_factory();
-    init_logger2();
-    dbLogger3 = logger.child("database");
+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/manager/instance.ts
-function getRawDb(type = "write") {
-  const instance = getDatabase(type);
-  if (!instance) {
-    throw new Error(
-      "Database not initialized. Set DATABASE_URL environment variable or call initDatabase() first."
-    );
+// src/db/schema/index.ts
+var init_schema = __esm({
+  "src/db/schema/index.ts"() {
+    init_helpers();
   }
-  return instance;
+});
+function createFunctionSchema(packageName) {
+  const schemaName = packageNameToSchema(packageName);
+  return pgSchema(schemaName);
 }
-var db;
-var init_instance = __esm({
-  "src/db/manager/instance.ts"() {
-    init_manager();
-    db = new Proxy({}, {
-      get(_target, prop) {
-        const instance = getDatabase("write");
-        if (!instance) {
-          throw new Error(
-            "Database not initialized. Set DATABASE_URL environment variable or call initDatabase() first."
-          );
-        }
-        return instance[prop];
-      }
-    });
+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 = asyncContext.getStore();
+  const context = getTransactionContext();
   return context?.tx ?? null;
 }
-function runWithTransaction(tx, callback) {
-  return asyncContext.run({ tx }, callback);
+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 asyncContext;
+var txLogger, asyncContext;
 var init_context = __esm({
   "src/db/transaction/context.ts"() {
+    init_logger2();
+    txLogger = logger.child("transaction");
     asyncContext = new AsyncLocalStorage();
   }
 });
@@ -1444,17 +2096,25 @@ function Transactional(options = {}) {
     enableLogging = true,
     timeout = defaultTimeout
   } = options;
-  const txLogger = logger.child("transaction");
+  const txLogger2 = logger.child("transaction");
   return createMiddleware(async (c, next) => {
-    const txId = `tx_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+    const txId = `tx_${randomUUID()}`;
     const startTime = Date.now();
     const route = `${c.req.method} ${c.req.path}`;
     if (enableLogging) {
-      txLogger.debug("Transaction started", { txId, route });
+      txLogger2.debug("Transaction started", { txId, route });
     }
     try {
-      const transactionPromise = db.transaction(async (tx) => {
-        await runWithTransaction(tx, async () => {
+      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) {
@@ -1485,14 +2145,14 @@ function Transactional(options = {}) {
       const duration = Date.now() - startTime;
       if (enableLogging) {
         if (duration >= slowThreshold) {
-          txLogger.warn("Slow transaction committed", {
+          txLogger2.warn("Slow transaction committed", {
             txId,
             route,
             duration: `${duration}ms`,
             threshold: `${slowThreshold}ms`
           });
         } else {
-          txLogger.debug("Transaction committed", {
+          txLogger2.debug("Transaction committed", {
             txId,
             route,
             duration: `${duration}ms`
@@ -1503,7 +2163,7 @@ function Transactional(options = {}) {
       const duration = Date.now() - startTime;
       const customError = error instanceof TransactionError ? error : fromPostgresError(error);
       if (enableLogging) {
-        txLogger.error("Transaction rolled back", {
+        txLogger2.error("Transaction rolled back", {
           txId,
           route,
           duration: `${duration}ms`,
@@ -1517,9 +2177,9 @@ function Transactional(options = {}) {
 }
 var init_middleware = __esm({
   "src/db/transaction/middleware.ts"() {
-    init_db();
-    init_context();
     init_logger2();
+    init_manager2();
+    init_context();
     init_errors();
     init_postgres_errors();
   }
@@ -1532,1048 +2192,459 @@ var init_transaction = __esm({
     init_middleware();
   }
 });
-function buildFilters(filters, table) {
-  const conditions = [];
-  for (const [field, filterCondition] of Object.entries(filters)) {
-    const column = table[field];
-    if (!column) {
-      console.warn(`[buildFilters] Unknown field: ${field}`);
-      continue;
+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);
     }
-    for (const [operator, value] of Object.entries(filterCondition)) {
-      const condition = buildCondition(column, operator, value);
-      if (condition) {
-        conditions.push(condition);
-      }
-    }
-  }
-  return conditions.length > 0 ? and(...conditions) : void 0;
-}
-function buildCondition(column, operator, value) {
-  switch (operator) {
-    case "eq":
-      return eq(column, value);
-    case "ne":
-      return ne(column, value);
-    case "gt":
-      return gt(column, value);
-    case "gte":
-      return gte(column, value);
-    case "lt":
-      return lt(column, value);
-    case "lte":
-      return lte(column, value);
-    case "like":
-      return like(column, `%${value}%`);
-    case "in":
-      if (Array.isArray(value)) {
-        return inArray(column, value);
-      }
-      console.warn(`[buildCondition] 'in' operator requires array value`);
-      return void 0;
-    case "nin":
-      if (Array.isArray(value)) {
-        return notInArray(column, value);
-      }
-      console.warn(`[buildCondition] 'nin' operator requires array value`);
-      return void 0;
-    case "is":
-      if (value === "null") return isNull(column);
-      if (value === "notnull") return isNotNull(column);
-      console.warn(`[buildCondition] 'is' operator requires 'null' or 'notnull'`);
-      return void 0;
-    default:
-      console.warn(`[buildCondition] Unknown operator: ${operator}`);
-      return void 0;
   }
+  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;
 }
-function buildSort(sortConditions, table) {
-  const orderByClauses = [];
-  for (const { field, direction } of sortConditions) {
-    const column = table[field];
-    if (!column) {
-      console.warn(`[buildSort] Unknown field: ${field}`);
-      continue;
-    }
-    const clause = direction === "desc" ? desc(column) : asc(column);
-    orderByClauses.push(clause);
+async function create(table, data) {
+  const db = getDatabase("write");
+  if (!db) {
+    throw new Error("Database not initialized. Call initDatabase() first.");
   }
-  return orderByClauses;
+  const [result] = await db.insert(table).values(data).returning();
+  return result;
 }
-function applyPagination(pagination) {
-  const { page, limit } = pagination;
-  const offset = (page - 1) * limit;
-  return { offset, limit };
+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;
 }
-function createPaginationMeta(pagination, total) {
-  const { page, limit } = pagination;
-  const totalPages = Math.ceil(total / limit);
-  return {
-    page,
-    limit,
-    total,
-    totalPages,
-    hasNext: page < totalPages,
-    hasPrev: page > 1
-  };
+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 countTotal(db2, table, whereCondition) {
-  const query = db2.select({ count: sql`count(*)::int` }).from(table);
-  if (whereCondition) {
-    query.where(whereCondition);
+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 query;
-  return result?.count || 0;
+  const [result] = await db.update(table).set(data).where(whereClause).returning();
+  return result ?? null;
 }
-var init_filters = __esm({
-  "src/db/repository/filters.ts"() {
+async function updateMany(table, where, data) {
+  const db = getDatabase("write");
+  if (!db) {
+    throw new Error("Database not initialized. Call initDatabase() first.");
   }
-});
-
-// src/db/repository/query-builder.ts
-var QueryBuilder;
-var init_query_builder = __esm({
-  "src/db/repository/query-builder.ts"() {
-    init_filters();
-    QueryBuilder = class {
-      db;
-      table;
-      filterConditions = [];
-      sortConditions = [];
-      limitValue;
-      offsetValue;
-      constructor(db2, table) {
-        this.db = db2;
-        this.table = table;
-      }
-      /**
-       * Add WHERE conditions
-       *
-       * Multiple where() calls are combined with AND logic.
-       *
-       * @param filters - Filter conditions
-       * @returns QueryBuilder for chaining
-       *
-       * @example
-       * ```typescript
-       * query
-       *     .where({ status: 'active' })
-       *     .where({ role: 'admin' })  // AND condition
-       * ```
-       */
-      where(filters) {
-        this.filterConditions.push(filters);
-        return this;
-      }
-      /**
-       * Add ORDER BY clause
-       *
-       * Multiple orderBy() calls create multi-column sorting.
-       *
-       * @param field - Field name to sort by
-       * @param direction - Sort direction ('asc' or 'desc')
-       * @returns QueryBuilder for chaining
-       *
-       * @example
-       * ```typescript
-       * query
-       *     .orderBy('isPremium', 'desc')
-       *     .orderBy('createdAt', 'desc')
-       * ```
-       */
-      orderBy(field, direction = "asc") {
-        this.sortConditions.push({ field, direction });
-        return this;
-      }
-      /**
-       * Set LIMIT clause
-       *
-       * @param limit - Maximum number of records to return
-       * @returns QueryBuilder for chaining
-       *
-       * @example
-       * ```typescript
-       * query.limit(10)
-       * ```
-       */
-      limit(limit) {
-        this.limitValue = limit;
-        return this;
-      }
-      /**
-       * Set OFFSET clause
-       *
-       * @param offset - Number of records to skip
-       * @returns QueryBuilder for chaining
-       *
-       * @example
-       * ```typescript
-       * query.offset(20)
-       * ```
-       */
-      offset(offset) {
-        this.offsetValue = offset;
-        return this;
-      }
-      /**
-       * Execute query and return multiple records
-       *
-       * @returns Array of records
-       *
-       * @example
-       * ```typescript
-       * const users = await query
-       *     .where({ status: 'active' })
-       *     .orderBy('createdAt', 'desc')
-       *     .limit(10)
-       *     .findMany();
-       * ```
-       */
-      async findMany() {
-        const mergedFilters = this.mergeFilters();
-        const whereCondition = buildFilters(mergedFilters, this.table);
-        const orderBy = buildSort(this.sortConditions, this.table);
-        let query = this.db.select().from(this.table).where(whereCondition).orderBy(...orderBy);
-        if (this.limitValue !== void 0) {
-          query = query.limit(this.limitValue);
-        }
-        if (this.offsetValue !== void 0) {
-          query = query.offset(this.offsetValue);
-        }
-        return query;
-      }
-      /**
-       * Execute query and return first record
-       *
-       * @returns First matching record or null
-       *
-       * @example
-       * ```typescript
-       * const user = await query
-       *     .where({ email: 'john@example.com' })
-       *     .findOne();
-       * ```
-       */
-      async findOne() {
-        const results = await this.limit(1).findMany();
-        return results[0] ?? null;
-      }
-      /**
-       * Execute query and return count
-       *
-       * @returns Number of matching records
-       *
-       * @example
-       * ```typescript
-       * const count = await query
-       *     .where({ status: 'active' })
-       *     .count();
-       * ```
-       */
-      async count() {
-        const mergedFilters = this.mergeFilters();
-        const whereCondition = buildFilters(mergedFilters, this.table);
-        const { count } = await import('drizzle-orm');
-        const result = await this.db.select({ count: count() }).from(this.table).where(whereCondition);
-        return Number(result[0]?.count ?? 0);
-      }
-      /**
-       * Merge multiple filter conditions into single object
-       *
-       * Combines all where() calls into one filter object.
-       */
-      mergeFilters() {
-        if (this.filterConditions.length === 0) {
-          return {};
-        }
-        return this.filterConditions.reduce((merged, current) => {
-          return { ...merged, ...current };
-        }, {});
-      }
-    };
-  }
-});
-
-// src/db/repository/repository.ts
-var Repository;
-var init_repository = __esm({
-  "src/db/repository/repository.ts"() {
-    init_filters();
-    init_manager2();
-    init_transaction();
-    init_errors();
-    init_query_builder();
-    init_logger2();
-    Repository = class {
-      db;
-      table;
-      useReplica;
-      explicitDb;
-      // Track if db was explicitly provided
-      autoUpdateField;
-      // Field name to auto-update (e.g., 'updatedAt', 'modifiedAt')
-      constructor(dbOrTable, tableOrUseReplica, useReplica = true) {
-        if ("name" in dbOrTable && typeof dbOrTable.name === "string") {
-          this.db = getRawDb("write");
-          this.table = dbOrTable;
-          this.useReplica = typeof tableOrUseReplica === "boolean" ? tableOrUseReplica : true;
-          this.explicitDb = void 0;
-        } else {
-          this.db = dbOrTable;
-          this.table = tableOrUseReplica;
-          this.useReplica = useReplica;
-          this.explicitDb = this.db;
-        }
-        this.autoUpdateField = this.detectAutoUpdateField();
-      }
-      /**
-       * Detect which field (if any) should be auto-updated
-       *
-       * Checks all table columns for __autoUpdate metadata flag.
-       * Set by autoUpdateTimestamp() or timestamps({ autoUpdate: true }) helpers.
-       *
-       * @returns Field name to auto-update, or undefined if none found
-       */
-      detectAutoUpdateField() {
-        if (!this.table || typeof this.table !== "object") {
-          return void 0;
-        }
-        const tableColumns = this.table;
-        for (const [fieldName, column] of Object.entries(tableColumns)) {
-          if (fieldName.startsWith("_") || fieldName.startsWith("$")) {
-            continue;
-          }
-          if (column && typeof column === "object" && column.__autoUpdate === true) {
-            return fieldName;
-          }
-        }
-        return void 0;
-      }
-      /**
-       * Inject auto-update timestamp if configured
-       *
-       * Only injects if:
-       * 1. Table has an auto-update field configured (via autoUpdateTimestamp() or timestamps({ autoUpdate: true }))
-       * 2. The field is not already explicitly provided in the data
-       *
-       * @param data - Update data object
-       * @returns Data with auto-update timestamp injected (if applicable)
-       */
-      injectAutoUpdateTimestamp(data) {
-        if (!this.autoUpdateField) {
-          return data;
-        }
-        if (data && this.autoUpdateField in data) {
-          return data;
-        }
-        return {
-          ...data,
-          [this.autoUpdateField]: /* @__PURE__ */ new Date()
-        };
-      }
-      /**
-       * Get id column from table
-       *
-       * Helper method to reduce code duplication across methods that need id column.
-       *
-       * @returns The id column object
-       * @throws {QueryError} If table does not have an id column
-       */
-      getIdColumn() {
-        const idColumn = this.table.id;
-        if (!idColumn) {
-          throw new QueryError("Table does not have an id column");
-        }
-        return idColumn;
-      }
-      /**
-       * Get read-only DB
-       *
-       * Automatically detects and uses transaction context if available.
-       * When in transaction, uses transaction DB to ensure read consistency.
-       * Priority: explicitDb > transaction > replica/primary DB
-       */
-      getReadDb() {
-        if (this.explicitDb) {
-          return this.explicitDb;
-        }
-        const tx = getTransaction();
-        if (tx) {
-          return tx;
-        }
-        return this.useReplica ? getRawDb("read") : this.db;
-      }
-      /**
-       * Get write-only DB
-       *
-       * Automatically detects and uses transaction context if available.
-       * Priority: explicitDb > transaction > primary DB
-       */
-      getWriteDb() {
-        if (this.explicitDb) {
-          return this.explicitDb;
-        }
-        const tx = getTransaction();
-        if (tx) {
-          return tx;
-        }
-        return getRawDb("write");
-      }
-      /**
-       * Execute operation with performance monitoring
-       *
-       * Wraps database operations with timing and logging for slow queries.
-       * Only logs if monitoring is enabled and query exceeds threshold.
-       *
-       * @param operation - Name of the operation (for logging)
-       * @param fn - Async function to execute
-       * @returns Result of the operation
-       */
-      async executeWithMonitoring(operation, fn) {
-        const config2 = getDatabaseMonitoringConfig();
-        if (!config2?.enabled) {
-          return fn();
-        }
-        const startTime = performance.now();
-        try {
-          const result = await fn();
-          const duration = performance.now() - startTime;
-          if (duration >= config2.slowThreshold) {
-            const dbLogger4 = logger.child("database");
-            const logData = {
-              operation,
-              table: this.table._.name,
-              duration: `${duration.toFixed(2)}ms`,
-              threshold: `${config2.slowThreshold}ms`
-            };
-            dbLogger4.warn("Slow query detected", logData);
-          }
-          return result;
-        } catch (error) {
-          const duration = performance.now() - startTime;
-          const dbLogger4 = logger.child("database");
-          const message = error instanceof Error ? error.message : "Unknown error";
-          dbLogger4.error("Query failed", {
-            operation,
-            table: this.table._.name,
-            duration: `${duration.toFixed(2)}ms`,
-            error: message
-          });
-          throw error;
-        }
-      }
-      /**
-       * Find all records (uses Replica)
-       *
-       * @example
-       * const users = await userRepo.findAll();
-       */
-      async findAll() {
-        return this.executeWithMonitoring("findAll", async () => {
-          const readDb = this.getReadDb();
-          return readDb.select().from(this.table);
-        });
-      }
-      /**
-       * Find with pagination (uses Replica)
-       *
-       * @example
-       * const result = await userRepo.findPage({
-       *   filters: { email: { like: 'john' } },
-       *   sort: [{ field: 'createdAt', direction: 'desc' }],
-       *   pagination: { page: 1, limit: 20 }
-       * });
-       */
-      async findPage(pageable) {
-        return this.executeWithMonitoring("findPage", async () => {
-          const { filters = {}, sort = [], pagination = { page: 1, limit: 20 } } = pageable;
-          const whereCondition = buildFilters(filters, this.table);
-          const orderBy = buildSort(sort, this.table);
-          const { offset, limit } = applyPagination(pagination);
-          const readDb = this.getReadDb();
-          const data = await readDb.select().from(this.table).where(whereCondition).orderBy(...orderBy).limit(limit).offset(offset);
-          const total = await countTotal(readDb, this.table, whereCondition);
-          const meta = createPaginationMeta(pagination, total);
-          return { data, meta };
-        });
-      }
-      /**
-       * Find one record by ID (uses Replica)
-       *
-       * @example
-       * const user = await userRepo.findById(1);
-       */
-      async findById(id2) {
-        return this.executeWithMonitoring("findById", async () => {
-          const idColumn = this.getIdColumn();
-          const { eq: eq2 } = await import('drizzle-orm');
-          const readDb = this.getReadDb();
-          const [result] = await readDb.select().from(this.table).where(eq2(idColumn, id2));
-          return result ?? null;
-        });
-      }
-      /**
-       * Find one record by condition (uses Replica)
-       *
-       * @example
-       * const user = await userRepo.findOne(eq(users.email, 'john@example.com'));
-       */
-      async findOne(where) {
-        return this.executeWithMonitoring("findOne", async () => {
-          const readDb = this.getReadDb();
-          const [result] = await readDb.select().from(this.table).where(where);
-          return result ?? null;
-        });
-      }
-      /**
-       * Create a new record (uses Primary)
-       *
-       * @example
-       * const user = await userRepo.save({ email: 'john@example.com', name: 'John' });
-       */
-      async save(data) {
-        return this.executeWithMonitoring("save", async () => {
-          const writeDb = this.getWriteDb();
-          const [result] = await writeDb.insert(this.table).values(data).returning();
-          return result;
-        });
-      }
-      /**
-       * Update a record (uses Primary)
-       *
-       * Automatically injects current timestamp if table has auto-update field configured.
-       *
-       * @example
-       * const user = await userRepo.update(1, { name: 'Jane' });
-       */
-      async update(id2, data) {
-        return this.executeWithMonitoring("update", async () => {
-          const idColumn = this.getIdColumn();
-          const updateData = this.injectAutoUpdateTimestamp(data);
-          const { eq: eq2 } = await import('drizzle-orm');
-          const writeDb = this.getWriteDb();
-          const [result] = await writeDb.update(this.table).set(updateData).where(eq2(idColumn, id2)).returning();
-          return result ?? null;
-        });
-      }
-      /**
-       * Delete a record (uses Primary)
-       *
-       * @example
-       * const deleted = await userRepo.delete(1);
-       */
-      async delete(id2) {
-        return this.executeWithMonitoring("delete", async () => {
-          const idColumn = this.getIdColumn();
-          const { eq: eq2 } = await import('drizzle-orm');
-          const writeDb = this.getWriteDb();
-          const [result] = await writeDb.delete(this.table).where(eq2(idColumn, id2)).returning();
-          return result ?? null;
-        });
-      }
-      /**
-       * Count records (uses Replica)
-       *
-       * @example
-       * const count = await userRepo.count();
-       */
-      async count(where) {
-        return this.executeWithMonitoring("count", async () => {
-          const readDb = this.getReadDb();
-          return countTotal(readDb, this.table, where);
-        });
-      }
-      /**
-       * Find records by filters (uses Replica)
-       *
-       * @example
-       * const users = await userRepo.findWhere({ email: { like: '@gmail.com' }, status: 'active' });
-       */
-      async findWhere(filters) {
-        return this.executeWithMonitoring("findWhere", async () => {
-          const whereCondition = buildFilters(filters, this.table);
-          const readDb = this.getReadDb();
-          return readDb.select().from(this.table).where(whereCondition);
-        });
-      }
-      /**
-       * Find one record by filters (uses Replica)
-       *
-       * @example
-       * const user = await userRepo.findOneWhere({ email: 'john@example.com' });
-       */
-      async findOneWhere(filters) {
-        return this.executeWithMonitoring("findOneWhere", async () => {
-          const whereCondition = buildFilters(filters, this.table);
-          const readDb = this.getReadDb();
-          const [result] = await readDb.select().from(this.table).where(whereCondition);
-          return result ?? null;
-        });
-      }
-      /**
-       * Check if record exists by ID (uses Replica)
-       *
-       * @example
-       * const exists = await userRepo.exists(1);
-       */
-      async exists(id2) {
-        return this.executeWithMonitoring("exists", async () => {
-          const idColumn = this.getIdColumn();
-          const { eq: eq2 } = await import('drizzle-orm');
-          const readDb = this.getReadDb();
-          const [result] = await readDb.select().from(this.table).where(eq2(idColumn, id2)).limit(1);
-          return !!result;
-        });
-      }
-      /**
-       * Check if record exists by filters (uses Replica)
-       *
-       * @example
-       * const exists = await userRepo.existsBy({ email: 'john@example.com' });
-       */
-      async existsBy(filters) {
-        return this.executeWithMonitoring("existsBy", async () => {
-          const whereCondition = buildFilters(filters, this.table);
-          const readDb = this.getReadDb();
-          const [result] = await readDb.select().from(this.table).where(whereCondition).limit(1);
-          return !!result;
-        });
-      }
-      /**
-       * Count records by filters (uses Replica)
-       *
-       * @example
-       * const count = await userRepo.countBy({ status: 'active' });
-       */
-      async countBy(filters) {
-        return this.executeWithMonitoring("countBy", async () => {
-          const whereCondition = buildFilters(filters, this.table);
-          const readDb = this.getReadDb();
-          return countTotal(readDb, this.table, whereCondition);
-        });
-      }
-      /**
-       * Create multiple records (uses Primary)
-       *
-       * @example
-       * const users = await userRepo.saveMany([
-       *   { email: 'user1@example.com', name: 'User 1' },
-       *   { email: 'user2@example.com', name: 'User 2' }
-       * ]);
-       */
-      async saveMany(data) {
-        return this.executeWithMonitoring("saveMany", async () => {
-          const writeDb = this.getWriteDb();
-          return writeDb.insert(this.table).values(data).returning();
-        });
-      }
-      /**
-       * Update multiple records by filters (uses Primary)
-       *
-       * Automatically injects current timestamp if table has auto-update field configured.
-       *
-       * @example
-       * const count = await userRepo.updateWhere({ status: 'inactive' }, { status: 'archived' });
-       */
-      async updateWhere(filters, data) {
-        return this.executeWithMonitoring("updateWhere", async () => {
-          const updateData = this.injectAutoUpdateTimestamp(data);
-          const whereCondition = buildFilters(filters, this.table);
-          const writeDb = this.getWriteDb();
-          const results = await writeDb.update(this.table).set(updateData).where(whereCondition).returning();
-          return results.length;
-        });
-      }
-      /**
-       * Delete multiple records by filters (uses Primary)
-       *
-       * @example
-       * const count = await userRepo.deleteWhere({ status: 'banned' });
-       */
-      async deleteWhere(filters) {
-        return this.executeWithMonitoring("deleteWhere", async () => {
-          const whereCondition = buildFilters(filters, this.table);
-          const writeDb = this.getWriteDb();
-          const results = await writeDb.delete(this.table).where(whereCondition).returning();
-          return results.length;
-        });
-      }
-      // ============================================================
-      // Query Builder (Fluent Interface)
-      // ============================================================
-      /**
-       * Start a chainable query builder (uses Replica)
-       *
-       * Returns a QueryBuilder instance for building complex queries with method chaining.
-       *
-       * @returns QueryBuilder instance for chaining
-       *
-       * @example
-       * ```typescript
-       * // Simple chaining
-       * const users = await userRepo
-       *     .query()
-       *     .where({ status: 'active' })
-       *     .orderBy('createdAt', 'desc')
-       *     .limit(10)
-       *     .findMany();
-       *
-       * // Multiple conditions
-       * const admins = await userRepo
-       *     .query()
-       *     .where({ role: 'admin' })
-       *     .where({ status: 'active' })  // AND condition
-       *     .findMany();
-       *
-       * // Reusable query
-       * const activeQuery = userRepo.query().where({ status: 'active' });
-       * const users = await activeQuery.findMany();
-       * const count = await activeQuery.count();
-       * ```
-       */
-      query() {
-        const readDb = this.getReadDb();
-        return new QueryBuilder(readDb, this.table);
-      }
-    };
-  }
-});
-
-// src/db/repository/factory.ts
-function getCacheKey(table, RepositoryClass) {
-  const tableName = table[Symbol.for("drizzle:Name")] || table.name || table.toString();
-  const className = RepositoryClass?.name || "Repository";
-  return `${tableName}:${className}`;
-}
-function getRepository(table, RepositoryClass) {
-  const cacheKey = getCacheKey(table, RepositoryClass);
-  let repo = repositoryCache.get(cacheKey);
-  if (!repo) {
-    if (RepositoryClass) {
-      repo = new RepositoryClass(table);
-    } else {
-      repo = new Repository(table);
-    }
-    repositoryCache.set(cacheKey, repo);
+  const whereClause = isSQLWrapper(where) ? where : where ? buildWhereFromObject(table, where) : void 0;
+  if (!whereClause) {
+    throw new Error("updateMany requires at least one where condition");
   }
-  return repo;
-}
-function clearRepositoryCache() {
-  repositoryCache.clear();
+  const results = await db.update(table).set(data).where(whereClause).returning();
+  return results;
 }
-function getRepositoryCacheSize() {
-  return repositoryCache.size;
-}
-var repositoryCache;
-var init_factory2 = __esm({
-  "src/db/repository/factory.ts"() {
-    init_repository();
-    repositoryCache = /* @__PURE__ */ new Map();
+async function deleteOne(table, where) {
+  const db = getDatabase("write");
+  if (!db) {
+    throw new Error("Database not initialized. Call initDatabase() first.");
   }
-});
-function getCacheKey2(table, RepositoryClass) {
-  const tableName = table[Symbol.for("drizzle:Name")] || table.name || table.toString();
-  const className = RepositoryClass?.name || "Repository";
-  return `${tableName}:${className}`;
-}
-function withRepositoryScope(fn) {
-  const cache = /* @__PURE__ */ new Map();
-  return repositoryStorage.run(cache, fn);
-}
-function getScopedRepository(table, RepositoryClass) {
-  const cache = repositoryStorage.getStore();
-  if (!cache) {
-    return RepositoryClass ? new RepositoryClass(table) : new Repository(table);
-  }
-  const key = getCacheKey2(table, RepositoryClass);
-  let repo = cache.get(key);
-  if (!repo) {
-    repo = RepositoryClass ? new RepositoryClass(table) : new Repository(table);
-    cache.set(key, repo);
-  }
-  return repo;
-}
-function RepositoryScope() {
-  return async (_c, next) => {
-    return withRepositoryScope(() => next());
-  };
-}
-function getScopedCacheSize() {
-  const cache = repositoryStorage.getStore();
-  return cache?.size ?? 0;
-}
-function isInRepositoryScope() {
-  return repositoryStorage.getStore() !== void 0;
-}
-var repositoryStorage;
-var init_request_scope = __esm({
-  "src/db/repository/request-scope.ts"() {
-    init_repository();
-    repositoryStorage = new AsyncLocalStorage();
+  const whereClause = isSQLWrapper(where) ? where : where ? buildWhereFromObject(table, where) : void 0;
+  if (!whereClause) {
+    throw new Error("deleteOne requires at least one where condition");
   }
-});
-
-// src/db/repository/relation-registry.ts
-function getTableName(table) {
-  const cached = tableNameCache.get(table);
-  if (cached) {
-    return cached;
-  }
-  const name = table[Symbol.for("drizzle:Name")] || table.constructor.name;
-  tableNameCache.set(table, name);
-  return name;
+  const [result] = await db.delete(table).where(whereClause).returning();
+  return result ?? null;
 }
-var tableNameCache;
-var init_relation_registry = __esm({
-  "src/db/repository/relation-registry.ts"() {
-    tableNameCache = /* @__PURE__ */ new WeakMap();
+async function deleteMany(table, where) {
+  const db = getDatabase("write");
+  if (!db) {
+    throw new Error("Database not initialized. Call initDatabase() first.");
   }
-});
-
-// src/db/repository/index.ts
-var init_repository2 = __esm({
-  "src/db/repository/index.ts"() {
-    init_repository();
-    init_factory2();
-    init_request_scope();
-    init_query_builder();
-    init_relation_registry();
-    init_filters();
-  }
-});
-
-// src/db/manager/wrapped-db.ts
-var WrappedDb;
-var init_wrapped_db = __esm({
-  "src/db/manager/wrapped-db.ts"() {
-    init_repository2();
-    WrappedDb = class {
-      constructor(db2) {
-        this.db = db2;
-      }
-      /**
-       * Repository 패턴으로 테이블 접근
-       *
-       * @example
-       * const db = getDb();
-       * const userRepo = db.for(users);
-       * const result = await userRepo.findPage(pageable);
-       */
-      for(table) {
-        return new Repository(this.db, table);
-      }
-      /**
-       * Drizzle의 모든 메서드를 프록시
-       *
-       * select, insert, update, delete, transaction 등 모든 Drizzle 메서드 사용 가능
-       */
-      get select() {
-        return this.db.select.bind(this.db);
-      }
-      get insert() {
-        return this.db.insert.bind(this.db);
-      }
-      get update() {
-        return this.db.update.bind(this.db);
-      }
-      get delete() {
-        return this.db.delete.bind(this.db);
-      }
-      get execute() {
-        return this.db.execute.bind(this.db);
-      }
-      get transaction() {
-        return this.db.transaction.bind(this.db);
-      }
-      get query() {
-        return this.db.query;
-      }
-      get $with() {
-        return this.db.$with.bind(this.db);
-      }
-      /**
-       * Raw Drizzle DB 접근 (필요시)
-       */
-      get raw() {
-        return this.db;
-      }
-    };
-  }
-});
-
-// src/db/manager/context.ts
-function getDb(type) {
-  const tx = getTransaction();
-  if (tx) {
-    return new WrappedDb(tx);
-  }
-  const rawDb = getDatabase(type);
-  if (!rawDb) {
-    throw new Error(
-      "Database not initialized. Set DATABASE_URL environment variable or call initDatabase() first."
-    );
-  }
-  return new WrappedDb(rawDb);
-}
-var init_context2 = __esm({
-  "src/db/manager/context.ts"() {
-    init_transaction();
-    init_manager();
-    init_wrapped_db();
-  }
-});
-
-// src/db/manager/index.ts
-var init_manager2 = __esm({
-  "src/db/manager/index.ts"() {
-    init_instance();
-    init_context2();
-    init_factory();
-    init_manager();
-    init_connection();
-    init_wrapped_db();
-  }
-});
-
-// src/db/manager/config-generator.ts
-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 schema = options.schema ?? "./src/server/entities/*.ts";
-  const out = options.out ?? "./drizzle/migrations";
-  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}`);
+  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;
 }
-function generateDrizzleConfigFile(options = {}) {
-  const config2 = getDrizzleConfig(options);
-  return `import { defineConfig } from 'drizzle-kit';
-
-export default defineConfig({
-    schema: '${config2.schema}',
-    out: '${config2.out}',
-    dialect: '${config2.dialect}',
-    dbCredentials: ${JSON.stringify(config2.dbCredentials, null, 4)},
-});
-`;
-}
-var init_config_generator = __esm({
-  "src/db/manager/config-generator.ts"() {
+async function count(table, where) {
+  const db = getDatabase("read");
+  if (!db) {
+    throw new Error("Database not initialized. Call initDatabase() first.");
   }
-});
-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;
+  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);
+    }
   }
-  return {
-    createdAt: timestamp("created_at", { withTimezone: true, mode: "date" }).defaultNow().notNull(),
-    updatedAt: updatedAtColumn
-  };
+  const results = await query;
+  return results.length;
 }
-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();
+var init_helpers2 = __esm({
+  "src/db/helpers.ts"() {
+    init_manager2();
   }
 });
 
 // src/db/index.ts
 var db_exports = {};
 __export(db_exports, {
-  QueryBuilder: () => QueryBuilder,
-  Repository: () => Repository,
-  RepositoryScope: () => RepositoryScope,
   Transactional: () => Transactional,
-  WrappedDb: () => WrappedDb,
   checkConnection: () => checkConnection,
-  clearRepositoryCache: () => clearRepositoryCache,
   closeDatabase: () => closeDatabase,
+  count: () => count,
+  create: () => create,
   createDatabaseConnection: () => createDatabaseConnection,
   createDatabaseFromEnv: () => createDatabaseFromEnv,
-  db: () => db,
+  createFunctionSchema: () => createFunctionSchema,
+  createMany: () => createMany,
+  deleteMany: () => deleteMany,
+  deleteOne: () => deleteOne,
   detectDialect: () => detectDialect,
+  findMany: () => findMany,
+  findOne: () => findOne,
   foreignKey: () => foreignKey,
   fromPostgresError: () => fromPostgresError,
   generateDrizzleConfigFile: () => generateDrizzleConfigFile,
   getDatabase: () => getDatabase,
   getDatabaseInfo: () => getDatabaseInfo,
-  getDb: () => getDb,
   getDrizzleConfig: () => getDrizzleConfig,
-  getRawDb: () => getRawDb,
-  getRepository: () => getRepository,
-  getRepositoryCacheSize: () => getRepositoryCacheSize,
-  getScopedCacheSize: () => getScopedCacheSize,
-  getScopedRepository: () => getScopedRepository,
-  getTableName: () => getTableName,
+  getSchemaInfo: () => getSchemaInfo,
   getTransaction: () => getTransaction,
   id: () => id,
   initDatabase: () => initDatabase,
-  isInRepositoryScope: () => isInRepositoryScope,
   optionalForeignKey: () => optionalForeignKey,
+  packageNameToSchema: () => packageNameToSchema,
   runWithTransaction: () => runWithTransaction,
   setDatabase: () => setDatabase,
   timestamps: () => timestamps,
-  withRepositoryScope: () => withRepositoryScope
+  updateMany: () => updateMany,
+  updateOne: () => updateOne,
+  upsert: () => upsert
 });
 var init_db = __esm({
   "src/db/index.ts"() {
     init_manager2();
     init_config_generator();
-    init_repository2();
     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;
@@ -2581,36 +2652,18 @@ var AutoRouteLoader = class {
     this.middlewares = middlewares;
   }
   routes = [];
-  registeredRoutes = /* @__PURE__ */ new Map();
-  // normalized path → file
   debug;
   middlewares;
-  /**
-   * Load all routes from directory
-   */
   async load(app) {
     const startTime = Date.now();
     const files = await this.scanFiles(this.routesDir);
     if (files.length === 0) {
-      console.warn("\u26A0\uFE0F  No route files found");
+      routeLogger2.warn("No route files found");
       return this.getStats();
     }
-    const filesWithPriority = files.map((file) => ({
-      path: file,
-      priority: this.calculatePriority(relative(this.routesDir, file))
-    }));
-    filesWithPriority.sort((a, b) => a.priority - b.priority);
-    if (this.debug) {
-      console.log(`
-\u{1F4CB} Route Registration Order:`);
-      console.log(`   Priority 1 (Static):    ${filesWithPriority.filter((f) => f.priority === 1).length} routes`);
-      console.log(`   Priority 2 (Dynamic):   ${filesWithPriority.filter((f) => f.priority === 2).length} routes`);
-      console.log(`   Priority 3 (Catch-all): ${filesWithPriority.filter((f) => f.priority === 3).length} routes
-`);
-    }
     let failureCount = 0;
-    for (const { path } of filesWithPriority) {
-      const success = await this.loadRoute(app, path);
+    for (const file of files) {
+      const success = await this.loadRoute(app, file);
       if (success) ; else {
         failureCount++;
       }
@@ -2621,13 +2674,53 @@ var AutoRouteLoader = class {
       this.logStats(stats, elapsed);
     }
     if (failureCount > 0) {
-      console.warn(`\u26A0\uFE0F  ${failureCount} route(s) failed to load`);
+      routeLogger2.warn("Some routes failed to load", { failureCount });
     }
     return stats;
   }
   /**
-   * Get route statistics
+   * 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,
@@ -2647,12 +2740,6 @@ var AutoRouteLoader = class {
     }
     return stats;
   }
-  // ========================================================================
-  // Private Methods
-  // ========================================================================
-  /**
-   * Recursively scan directory for .ts files
-   */
   async scanFiles(dir, files = []) {
     const entries = await readdir(dir);
     for (const entry of entries) {
@@ -2666,191 +2753,189 @@ var AutoRouteLoader = class {
     }
     return files;
   }
-  /**
-   * Check if file is a valid route file
-   */
   isValidRouteFile(fileName) {
-    return fileName.endsWith(".ts") && !fileName.endsWith(".test.ts") && !fileName.endsWith(".spec.ts") && !fileName.endsWith(".d.ts") && fileName !== "contract.ts";
+    return fileName === "index.ts" || fileName === "index.js" || fileName === "index.mjs";
   }
-  /**
-   * Load and register a single route
-   * Returns true if successful, false if failed
-   */
-  async loadRoute(app, absolutePath) {
+  async loadRoute(app, absolutePath, prefix) {
     const relativePath = relative(this.routesDir, absolutePath);
     try {
-      const module = await import(absolutePath);
-      if (!module.default) {
-        console.error(`\u274C ${relativePath}: Must export Hono instance as default`);
-        return false;
-      }
-      if (typeof module.default.route !== "function") {
-        console.error(`\u274C ${relativePath}: Default export is not a Hono instance`);
-        return false;
-      }
-      const urlPath = this.fileToPath(relativePath);
-      const priority = this.calculatePriority(relativePath);
-      const normalizedPath = this.normalizePath(urlPath);
-      const existingFile = this.registeredRoutes.get(normalizedPath);
-      if (existingFile) {
-        console.warn(`\u26A0\uFE0F  Route conflict detected:`);
-        console.warn(`   Path: ${urlPath} (normalized: ${normalizedPath})`);
-        console.warn(`   Already registered by: ${existingFile}`);
-        console.warn(`   Attempted by: ${relativePath}`);
-        console.warn(`   \u2192 Skipping duplicate registration`);
+      const module = await import(absolutePath);
+      if (!this.validateModule(module, relativePath)) {
         return false;
       }
-      this.registeredRoutes.set(normalizedPath, relativePath);
       const hasContractMetas = module.default._contractMetas && module.default._contractMetas.size > 0;
-      if (hasContractMetas) {
-        const middlewarePath = urlPath === "/" ? "/*" : `${urlPath}/*`;
-        app.use(middlewarePath, (c, next) => {
-          const method = c.req.method;
-          const requestPath = new URL(c.req.url).pathname;
-          const relativePath2 = requestPath.startsWith(urlPath) ? requestPath.slice(urlPath.length) || "/" : requestPath;
-          const key = `${method} ${relativePath2}`;
-          const meta = module.default._contractMetas?.get(key);
-          if (meta?.skipMiddlewares) {
-            c.set("_skipMiddlewares", meta.skipMiddlewares);
-          }
-          return next();
+      if (!hasContractMetas) {
+        routeLogger2.error("Route must use contract-based routing", {
+          file: relativePath,
+          hint: "Export contracts using satisfies RouteContract and use app.bind()"
         });
-        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);
+        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"`
           });
-        }
-      } else {
-        const skipList = module.meta?.skipMiddlewares || [];
-        const activeMiddlewares = this.middlewares.filter((m) => !skipList.includes(m.name));
-        for (const middleware of activeMiddlewares) {
-          app.use(urlPath, middleware.handler);
+          return false;
         }
       }
-      app.route(urlPath, module.default);
-      this.routes.push({
-        path: urlPath,
-        file: relativePath,
-        meta: module.meta,
-        priority
+      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 });
+        }
       });
-      if (this.debug) {
-        const icon = priority === 1 ? "\u{1F539}" : priority === 2 ? "\u{1F538}" : "\u2B50";
-        console.log(`   ${icon} ${urlPath.padEnd(40)} \u2192 ${relativePath}`);
-      }
       return true;
     } catch (error) {
-      const err = error;
-      if (err.message.includes("Cannot find module") || err.message.includes("MODULE_NOT_FOUND")) {
-        console.error(`\u274C ${relativePath}: Missing dependency`);
-        console.error(`   ${err.message}`);
-        console.error(`   \u2192 Run: npm install`);
-      } else if (err.message.includes("SyntaxError") || err.stack?.includes("SyntaxError")) {
-        console.error(`\u274C ${relativePath}: Syntax error`);
-        console.error(`   ${err.message}`);
-        if (this.debug && err.stack) {
-          console.error(`   Stack trace (first 5 lines):`);
-          const stackLines = err.stack.split("\n").slice(0, 5);
-          stackLines.forEach((line) => console.error(`   ${line}`));
-        }
-      } else if (err.message.includes("Unexpected token")) {
-        console.error(`\u274C ${relativePath}: Parse error`);
-        console.error(`   ${err.message}`);
-        console.error(`   \u2192 Check for syntax errors or invalid TypeScript`);
-      } else {
-        console.error(`\u274C ${relativePath}: ${err.message}`);
-        if (this.debug && err.stack) {
-          console.error(`   Stack: ${err.stack}`);
+      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 false;
     }
+    return Array.from(paths);
   }
-  /**
-   * Convert file path to URL path
-   *
-   * Examples:
-   * - users/index.ts → /users
-   * - users/[id].ts → /users/:id
-   * - posts/[...slug].ts → /posts/*
-   */
-  fileToPath(filePath) {
-    let path = filePath.replace(/\.ts$/, "");
-    const segments = path.split("/");
-    if (segments[segments.length - 1] === "index") {
-      segments.pop();
+  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;
     }
-    const transformed = segments.map((seg) => {
-      if (/^\[\.\.\.[\w-]+]$/.test(seg)) {
-        return "*";
-      }
-      if (/^\[[\w-]+]$/.test(seg)) {
-        return ":" + seg.slice(1, -1);
+    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);
       }
-      if (seg === "index") {
-        return null;
+      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);
+        });
       }
-      return seg;
-    }).filter((seg) => seg !== null);
-    const result = "/" + transformed.join("/");
-    return result.replace(/\/+/g, "/").replace(/\/$/, "") || "/";
-  }
-  /**
-   * Calculate route priority
-   * 1 = static, 2 = dynamic, 3 = catch-all
-   */
-  calculatePriority(path) {
-    if (/\[\.\.\.[\w-]+]/.test(path)) return 3;
-    if (/\[[\w-]+]/.test(path)) return 2;
-    return 1;
+    }
   }
-  /**
-   * Normalize path for conflict detection
-   *
-   * Converts dynamic parameter names to generic placeholders:
-   * - /users/:id → /users/:param
-   * - /users/:userId → /users/:param (conflict!)
-   * - /posts/* → /posts/* (unchanged)
-   *
-   * This allows detection of routes with different param names
-   * that would match the same URL patterns.
-   */
-  normalizePath(path) {
-    return path.replace(/:\w+/g, ":param");
+  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 }
+      });
+    }
   }
-  /**
-   * Log statistics
-   */
   logStats(stats, elapsed) {
-    console.log(`
-\u{1F4CA} Route Statistics:`);
-    console.log(`   Total: ${stats.total} routes`);
-    console.log(
-      `   Priority: ${stats.byPriority.static} static, ${stats.byPriority.dynamic} dynamic, ${stats.byPriority.catchAll} catch-all`
-    );
-    if (Object.keys(stats.byTag).length > 0) {
-      const tagCounts = Object.entries(stats.byTag).map(([tag, count]) => `${tag}(${count})`).join(", ");
-      console.log(`   Tags: ${tagCounts}`);
-    }
-    console.log(`
-\u2705 Routes loaded in ${elapsed}ms
-`);
+    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);
-  return loader.load(app);
+  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_database_errors();
+init_errors();
 
 // src/middleware/error-handler.ts
 init_logger2();
@@ -2861,27 +2946,36 @@ function ErrorHandler(options = {}) {
     enableLogging = true
   } = options;
   return (err, c) => {
-    const statusCode = err.statusCode || 500;
+    const errorWithCode = err;
+    const statusCode = errorWithCode.statusCode || 500;
     const errorType = err.name || "Error";
     if (enableLogging) {
       const logLevel = statusCode >= 500 ? "error" : "warn";
-      errorLogger[logLevel]("Error occurred", {
+      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 (err.details) {
-      response.error.details = err.details;
+    if (errorWithCode.details) {
+      response.error.details = errorWithCode.details;
     }
     if (includeStack) {
       response.error.stack = err.stack;
@@ -2896,15 +2990,14 @@ var DEFAULT_CONFIG = {
   excludePaths: ["/health", "/ping", "/favicon.ico"],
   sensitiveFields: ["password", "token", "apiKey", "secret", "authorization"],
   slowRequestThreshold: 1e3
-  // 1 second
 };
 function generateRequestId() {
   const timestamp2 = Date.now();
   const randomPart = randomBytes(6).toString("hex");
   return `req_${timestamp2}_${randomPart}`;
 }
-function RequestLogger(config2) {
-  const cfg = { ...DEFAULT_CONFIG, ...config2 };
+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;
@@ -2941,15 +3034,6 @@ function RequestLogger(config2) {
         logData.slow = true;
       }
       apiLogger[logLevel]("Request completed", logData);
-      if (isSlowRequest) {
-        apiLogger.warn("Slow request detected", {
-          requestId,
-          method,
-          path,
-          duration,
-          threshold: cfg.slowRequestThreshold
-        });
-      }
     } catch (error) {
       const duration = Date.now() - startTime;
       apiLogger.error("Request failed", error, {
@@ -2963,215 +3047,470 @@ function RequestLogger(config2) {
   };
 }
 
-// src/server/server.ts
-init_cache();
-init_db();
+// 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/create-server.ts
 var serverLogger = logger.child("server");
-async function createServer(config2) {
+async function createServer(config) {
   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)) {
-    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 app2 = await appFactory();
-    const debug2 = config2?.debug ?? process.env.NODE_ENV === "development";
-    await loadRoutes(app2, { routesDir: config2?.routesPath, debug: debug2 });
-    return app2;
+    return await loadCustomApp(appPath, appJsPath, config);
+  }
+  return await createAutoConfiguredApp(config);
+}
+async function loadCustomApp(appPath, appJsPath, config) {
+  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();
+  const debug = config?.debug ?? process.env.NODE_ENV === "development";
+  await loadRoutes(app, { routesDir: config?.routesPath, debug });
+  return app;
+}
+async function createAutoConfiguredApp(config) {
   const app = new Hono();
-  const middlewareConfig = config2?.middleware ?? {};
+  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 loadAppRoutes(app, config);
+  await executeAfterRoutesHook(app, config);
+  if (enableErrorHandler) {
+    app.onError(ErrorHandler());
+  }
+  return app;
+}
+function applyDefaultMiddleware(app, config, enableLogger, enableCors) {
   if (enableLogger) {
     app.use("*", RequestLogger());
   }
-  if (enableCors && config2?.cors !== false) {
-    app.use("*", cors(config2?.cors));
+  if (enableCors && config?.cors !== false) {
+    app.use("*", cors(config?.cors));
   }
-  config2?.use?.forEach((mw) => app.use("*", mw));
-  const healthCheckConfig = config2?.healthCheck ?? {};
+}
+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, async (c) => {
-      const response = {
-        status: "ok",
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      };
-      if (healthCheckDetailed) {
-        const { getDatabase: getDatabase2 } = await Promise.resolve().then(() => (init_db(), db_exports));
-        const { getRedis: getRedis2 } = await Promise.resolve().then(() => (init_cache(), cache_exports));
-        const db2 = getDatabase2();
-        let dbStatus = "disconnected";
-        if (db2) {
-          try {
-            await db2.execute("SELECT 1");
-            dbStatus = "connected";
-          } catch {
-            dbStatus = "error";
-          }
-        }
-        const redis = getRedis2();
-        let redisStatus = "disconnected";
-        if (redis) {
-          try {
-            await redis.ping();
-            redisStatus = "connected";
-          } catch {
-            redisStatus = "error";
-          }
-        }
-        response.services = {
-          database: dbStatus,
-          redis: redisStatus
-        };
-      }
-      return c.json(response);
-    });
+    app.get(healthCheckPath, createHealthCheckHandler(healthCheckDetailed));
     serverLogger.debug(`Health check endpoint enabled at ${healthCheckPath}`);
   }
-  await config2?.beforeRoutes?.(app);
-  const debug = config2?.debug ?? process.env.NODE_ENV === "development";
+}
+async function executeBeforeRoutesHook(app, config) {
+  if (!config?.beforeRoutes) {
+    return;
+  }
+  try {
+    await config.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: config2?.routesPath,
+    routesDir: config?.routesPath,
     debug,
-    middlewares: config2?.middlewares
+    middlewares: config?.middlewares
   });
-  await config2?.afterRoutes?.(app);
-  if (enableErrorHandler) {
-    app.onError(ErrorHandler());
+}
+async function executeAfterRoutesHook(app, config) {
+  if (!config?.afterRoutes) {
+    return;
+  }
+  try {
+    await config.afterRoutes(app);
+  } catch (error) {
+    serverLogger.error("afterRoutes hook failed", error);
+    throw new Error("Server initialization failed in afterRoutes hook");
   }
-  return app;
 }
-async function startServer(config2) {
-  const cwd = process.cwd();
-  const configPath = join(cwd, "src", "server", "server.config.ts");
-  const configJsPath = join(cwd, "src", "server", "server.config.js");
-  let fileConfig = {};
-  if (existsSync(configPath) || existsSync(configJsPath)) {
-    const configModule = await (existsSync(configPath) ? import(configPath) : import(configJsPath));
-    fileConfig = configModule.default ?? {};
+
+// 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;
+      }
+    }
   }
-  const finalConfig = {
-    ...fileConfig,
-    ...config2,
-    port: config2?.port ?? fileConfig?.port ?? (parseInt(process.env.PORT || "", 10) || 4e3),
-    host: config2?.host ?? fileConfig?.host ?? (process.env.HOST || "localhost")
-  };
+  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);
+  }
   try {
-    serverLogger.debug("Initializing database...");
-    await initDatabase(finalConfig.database);
-    serverLogger.debug("Initializing Redis...");
-    await initRedis();
-    serverLogger.debug("Creating Hono app...");
+    await initializeInfrastructure(finalConfig);
     const app = await createServer(finalConfig);
-    serverLogger.debug(`Starting server on ${host}:${port}...`);
-    const server = serve(
-      {
-        fetch: app.fetch,
-        port,
-        hostname: host
-      }
-    );
-    const timeoutConfig = finalConfig.timeout ?? {};
-    const requestTimeout = timeoutConfig.request ?? (parseInt(process.env.SERVER_TIMEOUT || "", 10) || 12e4);
-    const keepAliveTimeout = timeoutConfig.keepAlive ?? (parseInt(process.env.SERVER_KEEPALIVE_TIMEOUT || "", 10) || 65e3);
-    const headersTimeout = timeoutConfig.headers ?? (parseInt(process.env.SERVER_HEADERS_TIMEOUT || "", 10) || 6e4);
-    if ("timeout" in server) {
-      server.timeout = requestTimeout;
-      server.keepAliveTimeout = keepAliveTimeout;
-      server.headersTimeout = headersTimeout;
-    }
-    serverLogger.info("Server timeouts configured", {
-      request: `${requestTimeout}ms`,
-      keepAlive: `${keepAliveTimeout}ms`,
-      headers: `${headersTimeout}ms`
-    });
-    console.log(`   \u25B2 SPFN ${debug ? "dev" : "production"}`);
-    console.log(`   - Local:        http://${host}:${port}`);
-    console.log("");
-    const shutdownServer = async () => {
-      serverLogger.debug("Closing HTTP server...");
-      await new Promise((resolve) => {
-        server.close(() => {
-          serverLogger.info("HTTP server closed");
-          resolve();
-        });
-      });
-      serverLogger.debug("Closing database connections...");
-      await closeDatabase();
-      serverLogger.debug("Closing Redis connections...");
-      await closeRedis();
-      serverLogger.info("Server shutdown completed");
-    };
-    const shutdown = async (signal) => {
-      serverLogger.info(`${signal} received, starting graceful shutdown...`);
-      const shutdownTimeout = finalConfig.shutdown?.timeout ?? (parseInt(process.env.SHUTDOWN_TIMEOUT || "", 10) || 3e4);
-      const timeoutPromise = new Promise((_, reject) => {
-        setTimeout(() => {
-          reject(new Error(`Graceful shutdown timeout after ${shutdownTimeout}ms`));
-        }, shutdownTimeout);
-      });
-      try {
-        await Promise.race([
-          shutdownServer(),
-          timeoutPromise
-        ]);
-        serverLogger.info("Graceful shutdown completed successfully");
-        process.exit(0);
-      } catch (error) {
-        const err = error;
-        if (err.message && err.message.includes("timeout")) {
-          serverLogger.error("Graceful shutdown timeout, forcing exit", err);
-        } else {
-          serverLogger.error("Error during graceful shutdown", err);
-        }
-        process.exit(1);
-      }
-    };
-    const close = async () => {
-      serverLogger.info("Manual server shutdown requested");
-      await shutdownServer();
-    };
-    process.on("SIGTERM", () => shutdown("SIGTERM"));
-    process.on("SIGINT", () => shutdown("SIGINT"));
-    process.on("uncaughtException", (error) => {
-      serverLogger.error("Uncaught exception", error);
-      shutdown("UNCAUGHT_EXCEPTION");
-    });
-    process.on("unhandledRejection", (reason, promise) => {
-      serverLogger.error("Unhandled promise rejection", {
-        reason,
-        promise
-      });
-      shutdown("UNHANDLED_REJECTION");
+    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);
+    const shutdown = createGracefulShutdown(shutdownServer, finalConfig);
+    registerShutdownHandlers(shutdown);
     return {
       server,
       app,
       config: finalConfig,
-      close
+      close: async () => {
+        serverLogger2.info("Manual server shutdown requested");
+        await shutdownServer();
+      }
     };
   } catch (error) {
     const err = error;
-    serverLogger.error("Server initialization failed", err);
+    serverLogger2.error("Server initialization failed", err);
+    await cleanupOnFailure();
+    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) {
+  serverLogger2.debug("Initializing database...");
+  await initDatabase(config.database);
+  serverLogger2.debug("Initializing Redis...");
+  await initRedis();
+}
+function startHttpServer(app, host, port) {
+  serverLogger2.debug(`Starting server on ${host}:${port}...`);
+  return serve({
+    fetch: app.fetch,
+    port,
+    hostname: host
+  });
+}
+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) {
+  return async () => {
+    serverLogger2.debug("Closing HTTP server...");
+    await new Promise((resolve) => {
+      server.close(() => {
+        serverLogger2.info("HTTP server closed");
+        resolve();
+      });
+    });
+    serverLogger2.debug("Closing database connections...");
+    await closeDatabase();
+    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 {
-      serverLogger.debug("Cleaning up after initialization failure...");
-      await closeDatabase();
-      await closeRedis();
-      serverLogger.debug("Cleanup completed");
-    } catch (cleanupError) {
-      serverLogger.error("Cleanup failed", cleanupError);
+      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);
     }
-    throw error;
+  };
+}
+function registerShutdownHandlers(shutdown) {
+  process.on("SIGTERM", () => shutdown("SIGTERM"));
+  process.on("SIGINT", () => shutdown("SIGINT"));
+  process.on("uncaughtException", (error) => {
+    serverLogger2.error("Uncaught exception", error);
+    shutdown("UNCAUGHT_EXCEPTION");
+  });
+  process.on("unhandledRejection", (reason, promise) => {
+    serverLogger2.error("Unhandled promise rejection", {
+      reason,
+      promise
+    });
+    shutdown("UNHANDLED_REJECTION");
+  });
+}
+async function cleanupOnFailure() {
+  try {
+    serverLogger2.debug("Cleaning up after initialization failure...");
+    await closeDatabase();
+    await closeRedis();
+    serverLogger2.debug("Cleanup completed");
+  } catch (cleanupError) {
+    serverLogger2.error("Cleanup failed", cleanupError);
   }
 }