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

package/dist/server/index.js

@@ -1,17 +1,17 @@
-import { readFileSync, existsSync, readdirSync, statSync, mkdirSync, accessSync, constants, writeFileSync, unlinkSync, createWriteStream, renameSync } from 'fs';
-import { join, dirname, relative, basename } from 'path';
+import { env } from '@spfn/core/config';
 import { config } from 'dotenv';
-import postgres from 'postgres';
-import { drizzle } from 'drizzle-orm/postgres-js';
-import { timestamp, bigserial, pgSchema } from 'drizzle-orm/pg-core';
-import { AsyncLocalStorage } from 'async_hooks';
-import { randomUUID, randomBytes } from 'crypto';
-import { createMiddleware } from 'hono/factory';
-import { eq, and } from 'drizzle-orm';
+import { existsSync } from 'fs';
+import { resolve, join } from 'path';
 import { Hono } from 'hono';
 import { cors } from 'hono/cors';
-import { readdir, stat } from 'fs/promises';
+import { registerRoutes } from '@spfn/core/route';
+import { ErrorHandler, RequestLogger } from '@spfn/core/middleware';
+import { streamSSE } from 'hono/streaming';
+import { logger } from '@spfn/core/logger';
+import { initDatabase, getDatabase, closeDatabase } from '@spfn/core/db';
+import { initCache, getCache, closeCache } from '@spfn/core/cache';
 import { serve } from '@hono/node-server';
+import PgBoss from 'pg-boss';
 import { networkInterfaces } from 'os';
 
 var __defProp = Object.defineProperty;
@@ -24,46 +24,55 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// src/logger/types.ts
-var LOG_LEVEL_PRIORITY;
-var init_types = __esm({
-  "src/logger/types.ts"() {
-    LOG_LEVEL_PRIORITY = {
-      debug: 0,
-      info: 1,
-      warn: 2,
-      error: 3,
-      fatal: 4
-    };
-  }
-});
-
 // src/logger/formatters.ts
+var formatters_exports = {};
+__export(formatters_exports, {
+  colorizeLevel: () => colorizeLevel,
+  extractPromiseContext: () => extractPromiseContext,
+  extractQueryInfo: () => extractQueryInfo,
+  formatConsole: () => formatConsole,
+  formatContext: () => formatContext,
+  formatError: () => formatError,
+  formatJSON: () => formatJSON,
+  formatTimestamp: () => formatTimestamp,
+  formatTimestampHuman: () => formatTimestampHuman,
+  formatUnhandledRejection: () => formatUnhandledRejection,
+  maskSensitiveData: () => maskSensitiveData
+});
 function isSensitiveKey(key) {
   const lowerKey = key.toLowerCase();
   return SENSITIVE_KEYS.some((sensitive) => lowerKey.includes(sensitive));
 }
-function maskSensitiveData(data) {
+function maskSensitiveData(data, seen = /* @__PURE__ */ new WeakSet()) {
   if (data === null || data === void 0) {
     return data;
   }
-  if (Array.isArray(data)) {
-    return data.map((item) => maskSensitiveData(item));
+  if (typeof data !== "object") {
+    return data;
   }
-  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;
-      }
+  if (seen.has(data)) {
+    return "[Circular]";
+  }
+  seen.add(data);
+  if (Array.isArray(data)) {
+    return data.map((item) => maskSensitiveData(item, seen));
+  }
+  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, seen);
+    } else {
+      masked[key] = value;
     }
-    return masked;
   }
-  return data;
+  return masked;
+}
+function colorizeLevel(level) {
+  const color = COLORS[level];
+  const levelStr = level.toUpperCase().padEnd(5);
+  return `${color}${levelStr}${COLORS.reset}`;
 }
 function formatTimestamp(date) {
   return date.toISOString();
@@ -87,13 +96,26 @@ function formatError(error) {
   }
   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);
+  const timestamp = formatTimestampHuman(metadata.timestamp);
+  if (colorize) {
+    parts.push(`${COLORS.gray}[${timestamp}]${COLORS.reset}`);
+  } else {
+    parts.push(`[${timestamp}]`);
+  }
+  const pid = process.pid;
   if (colorize) {
-    parts.push(`${COLORS.gray}[${timestamp2}]${COLORS.reset}`);
+    parts.push(`${COLORS.dim}[pid=${pid}]${COLORS.reset}`);
   } else {
-    parts.push(`[${timestamp2}]`);
+    parts.push(`[pid=${pid}]`);
   }
   if (metadata.module) {
     if (colorize) {
@@ -162,6 +184,84 @@ function formatJSON(metadata) {
   }
   return JSON.stringify(obj);
 }
+function extractQueryInfo(error) {
+  const message = error.message;
+  if (!message) return null;
+  const result = {};
+  const queryMatch = message.match(/(?:Failed query:|Query:)\s*([^\n]+)/);
+  if (queryMatch) {
+    result.query = queryMatch[1].trim();
+    const tableMatch = result.query.match(/(?:UPDATE|INSERT INTO|DELETE FROM|FROM)\s+"?([a-zA-Z_][a-zA-Z0-9_]*)"?\."?([a-zA-Z_][a-zA-Z0-9_]*)"?|(?:UPDATE|INSERT INTO|DELETE FROM|FROM)\s+"?([a-zA-Z_][a-zA-Z0-9_]*)"?/i);
+    if (tableMatch) {
+      result.table = tableMatch[2] || tableMatch[3] || tableMatch[1];
+    }
+  }
+  const paramsMatch = message.match(/params:\s*(.+?)(?:\n|$)/);
+  if (paramsMatch) {
+    const paramsStr = paramsMatch[1].trim();
+    try {
+      result.params = paramsStr.split(",").map((p) => p.trim());
+    } catch (e) {
+      result.params = paramsStr;
+    }
+  }
+  return Object.keys(result).length > 0 ? result : null;
+}
+function extractPromiseContext(error) {
+  const context = {};
+  if (!error.stack) return context;
+  const stackLines = error.stack.split("\n");
+  for (let i = 1; i < stackLines.length; i++) {
+    const line = stackLines[i].trim();
+    if (line.includes("node_modules") || line.includes("node:internal")) continue;
+    const match = line.match(/at\s+(?:([a-zA-Z_$][\w$]*(?:\.[a-zA-Z_$][\w$]*)*)\s+)?\(?([^)]+):(\d+):(\d+)\)?/);
+    if (match) {
+      const [, functionName, filePath, lineNumber, columnNumber] = match;
+      const fileNameMatch = filePath.match(/([^/\\]+)$/);
+      const fileName = fileNameMatch ? fileNameMatch[1] : filePath;
+      context.file = fileName;
+      context.line = parseInt(lineNumber, 10);
+      context.column = parseInt(columnNumber, 10);
+      if (functionName) {
+        const methodMatch = functionName.match(/^(.+)\.([^.]+)$/);
+        if (methodMatch) {
+          const [, className, methodName] = methodMatch;
+          context.class = className;
+          context.method = methodName;
+          if (className.includes("Repository")) {
+            context.repository = className;
+          }
+        } else {
+          context.function = functionName;
+        }
+      }
+      break;
+    }
+  }
+  return context;
+}
+function formatUnhandledRejection(reason, promise) {
+  let error;
+  if (reason instanceof Error) {
+    error = reason;
+  } else if (typeof reason === "string") {
+    error = new Error(reason);
+  } else {
+    error = new Error(JSON.stringify(reason));
+  }
+  const context = {
+    promise: String(promise)
+  };
+  const promiseContext = extractPromiseContext(error);
+  if (Object.keys(promiseContext).length > 0) {
+    context.promiseContext = promiseContext;
+  }
+  const queryInfo = extractQueryInfo(error);
+  if (queryInfo) {
+    context.queryInfo = queryInfo;
+  }
+  return { error, context };
+}
 var SENSITIVE_KEYS, MASKED_VALUE, COLORS;
 var init_formatters = __esm({
   "src/logger/formatters.ts"() {
@@ -214,3044 +314,252 @@ var init_formatters = __esm({
     };
   }
 });
-
-// src/logger/logger.ts
-var Logger;
-var init_logger = __esm({
-  "src/logger/logger.ts"() {
-    init_types();
-    init_formatters();
-    Logger = class _Logger {
-      config;
-      module;
-      constructor(config) {
-        this.config = config;
-        this.module = config.module;
-      }
-      /**
-       * Get current log level
-       */
-      get level() {
-        return this.config.level;
-      }
-      /**
-       * Create child logger (per module)
-       */
-      child(module) {
-        return new _Logger({
-          ...this.config,
-          module
-        });
-      }
-      /**
-       * Debug log
-       */
-      debug(message, context) {
-        this.log("debug", message, void 0, context);
-      }
-      /**
-       * Info log
-       */
-      info(message, context) {
-        this.log("info", message, void 0, context);
-      }
-      warn(message, errorOrContext, context) {
-        if (errorOrContext instanceof Error) {
-          this.log("warn", message, errorOrContext, context);
-        } else {
-          this.log("warn", message, void 0, errorOrContext);
-        }
-      }
-      error(message, errorOrContext, context) {
-        if (errorOrContext instanceof Error) {
-          this.log("error", message, errorOrContext, context);
-        } else {
-          this.log("error", message, void 0, errorOrContext);
-        }
-      }
-      fatal(message, errorOrContext, context) {
-        if (errorOrContext instanceof Error) {
-          this.log("fatal", message, errorOrContext, context);
-        } else {
-          this.log("fatal", message, void 0, errorOrContext);
-        }
-      }
-      /**
-       * Log processing (internal)
-       */
-      log(level, message, error, context) {
-        if (LOG_LEVEL_PRIORITY[level] < LOG_LEVEL_PRIORITY[this.config.level]) {
-          return;
-        }
-        const metadata = {
-          timestamp: /* @__PURE__ */ new Date(),
-          level,
-          message,
-          module: this.module,
-          error,
-          // Mask sensitive information in context to prevent credential leaks
-          context: context ? maskSensitiveData(context) : void 0
-        };
-        this.processTransports(metadata);
-      }
-      /**
-       * Process Transports
-       */
-      processTransports(metadata) {
-        const promises = this.config.transports.filter((transport) => transport.enabled).map((transport) => this.safeTransportLog(transport, metadata));
-        Promise.all(promises).catch((error) => {
-          const errorMessage = error instanceof Error ? error.message : String(error);
-          process.stderr.write(`[Logger] Transport error: ${errorMessage}
-`);
-        });
-      }
-      /**
-       * Transport log (error-safe)
-       */
-      async safeTransportLog(transport, metadata) {
-        try {
-          await transport.log(metadata);
-        } catch (error) {
-          const errorMessage = error instanceof Error ? error.message : String(error);
-          process.stderr.write(`[Logger] Transport "${transport.name}" failed: ${errorMessage}
-`);
-        }
-      }
-      /**
-       * Close all Transports
-       */
-      async close() {
-        const closePromises = this.config.transports.filter((transport) => transport.close).map((transport) => transport.close());
-        await Promise.all(closePromises);
-      }
-    };
-  }
-});
-
-// src/logger/transports/console.ts
-var ConsoleTransport;
-var init_console = __esm({
-  "src/logger/transports/console.ts"() {
-    init_types();
-    init_formatters();
-    ConsoleTransport = class {
-      name = "console";
-      level;
-      enabled;
-      colorize;
-      constructor(config) {
-        this.level = config.level;
-        this.enabled = config.enabled;
-        this.colorize = config.colorize ?? true;
-      }
-      async log(metadata) {
-        if (!this.enabled) {
-          return;
-        }
-        if (LOG_LEVEL_PRIORITY[metadata.level] < LOG_LEVEL_PRIORITY[this.level]) {
-          return;
-        }
-        const message = formatConsole(metadata, this.colorize);
-        if (metadata.level === "warn" || metadata.level === "error" || metadata.level === "fatal") {
-          console.error(message);
-        } else {
-          console.log(message);
-        }
-      }
-    };
-  }
-});
-var FileTransport;
-var init_file = __esm({
-  "src/logger/transports/file.ts"() {
-    init_types();
-    init_formatters();
-    FileTransport = class {
-      name = "file";
-      level;
-      enabled;
-      logDir;
-      maxFileSize;
-      maxFiles;
-      currentStream = null;
-      currentFilename = null;
-      constructor(config) {
-        this.level = config.level;
-        this.enabled = config.enabled;
-        this.logDir = config.logDir;
-        this.maxFileSize = config.maxFileSize ?? 10 * 1024 * 1024;
-        this.maxFiles = config.maxFiles ?? 10;
-        if (!existsSync(this.logDir)) {
-          mkdirSync(this.logDir, { recursive: true });
-        }
-      }
-      async log(metadata) {
-        if (!this.enabled) {
-          return;
-        }
-        if (LOG_LEVEL_PRIORITY[metadata.level] < LOG_LEVEL_PRIORITY[this.level]) {
-          return;
-        }
-        const message = formatJSON(metadata);
-        const filename = this.getLogFilename(metadata.timestamp);
-        if (this.currentFilename !== filename) {
-          await this.rotateStream(filename);
-          await this.cleanOldFiles();
-        } else if (this.currentFilename) {
-          await this.checkAndRotateBySize();
+function loadEnvFiles() {
+  const cwd = process.cwd();
+  const nodeEnv = process.env.NODE_ENV || "development";
+  const envFiles = [
+    ".env.server.local",
+    ".env.server",
+    `.env.${nodeEnv}.local`,
+    nodeEnv !== "test" ? ".env.local" : null,
+    `.env.${nodeEnv}`,
+    ".env"
+  ].filter((file) => file !== null);
+  for (const file of envFiles) {
+    const filePath = resolve(cwd, file);
+    if (existsSync(filePath)) {
+      config({ path: filePath });
+    }
+  }
+}
+var sseLogger = logger.child("@spfn/core:sse");
+function createSSEHandler(router, config2 = {}) {
+  const {
+    pingInterval = 3e4
+    // headers: customHeaders = {},  // Reserved for future use
+  } = config2;
+  return async (c) => {
+    const eventsParam = c.req.query("events");
+    if (!eventsParam) {
+      return c.json({ error: "Missing events parameter" }, 400);
+    }
+    const requestedEvents = eventsParam.split(",").map((e) => e.trim());
+    const validEventNames = router.eventNames;
+    const invalidEvents = requestedEvents.filter((e) => !validEventNames.includes(e));
+    if (invalidEvents.length > 0) {
+      return c.json({
+        error: "Invalid event names",
+        invalidEvents,
+        validEvents: validEventNames
+      }, 400);
+    }
+    sseLogger.debug("SSE connection requested", {
+      events: requestedEvents,
+      clientIp: c.req.header("x-forwarded-for") || c.req.header("x-real-ip")
+    });
+    return streamSSE(c, async (stream) => {
+      const unsubscribes = [];
+      let messageId = 0;
+      for (const eventName of requestedEvents) {
+        const eventDef = router.events[eventName];
+        if (!eventDef) {
+          continue;
         }
-        if (this.currentStream) {
-          return new Promise((resolve, reject) => {
-            this.currentStream.write(message + "\n", "utf-8", (error) => {
-              if (error) {
-                process.stderr.write(`[FileTransport] Failed to write log: ${error.message}
-`);
-                reject(error);
-              } else {
-                resolve();
-              }
-            });
+        const unsubscribe = eventDef.subscribe((payload) => {
+          messageId++;
+          const message = {
+            event: eventName,
+            data: payload
+          };
+          sseLogger.debug("SSE sending event", {
+            event: eventName,
+            messageId
           });
-        }
-      }
-      /**
-       * 스트림 교체 (날짜 변경 시)
-       */
-      async rotateStream(filename) {
-        if (this.currentStream) {
-          await this.closeStream();
-        }
-        const filepath = join(this.logDir, filename);
-        this.currentStream = createWriteStream(filepath, {
-          flags: "a",
-          // append mode
-          encoding: "utf-8"
-        });
-        this.currentFilename = filename;
-        this.currentStream.on("error", (error) => {
-          process.stderr.write(`[FileTransport] Stream error: ${error.message}
-`);
-          this.currentStream = null;
-          this.currentFilename = null;
-        });
-      }
-      /**
-       * 현재 스트림 닫기
-       */
-      async closeStream() {
-        if (!this.currentStream) {
-          return;
-        }
-        return new Promise((resolve, reject) => {
-          this.currentStream.end((error) => {
-            if (error) {
-              reject(error);
-            } else {
-              this.currentStream = null;
-              this.currentFilename = null;
-              resolve();
-            }
+          void stream.writeSSE({
+            id: String(messageId),
+            event: eventName,
+            data: JSON.stringify(message)
           });
         });
+        unsubscribes.push(unsubscribe);
       }
-      /**
-       * 파일 크기 체크 및 크기 기반 로테이션
-       */
-      async checkAndRotateBySize() {
-        if (!this.currentFilename) {
-          return;
-        }
-        const filepath = join(this.logDir, this.currentFilename);
-        if (!existsSync(filepath)) {
-          return;
-        }
+      sseLogger.info("SSE connection established", {
+        events: requestedEvents,
+        subscriptionCount: unsubscribes.length
+      });
+      await stream.writeSSE({
+        event: "connected",
+        data: JSON.stringify({
+          subscribedEvents: requestedEvents,
+          timestamp: Date.now()
+        })
+      });
+      const pingTimer = setInterval(() => {
+        void stream.writeSSE({
+          event: "ping",
+          data: JSON.stringify({ timestamp: Date.now() })
+        });
+      }, pingInterval);
+      const abortSignal = c.req.raw.signal;
+      while (!abortSignal.aborted) {
+        await stream.sleep(pingInterval);
+      }
+      clearInterval(pingTimer);
+      unsubscribes.forEach((fn) => fn());
+      sseLogger.info("SSE connection closed", {
+        events: requestedEvents
+      });
+    }, async (err) => {
+      sseLogger.error("SSE stream error", {
+        error: err.message
+      });
+    });
+  };
+}
+function createHealthCheckHandler(detailed) {
+  return async (c) => {
+    const response = {
+      status: "ok",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    if (detailed) {
+      let dbStatus = "unknown";
+      let dbError;
+      try {
+        const db = getDatabase();
         try {
-          const stats = statSync(filepath);
-          if (stats.size >= this.maxFileSize) {
-            await this.rotateBySize();
-          }
+          await db.execute("SELECT 1");
+          dbStatus = "connected";
         } catch (error) {
-          const errorMessage = error instanceof Error ? error.message : String(error);
-          process.stderr.write(`[FileTransport] Failed to check file size: ${errorMessage}
-`);
+          dbStatus = "error";
+          dbError = error instanceof Error ? error.message : String(error);
         }
+      } catch (error) {
+        dbStatus = "not_initialized";
+        dbError = "Database not available";
       }
-      /**
-       * 크기 기반 로테이션 수행
-       * 예: 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`);
+      const redis = getCache();
+      let redisStatus = redis ? "unknown" : "not_initialized";
+      let redisError;
+      if (redis) {
         try {
-          if (existsSync(currentPath)) {
-            renameSync(currentPath, newPath);
-          }
+          await redis.ping();
+          redisStatus = "connected";
         } catch (error) {
-          const errorMessage = error instanceof Error ? error.message : String(error);
-          process.stderr.write(`[FileTransport] Failed to rotate current file: ${errorMessage}
-`);
+          redisStatus = "error";
+          redisError = error instanceof Error ? error.message : String(error);
         }
-        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}
-`);
+      response.services = {
+        database: {
+          status: dbStatus,
+          ...dbError && { error: dbError }
+        },
+        redis: {
+          status: redisStatus,
+          ...redisError && { error: redisError }
         }
-      }
-      /**
-       * 날짜별 로그 파일명 생성
-       */
-      getLogFilename(date) {
-        const year = date.getFullYear();
-        const month = String(date.getMonth() + 1).padStart(2, "0");
-        const day = String(date.getDate()).padStart(2, "0");
-        return `${year}-${month}-${day}.log`;
-      }
-      async close() {
-        await this.closeStream();
-      }
-    };
-  }
-});
-function isFileLoggingEnabled() {
-  return process.env.LOGGER_FILE_ENABLED === "true";
+      };
+      const hasErrors = dbStatus === "error" || dbStatus === "not_initialized" || redisStatus === "error";
+      response.status = hasErrors ? "degraded" : "ok";
+    }
+    const statusCode = response.status === "ok" ? 200 : 503;
+    return c.json(response, statusCode);
+  };
 }
-function getDefaultLogLevel() {
-  const isProduction = process.env.NODE_ENV === "production";
-  const isDevelopment = process.env.NODE_ENV === "development";
-  if (isDevelopment) {
-    return "debug";
-  }
-  if (isProduction) {
-    return "info";
+function applyServerTimeouts(server, timeouts) {
+  if ("timeout" in server) {
+    server.timeout = timeouts.request;
+    server.keepAliveTimeout = timeouts.keepAlive;
+    server.headersTimeout = timeouts.headers;
   }
-  return "warn";
-}
-function getConsoleConfig() {
-  const isProduction = process.env.NODE_ENV === "production";
-  return {
-    level: "debug",
-    enabled: true,
-    colorize: !isProduction
-    // Dev: colored output, Production: plain text
-  };
 }
-function getFileConfig() {
-  const isProduction = process.env.NODE_ENV === "production";
+function getTimeoutConfig(config2) {
   return {
-    level: "info",
-    enabled: isProduction,
-    // File logging in production only
-    logDir: process.env.LOG_DIR || "./logs",
-    maxFileSize: 10 * 1024 * 1024,
-    // 10MB
-    maxFiles: 10
+    request: config2?.request ?? env.SERVER_TIMEOUT,
+    keepAlive: config2?.keepAlive ?? env.SERVER_KEEPALIVE_TIMEOUT,
+    headers: config2?.headers ?? env.SERVER_HEADERS_TIMEOUT
   };
 }
-function validateDirectoryWritable(dirPath) {
-  if (!existsSync(dirPath)) {
-    try {
-      mkdirSync(dirPath, { recursive: true });
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      throw new Error(`Failed to create log directory "${dirPath}": ${errorMessage}`);
-    }
-  }
-  try {
-    accessSync(dirPath, constants.W_OK);
-  } catch {
-    throw new Error(`Log directory "${dirPath}" is not writable. Please check permissions.`);
-  }
-  const testFile = join(dirPath, ".logger-write-test");
-  try {
-    writeFileSync(testFile, "test", "utf-8");
-    unlinkSync(testFile);
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    throw new Error(`Cannot write to log directory "${dirPath}": ${errorMessage}`);
-  }
-}
-function validateFileConfig() {
-  if (!isFileLoggingEnabled()) {
-    return;
-  }
-  const logDir = process.env.LOG_DIR;
-  if (!logDir) {
-    throw new Error(
-      "LOG_DIR environment variable is required when LOGGER_FILE_ENABLED=true. Example: LOG_DIR=/var/log/myapp"
-    );
-  }
-  validateDirectoryWritable(logDir);
-}
-function validateSlackConfig() {
-  const webhookUrl = process.env.SLACK_WEBHOOK_URL;
-  if (!webhookUrl) {
-    return;
-  }
-  if (!webhookUrl.startsWith("https://hooks.slack.com/")) {
-    throw new Error(
-      `Invalid SLACK_WEBHOOK_URL: "${webhookUrl}". Slack webhook URLs must start with "https://hooks.slack.com/"`
-    );
-  }
-}
-function validateEmailConfig() {
-  const smtpHost = process.env.SMTP_HOST;
-  const smtpPort = process.env.SMTP_PORT;
-  const emailFrom = process.env.EMAIL_FROM;
-  const emailTo = process.env.EMAIL_TO;
-  const hasAnyEmailConfig = smtpHost || smtpPort || emailFrom || emailTo;
-  if (!hasAnyEmailConfig) {
-    return;
-  }
-  const missingFields = [];
-  if (!smtpHost) missingFields.push("SMTP_HOST");
-  if (!smtpPort) missingFields.push("SMTP_PORT");
-  if (!emailFrom) missingFields.push("EMAIL_FROM");
-  if (!emailTo) missingFields.push("EMAIL_TO");
-  if (missingFields.length > 0) {
-    throw new Error(
-      `Email transport configuration incomplete. Missing: ${missingFields.join(", ")}. Either set all required fields or remove all email configuration.`
-    );
-  }
-  const port = parseInt(smtpPort, 10);
-  if (isNaN(port) || port < 1 || port > 65535) {
-    throw new Error(
-      `Invalid SMTP_PORT: "${smtpPort}". Must be a number between 1 and 65535.`
-    );
-  }
-  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-  if (!emailRegex.test(emailFrom)) {
-    throw new Error(`Invalid EMAIL_FROM format: "${emailFrom}"`);
-  }
-  const recipients = emailTo.split(",").map((e) => e.trim());
-  for (const email of recipients) {
-    if (!emailRegex.test(email)) {
-      throw new Error(`Invalid email address in EMAIL_TO: "${email}"`);
-    }
-  }
-}
-function validateEnvironment() {
-  const nodeEnv = process.env.NODE_ENV;
-  if (!nodeEnv) {
-    process.stderr.write(
-      "[Logger] Warning: NODE_ENV is not set. Defaulting to test environment.\n"
-    );
-  }
-}
-function validateConfig() {
-  try {
-    validateEnvironment();
-    validateFileConfig();
-    validateSlackConfig();
-    validateEmailConfig();
-  } catch (error) {
-    if (error instanceof Error) {
-      throw new Error(`[Logger] Configuration validation failed: ${error.message}`);
-    }
-    throw error;
-  }
-}
-var init_config = __esm({
-  "src/logger/config.ts"() {
-  }
-});
-
-// src/logger/factory.ts
-function initializeTransports() {
-  const transports = [];
-  const consoleConfig = getConsoleConfig();
-  transports.push(new ConsoleTransport(consoleConfig));
-  const fileConfig = getFileConfig();
-  if (fileConfig.enabled) {
-    transports.push(new FileTransport(fileConfig));
-  }
-  return transports;
-}
-function initializeLogger() {
-  validateConfig();
-  return new Logger({
-    level: getDefaultLogLevel(),
-    transports: initializeTransports()
-  });
+function getShutdownTimeout(config2) {
+  return config2?.timeout ?? env.SHUTDOWN_TIMEOUT;
 }
-var logger;
-var init_factory = __esm({
-  "src/logger/factory.ts"() {
-    init_logger();
-    init_console();
-    init_file();
-    init_config();
-    logger = initializeLogger();
-  }
-});
-
-// src/logger/index.ts
-var init_logger2 = __esm({
-  "src/logger/index.ts"() {
-    init_factory();
-    init_logger();
-  }
-});
-
-// src/route/function-routes.ts
-var function_routes_exports = {};
-__export(function_routes_exports, {
-  discoverFunctionRoutes: () => discoverFunctionRoutes
-});
-function discoverFunctionRoutes(cwd = process.cwd()) {
-  const functions = [];
-  const nodeModulesPath = join(cwd, "node_modules");
-  try {
-    const projectPkgPath = join(cwd, "package.json");
-    const projectPkg = JSON.parse(readFileSync(projectPkgPath, "utf-8"));
-    const dependencies = {
-      ...projectPkg.dependencies,
-      ...projectPkg.devDependencies
-    };
-    for (const [packageName] of Object.entries(dependencies)) {
-      if (!packageName.startsWith("@spfn/") && !packageName.startsWith("spfn-")) {
-        continue;
-      }
-      try {
-        const pkgPath = join(nodeModulesPath, ...packageName.split("/"), "package.json");
-        const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
-        if (pkg.spfn?.routes?.dir) {
-          const { dir } = pkg.spfn.routes;
-          const prefix = pkg.spfn.prefix;
-          const packagePath = dirname(pkgPath);
-          const routesDir = join(packagePath, dir);
-          functions.push({
-            packageName,
-            routesDir,
-            packagePath,
-            prefix
-            // Include prefix in function info
-          });
-          routeLogger.debug("Discovered function routes", {
-            package: packageName,
-            dir,
-            prefix: prefix || "(none)"
-          });
-        }
-      } catch (error) {
-      }
-    }
-  } catch (error) {
-    routeLogger.warn("Failed to discover function routes", {
-      error: error instanceof Error ? error.message : "Unknown error"
-    });
-  }
-  return functions;
+function buildMiddlewareOrder(config2) {
+  const order = [];
+  const middlewareConfig = config2.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");
+  config2.use?.forEach((_, i) => order.push(`Custom[${i}]`));
+  if (config2.beforeRoutes) order.push("beforeRoutes hook");
+  order.push("Routes");
+  if (config2.afterRoutes) order.push("afterRoutes hook");
+  if (enableErrorHandler) order.push("ErrorHandler");
+  return order;
 }
-var routeLogger;
-var init_function_routes = __esm({
-  "src/route/function-routes.ts"() {
-    init_logger2();
-    routeLogger = logger.child("function-routes");
-  }
-});
-
-// src/errors/database-errors.ts
-var DatabaseError, ConnectionError, QueryError, ConstraintViolationError, TransactionError, DeadlockError, DuplicateEntryError;
-var init_database_errors = __esm({
-  "src/errors/database-errors.ts"() {
-    DatabaseError = class extends Error {
-      statusCode;
-      details;
-      timestamp;
-      constructor(message, statusCode = 500, details) {
-        super(message);
-        this.name = "DatabaseError";
-        this.statusCode = statusCode;
-        this.details = details;
-        this.timestamp = /* @__PURE__ */ new Date();
-        Error.captureStackTrace(this, this.constructor);
-      }
-      /**
-       * Serialize error for API response
-       */
-      toJSON() {
-        return {
-          name: this.name,
-          message: this.message,
-          statusCode: this.statusCode,
-          details: this.details,
-          timestamp: this.timestamp.toISOString()
-        };
-      }
-    };
-    ConnectionError = class extends DatabaseError {
-      constructor(message, details) {
-        super(message, 503, details);
-        this.name = "ConnectionError";
-      }
-    };
-    QueryError = class extends DatabaseError {
-      constructor(message, statusCode = 500, details) {
-        super(message, statusCode, details);
-        this.name = "QueryError";
-      }
-    };
-    ConstraintViolationError = class extends QueryError {
-      constructor(message, details) {
-        super(message, 400, details);
-        this.name = "ConstraintViolationError";
-      }
-    };
-    TransactionError = class extends DatabaseError {
-      constructor(message, statusCode = 500, details) {
-        super(message, statusCode, details);
-        this.name = "TransactionError";
-      }
-    };
-    DeadlockError = class extends TransactionError {
-      constructor(message, details) {
-        super(message, 409, details);
-        this.name = "DeadlockError";
-      }
-    };
-    DuplicateEntryError = class extends QueryError {
-      constructor(field, value) {
-        super(`${field} '${value}' already exists`, 409, { field, value });
-        this.name = "DuplicateEntryError";
-      }
-    };
-  }
-});
-
-// src/errors/http-errors.ts
-var init_http_errors = __esm({
-  "src/errors/http-errors.ts"() {
-  }
-});
-
-// src/errors/error-utils.ts
-var init_error_utils = __esm({
-  "src/errors/error-utils.ts"() {
-    init_database_errors();
-    init_http_errors();
-  }
-});
-
-// src/errors/index.ts
-var init_errors = __esm({
-  "src/errors/index.ts"() {
-    init_database_errors();
-    init_http_errors();
-    init_error_utils();
-  }
-});
-
-// src/env/config.ts
-var ENV_FILE_PRIORITY, TEST_ONLY_FILES;
-var init_config2 = __esm({
-  "src/env/config.ts"() {
-    ENV_FILE_PRIORITY = [
-      ".env",
-      // Base configuration (lowest priority)
-      ".env.{NODE_ENV}",
-      // Environment-specific
-      ".env.local",
-      // Local overrides (excluded in test)
-      ".env.{NODE_ENV}.local"
-      // Local environment-specific (highest priority)
-    ];
-    TEST_ONLY_FILES = [
-      ".env.test",
-      ".env.test.local"
-    ];
-  }
-});
-function buildFileList(basePath, nodeEnv) {
-  const files = [];
-  if (!nodeEnv) {
-    files.push(join(basePath, ".env"));
-    files.push(join(basePath, ".env.local"));
-    return files;
-  }
-  for (const pattern of ENV_FILE_PRIORITY) {
-    const fileName = pattern.replace("{NODE_ENV}", nodeEnv);
-    if (nodeEnv === "test" && fileName === ".env.local") {
-      continue;
-    }
-    if (nodeEnv === "local" && pattern === ".env.local") {
-      continue;
-    }
-    if (nodeEnv !== "test" && TEST_ONLY_FILES.includes(fileName)) {
-      continue;
-    }
-    files.push(join(basePath, fileName));
-  }
-  return files;
-}
-function loadSingleFile(filePath, debug) {
-  if (!existsSync(filePath)) {
-    if (debug) {
-      envLogger.debug("Environment file not found (optional)", {
-        path: filePath
-      });
-    }
-    return { success: false, parsed: {}, error: "File not found" };
-  }
-  try {
-    const result = config({ path: filePath });
-    if (result.error) {
-      envLogger.warn("Failed to parse environment file", {
-        path: filePath,
-        error: result.error.message
-      });
-      return {
-        success: false,
-        parsed: {},
-        error: result.error.message
-      };
-    }
-    const parsed = result.parsed || {};
-    if (debug) {
-      envLogger.debug("Environment file loaded successfully", {
-        path: filePath,
-        variables: Object.keys(parsed),
-        count: Object.keys(parsed).length
-      });
-    }
-    return { success: true, parsed };
-  } catch (error) {
-    const message = error instanceof Error ? error.message : "Unknown error";
-    envLogger.error("Error loading environment file", {
-      path: filePath,
-      error: message
-    });
-    return { success: false, parsed: {}, error: message };
-  }
-}
-function validateRequiredVars(required, debug) {
-  const missing = [];
-  for (const varName of required) {
-    if (!process.env[varName]) {
-      missing.push(varName);
-    }
-  }
-  if (missing.length > 0) {
-    const error = `Required environment variables missing: ${missing.join(", ")}`;
-    envLogger.error("Environment validation failed", {
-      missing,
-      required
-    });
-    throw new Error(error);
-  }
-  if (debug) {
-    envLogger.debug("Required environment variables validated", {
-      required,
-      allPresent: true
-    });
-  }
-}
-function loadEnvironment(options = {}) {
-  const {
-    basePath = process.cwd(),
-    customPaths = [],
-    debug = false,
-    nodeEnv = process.env.NODE_ENV || "",
-    required = [],
-    useCache = true
-  } = options;
-  if (useCache && environmentLoaded && cachedLoadResult) {
-    if (debug) {
-      envLogger.debug("Returning cached environment", {
-        loaded: cachedLoadResult.loaded.length,
-        variables: Object.keys(cachedLoadResult.parsed).length
-      });
-    }
-    return cachedLoadResult;
-  }
-  if (debug) {
-    envLogger.debug("Loading environment variables", {
-      basePath,
-      nodeEnv,
-      customPaths,
-      required
-    });
-  }
-  const result = {
-    success: true,
-    loaded: [],
-    failed: [],
-    parsed: {},
-    warnings: []
-  };
-  const standardFiles = buildFileList(basePath, nodeEnv);
-  const allFiles = [...standardFiles, ...customPaths];
-  if (debug) {
-    envLogger.debug("Environment files to load", {
-      standardFiles,
-      customPaths,
-      total: allFiles.length
-    });
-  }
-  const reversedFiles = [...allFiles].reverse();
-  for (const filePath of reversedFiles) {
-    const fileResult = loadSingleFile(filePath, debug);
-    if (fileResult.success) {
-      result.loaded.push(filePath);
-      Object.assign(result.parsed, fileResult.parsed);
-      if (fileResult.parsed["NODE_ENV"]) {
-        const fileName = filePath.split("/").pop() || filePath;
-        result.warnings.push(
-          `NODE_ENV found in ${fileName}. It's recommended to set NODE_ENV via CLI (e.g., 'spfn dev', 'spfn build') instead of .env files for consistent environment behavior.`
-        );
-      }
-    } else if (fileResult.error) {
-      result.failed.push({
-        path: filePath,
-        reason: fileResult.error
-      });
-    }
-  }
-  if (debug || result.loaded.length > 0) {
-    envLogger.info("Environment loading complete", {
-      loaded: result.loaded.length,
-      failed: result.failed.length,
-      variables: Object.keys(result.parsed).length,
-      files: result.loaded
-    });
-  }
-  if (required.length > 0) {
-    try {
-      validateRequiredVars(required, debug);
-    } catch (error) {
-      result.success = false;
-      result.errors = [
-        error instanceof Error ? error.message : "Validation failed"
-      ];
-      throw error;
-    }
-  }
-  if (result.warnings.length > 0) {
-    for (const warning of result.warnings) {
-      envLogger.warn(warning);
-    }
-  }
-  environmentLoaded = true;
-  cachedLoadResult = result;
-  return result;
-}
-var envLogger, environmentLoaded, cachedLoadResult;
-var init_loader = __esm({
-  "src/env/loader.ts"() {
-    init_logger2();
-    init_config2();
-    envLogger = logger.child("environment");
-    environmentLoaded = false;
-  }
-});
-
-// src/env/validator.ts
-var init_validator = __esm({
-  "src/env/validator.ts"() {
-  }
-});
-
-// src/env/index.ts
-var init_env = __esm({
-  "src/env/index.ts"() {
-    init_loader();
-    init_config2();
-    init_validator();
-  }
-});
-
-// src/db/postgres-errors.ts
-function parseUniqueViolation(message) {
-  const patterns = [
-    // Standard format: Key (field)=(value)
-    /Key \(([^)]+)\)=\(([^)]+)\)/i,
-    // With quotes: Key ("field")=('value')
-    /Key \(["']?([^)"']+)["']?\)=\(["']?([^)"']+)["']?\)/i,
-    // Alternative format
-    /Key `([^`]+)`=`([^`]+)`/i
-  ];
-  for (const pattern of patterns) {
-    const match = message.match(pattern);
-    if (match) {
-      const field = match[1].trim().replace(/["'`]/g, "");
-      const value = match[2].trim().replace(/["'`]/g, "");
-      return { field, value };
-    }
-  }
-  return null;
-}
-function fromPostgresError(error) {
-  const code = error?.code;
-  const message = error?.message || "Database error occurred";
-  switch (code) {
-    // Class 08 — Connection Exception
-    case "08000":
-    // connection_exception
-    case "08001":
-    // sqlclient_unable_to_establish_sqlconnection
-    case "08003":
-    // connection_does_not_exist
-    case "08004":
-    // sqlserver_rejected_establishment_of_sqlconnection
-    case "08006":
-    // connection_failure
-    case "08007":
-    // transaction_resolution_unknown
-    case "08P01":
-      return new ConnectionError(message, { code });
-    // Class 23 — Integrity Constraint Violation
-    case "23000":
-    // integrity_constraint_violation
-    case "23001":
-      return new ConstraintViolationError(message, { code, constraint: "integrity" });
-    case "23502":
-      return new ConstraintViolationError(message, { code, constraint: "not_null" });
-    case "23503":
-      return new ConstraintViolationError(message, { code, constraint: "foreign_key" });
-    case "23505":
-      const parsed = parseUniqueViolation(message);
-      if (parsed) {
-        return new DuplicateEntryError(parsed.field, parsed.value);
-      }
-      return new DuplicateEntryError("field", "value");
-    case "23514":
-      return new ConstraintViolationError(message, { code, constraint: "check" });
-    // Class 40 — Transaction Rollback
-    case "40000":
-    // transaction_rollback
-    case "40001":
-    // serialization_failure
-    case "40002":
-    // transaction_integrity_constraint_violation
-    case "40003":
-      return new TransactionError(message, 500, { code });
-    case "40P01":
-      return new DeadlockError(message, { code });
-    // Class 42 — Syntax Error or Access Rule Violation
-    case "42000":
-    // syntax_error_or_access_rule_violation
-    case "42601":
-    // syntax_error
-    case "42501":
-    // insufficient_privilege
-    case "42602":
-    // invalid_name
-    case "42622":
-    // name_too_long
-    case "42701":
-    // duplicate_column
-    case "42702":
-    // ambiguous_column
-    case "42703":
-    // undefined_column
-    case "42704":
-    // undefined_object
-    case "42P01":
-    // undefined_table
-    case "42P02":
-      return new QueryError(message, 400, { code });
-    // Class 53 — Insufficient Resources
-    case "53000":
-    // insufficient_resources
-    case "53100":
-    // disk_full
-    case "53200":
-    // out_of_memory
-    case "53300":
-      return new ConnectionError(message, { code });
-    // Class 57 — Operator Intervention
-    case "57000":
-    // operator_intervention
-    case "57014":
-    // query_canceled
-    case "57P01":
-    // admin_shutdown
-    case "57P02":
-    // crash_shutdown
-    case "57P03":
-      return new ConnectionError(message, { code });
-    // Default: Unknown error
-    default:
-      return new QueryError(message, 500, { code });
-  }
-}
-var init_postgres_errors = __esm({
-  "src/db/postgres-errors.ts"() {
-    init_errors();
-  }
-});
-function delay(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-async function createDatabaseConnection(connectionString, poolConfig, retryConfig) {
-  let lastError;
-  for (let attempt = 0; attempt <= retryConfig.maxRetries; attempt++) {
-    try {
-      const client = postgres(connectionString, {
-        max: poolConfig.max,
-        idle_timeout: poolConfig.idleTimeout
-      });
-      await client`SELECT 1 as test`;
-      if (attempt > 0) {
-        dbLogger.info(`Database connected successfully after ${attempt} retries`);
-      } else {
-        dbLogger.info("Database connected successfully");
-      }
-      return client;
-    } catch (error) {
-      lastError = fromPostgresError(error);
-      if (attempt < retryConfig.maxRetries) {
-        const delayMs = Math.min(
-          retryConfig.initialDelay * Math.pow(retryConfig.factor, attempt),
-          retryConfig.maxDelay
-        );
-        dbLogger.warn(
-          `Connection failed (attempt ${attempt + 1}/${retryConfig.maxRetries + 1}), retrying in ${delayMs}ms...`,
-          lastError,
-          {
-            attempt: attempt + 1,
-            maxRetries: retryConfig.maxRetries + 1,
-            delayMs
-          }
-        );
-        await delay(delayMs);
-      }
-    }
-  }
-  const errorMessage = `Failed to connect to database after ${retryConfig.maxRetries + 1} attempts: ${lastError?.message || "Unknown error"}`;
-  throw new ConnectionError(errorMessage);
-}
-async function checkConnection(client) {
-  try {
-    await client`SELECT 1 as health_check`;
-    return true;
-  } catch (error) {
-    dbLogger.error("Database health check failed", error);
-    return false;
-  }
-}
-var dbLogger;
-var init_connection = __esm({
-  "src/db/manager/connection.ts"() {
-    init_logger2();
-    init_errors();
-    init_postgres_errors();
-    dbLogger = logger.child("database");
-  }
-});
-
-// src/db/manager/config.ts
-function parseEnvNumber(key, prodDefault, devDefault) {
-  const isProduction = process.env.NODE_ENV === "production";
-  const envValue = parseInt(process.env[key] || "", 10);
-  return isNaN(envValue) ? isProduction ? prodDefault : devDefault : envValue;
-}
-function parseEnvBoolean(key, defaultValue) {
-  const value = process.env[key];
-  if (value === void 0) return defaultValue;
-  return value.toLowerCase() === "true";
-}
-function getPoolConfig(options) {
-  return {
-    max: options?.max ?? parseEnvNumber("DB_POOL_MAX", 20, 10),
-    idleTimeout: options?.idleTimeout ?? parseEnvNumber("DB_POOL_IDLE_TIMEOUT", 30, 20)
-  };
-}
-function getRetryConfig() {
-  return {
-    maxRetries: parseEnvNumber("DB_RETRY_MAX", 5, 3),
-    initialDelay: parseEnvNumber("DB_RETRY_INITIAL_DELAY", 100, 50),
-    maxDelay: parseEnvNumber("DB_RETRY_MAX_DELAY", 1e4, 5e3),
-    factor: parseEnvNumber("DB_RETRY_FACTOR", 2, 2)
-  };
-}
-function buildHealthCheckConfig(options) {
-  return {
-    enabled: options?.enabled ?? parseEnvBoolean("DB_HEALTH_CHECK_ENABLED", true),
-    interval: options?.interval ?? parseEnvNumber("DB_HEALTH_CHECK_INTERVAL", 6e4, 6e4),
-    reconnect: options?.reconnect ?? parseEnvBoolean("DB_HEALTH_CHECK_RECONNECT", true),
-    maxRetries: options?.maxRetries ?? parseEnvNumber("DB_HEALTH_CHECK_MAX_RETRIES", 3, 3),
-    retryInterval: options?.retryInterval ?? parseEnvNumber("DB_HEALTH_CHECK_RETRY_INTERVAL", 5e3, 5e3)
-  };
-}
-function buildMonitoringConfig(options) {
-  const isDevelopment = process.env.NODE_ENV !== "production";
-  return {
-    enabled: options?.enabled ?? parseEnvBoolean("DB_MONITORING_ENABLED", isDevelopment),
-    slowThreshold: options?.slowThreshold ?? parseEnvNumber("DB_MONITORING_SLOW_THRESHOLD", 1e3, 1e3),
-    logQueries: options?.logQueries ?? parseEnvBoolean("DB_MONITORING_LOG_QUERIES", false)
-  };
-}
-var init_config3 = __esm({
-  "src/db/manager/config.ts"() {
-  }
-});
-function hasDatabaseConfig() {
-  return !!(process.env.DATABASE_URL || process.env.DATABASE_WRITE_URL || process.env.DATABASE_READ_URL);
-}
-function detectDatabasePattern() {
-  if (process.env.DATABASE_WRITE_URL && process.env.DATABASE_READ_URL) {
-    return {
-      type: "write-read",
-      write: process.env.DATABASE_WRITE_URL,
-      read: process.env.DATABASE_READ_URL
-    };
-  }
-  if (process.env.DATABASE_URL && process.env.DATABASE_REPLICA_URL) {
-    return {
-      type: "legacy",
-      primary: process.env.DATABASE_URL,
-      replica: process.env.DATABASE_REPLICA_URL
-    };
-  }
-  if (process.env.DATABASE_URL) {
-    return {
-      type: "single",
-      url: process.env.DATABASE_URL
-    };
-  }
-  if (process.env.DATABASE_WRITE_URL) {
-    return {
-      type: "single",
-      url: process.env.DATABASE_WRITE_URL
-    };
-  }
-  return { type: "none" };
-}
-async function createWriteReadClients(writeUrl, readUrl, poolConfig, retryConfig) {
-  const writeClient = await createDatabaseConnection(writeUrl, poolConfig, retryConfig);
-  const readClient = await createDatabaseConnection(readUrl, poolConfig, retryConfig);
-  return {
-    write: drizzle(writeClient),
-    read: drizzle(readClient),
-    writeClient,
-    readClient
-  };
-}
-async function createSingleClient(url, poolConfig, retryConfig) {
-  const client = await createDatabaseConnection(url, poolConfig, retryConfig);
-  const db = drizzle(client);
-  return {
-    write: db,
-    read: db,
-    writeClient: client,
-    readClient: client
-  };
-}
-async function createDatabaseFromEnv(options) {
-  if (!hasDatabaseConfig()) {
-    dbLogger2.debug("No DATABASE_URL found, loading environment variables");
-    const result = loadEnvironment({
-      debug: true
-    });
-    dbLogger2.debug("Environment variables loaded", {
-      success: result.success,
-      loaded: result.loaded.length,
-      hasDatabaseUrl: !!process.env.DATABASE_URL,
-      hasWriteUrl: !!process.env.DATABASE_WRITE_URL,
-      hasReadUrl: !!process.env.DATABASE_READ_URL
-    });
-  }
-  if (!hasDatabaseConfig()) {
-    dbLogger2.warn("No database configuration found", {
-      cwd: process.cwd(),
-      nodeEnv: process.env.NODE_ENV,
-      checkedVars: ["DATABASE_URL", "DATABASE_WRITE_URL", "DATABASE_READ_URL"]
-    });
-    return { write: void 0, read: void 0 };
-  }
-  try {
-    const poolConfig = getPoolConfig(options?.pool);
-    const retryConfig = getRetryConfig();
-    const pattern = detectDatabasePattern();
-    switch (pattern.type) {
-      case "write-read":
-        dbLogger2.debug("Using write-read pattern", {
-          write: pattern.write.replace(/:[^:@]+@/, ":***@"),
-          read: pattern.read.replace(/:[^:@]+@/, ":***@")
-        });
-        return await createWriteReadClients(
-          pattern.write,
-          pattern.read,
-          poolConfig,
-          retryConfig
-        );
-      case "legacy":
-        dbLogger2.debug("Using legacy replica pattern", {
-          primary: pattern.primary.replace(/:[^:@]+@/, ":***@"),
-          replica: pattern.replica.replace(/:[^:@]+@/, ":***@")
-        });
-        return await createWriteReadClients(
-          pattern.primary,
-          pattern.replica,
-          poolConfig,
-          retryConfig
-        );
-      case "single":
-        dbLogger2.debug("Using single database pattern", {
-          url: pattern.url.replace(/:[^:@]+@/, ":***@")
-        });
-        return await createSingleClient(pattern.url, poolConfig, retryConfig);
-      case "none":
-        dbLogger2.warn("No database pattern detected");
-        return { write: void 0, read: void 0 };
-    }
-  } catch (error) {
-    const message = error instanceof Error ? error.message : "Unknown error";
-    dbLogger2.error("Failed to create database connection", {
-      error: message,
-      stage: "initialization",
-      hasWriteUrl: !!process.env.DATABASE_WRITE_URL,
-      hasReadUrl: !!process.env.DATABASE_READ_URL,
-      hasUrl: !!process.env.DATABASE_URL,
-      hasReplicaUrl: !!process.env.DATABASE_REPLICA_URL
-    });
-    throw new Error(`Database connection failed: ${message}`, { cause: error });
-  }
-}
-var dbLogger2;
-var init_factory2 = __esm({
-  "src/db/manager/factory.ts"() {
-    init_logger2();
-    init_env();
-    init_connection();
-    init_config3();
-    dbLogger2 = logger.child("database");
-  }
-});
-
-// src/db/manager/global-state.ts
-var getWriteInstance, setWriteInstance, getReadInstance, setReadInstance, getWriteClient, setWriteClient, getReadClient, setReadClient, getHealthCheckInterval, setHealthCheckInterval, setMonitoringConfig;
-var init_global_state = __esm({
-  "src/db/manager/global-state.ts"() {
-    getWriteInstance = () => globalThis.__SPFN_DB_WRITE__;
-    setWriteInstance = (instance) => {
-      globalThis.__SPFN_DB_WRITE__ = instance;
-    };
-    getReadInstance = () => globalThis.__SPFN_DB_READ__;
-    setReadInstance = (instance) => {
-      globalThis.__SPFN_DB_READ__ = instance;
-    };
-    getWriteClient = () => globalThis.__SPFN_DB_WRITE_CLIENT__;
-    setWriteClient = (client) => {
-      globalThis.__SPFN_DB_WRITE_CLIENT__ = client;
-    };
-    getReadClient = () => globalThis.__SPFN_DB_READ_CLIENT__;
-    setReadClient = (client) => {
-      globalThis.__SPFN_DB_READ_CLIENT__ = client;
-    };
-    getHealthCheckInterval = () => globalThis.__SPFN_DB_HEALTH_CHECK__;
-    setHealthCheckInterval = (interval) => {
-      globalThis.__SPFN_DB_HEALTH_CHECK__ = interval;
-    };
-    setMonitoringConfig = (config) => {
-      globalThis.__SPFN_DB_MONITORING__ = config;
-    };
-  }
-});
-
-// src/db/manager/health-check.ts
-function startHealthCheck(config, options, getDatabase2, closeDatabase2) {
-  const healthCheck = getHealthCheckInterval();
-  if (healthCheck) {
-    dbLogger3.debug("Health check already running");
-    return;
-  }
-  dbLogger3.info("Starting database health check", {
-    interval: `${config.interval}ms`,
-    reconnect: config.reconnect
-  });
-  const interval = setInterval(async () => {
-    try {
-      const write = getDatabase2("write");
-      const read = getDatabase2("read");
-      if (write) {
-        await write.execute("SELECT 1");
-      }
-      if (read && read !== write) {
-        await read.execute("SELECT 1");
-      }
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Unknown error";
-      dbLogger3.error("Database health check failed", { error: message });
-      if (config.reconnect) {
-        await attemptReconnection(config, options, closeDatabase2);
-      }
-    }
-  }, config.interval);
-  setHealthCheckInterval(interval);
-}
-async function attemptReconnection(config, options, closeDatabase2) {
-  dbLogger3.warn("Attempting database reconnection", {
-    maxRetries: config.maxRetries,
-    retryInterval: `${config.retryInterval}ms`
-  });
-  for (let attempt = 1; attempt <= config.maxRetries; attempt++) {
-    try {
-      dbLogger3.debug(`Reconnection attempt ${attempt}/${config.maxRetries}`);
-      await closeDatabase2();
-      await new Promise((resolve) => setTimeout(resolve, config.retryInterval));
-      const result = await createDatabaseFromEnv(options);
-      if (result.write) {
-        await result.write.execute("SELECT 1");
-        setWriteInstance(result.write);
-        setReadInstance(result.read);
-        setWriteClient(result.writeClient);
-        setReadClient(result.readClient);
-        dbLogger3.info("Database reconnection successful", { attempt });
-        return;
-      }
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Unknown error";
-      dbLogger3.error(`Reconnection attempt ${attempt} failed`, {
-        error: message,
-        attempt,
-        maxRetries: config.maxRetries
-      });
-      if (attempt === config.maxRetries) {
-        dbLogger3.error("Max reconnection attempts reached, giving up");
-      }
-    }
-  }
-}
-function stopHealthCheck() {
-  const healthCheck = getHealthCheckInterval();
-  if (healthCheck) {
-    clearInterval(healthCheck);
-    setHealthCheckInterval(void 0);
-    dbLogger3.info("Database health check stopped");
-  }
-}
-var dbLogger3;
-var init_health_check = __esm({
-  "src/db/manager/health-check.ts"() {
-    init_logger2();
-    init_factory2();
-    init_global_state();
-    dbLogger3 = logger.child("database");
-  }
-});
-
-// src/db/manager/manager.ts
-function getCallerInfo() {
-  try {
-    const stack = new Error().stack;
-    if (!stack) return void 0;
-    const lines = stack.split("\n");
-    for (let i = 3; i < lines.length; i++) {
-      const line = lines[i];
-      if (!line.includes("node_modules") && !line.includes("/db/manager/")) {
-        const match = line.match(/\((.+):(\d+):(\d+)\)/) || line.match(/at (.+):(\d+):(\d+)/);
-        if (match) {
-          const fullPath = match[1];
-          const parts = fullPath.split("/");
-          const srcIndex = parts.lastIndexOf("src");
-          if (srcIndex !== -1) {
-            const relativePath = parts.slice(srcIndex).join("/");
-            return `${relativePath}:${match[2]}`;
-          }
-          return `${fullPath}:${match[2]}`;
-        }
-        break;
-      }
-    }
-  } catch {
-  }
-  return void 0;
-}
-function getDatabase(type) {
-  const writeInst = getWriteInstance();
-  const readInst = getReadInstance();
-  if (process.env.DB_DEBUG_TRACE === "true") {
-    const caller = getCallerInfo();
-    dbLogger4.debug("getDatabase() called", {
-      type: type || "write",
-      hasWrite: !!writeInst,
-      hasRead: !!readInst,
-      caller
-    });
-  }
-  if (type === "read") {
-    return readInst ?? writeInst;
-  }
-  return writeInst;
-}
-function setDatabase(write, read) {
-  setWriteInstance(write);
-  setReadInstance(read ?? write);
-}
-async function initDatabase(options) {
-  const writeInst = getWriteInstance();
-  if (writeInst) {
-    dbLogger4.debug("Database already initialized");
-    return { write: writeInst, read: getReadInstance() };
-  }
-  const result = await createDatabaseFromEnv(options);
-  if (result.write) {
-    try {
-      await result.write.execute("SELECT 1");
-      if (result.read && result.read !== result.write) {
-        await result.read.execute("SELECT 1");
-      }
-      setWriteInstance(result.write);
-      setReadInstance(result.read);
-      setWriteClient(result.writeClient);
-      setReadClient(result.readClient);
-      const hasReplica = result.read && result.read !== result.write;
-      dbLogger4.info(
-        hasReplica ? "Database connected (Primary + Replica)" : "Database connected"
-      );
-      const healthCheckConfig = buildHealthCheckConfig(options?.healthCheck);
-      if (healthCheckConfig.enabled) {
-        startHealthCheck(healthCheckConfig, options, getDatabase, closeDatabase);
-      }
-      const monConfig = buildMonitoringConfig(options?.monitoring);
-      setMonitoringConfig(monConfig);
-      if (monConfig.enabled) {
-        dbLogger4.info("Database query monitoring enabled", {
-          slowThreshold: `${monConfig.slowThreshold}ms`,
-          logQueries: monConfig.logQueries
-        });
-      }
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Unknown error";
-      dbLogger4.error("Database connection failed", { error: message });
-      await closeDatabase();
-      throw new Error(`Database connection test failed: ${message}`, { cause: error });
-    }
-  } else {
-    dbLogger4.warn("No database configuration found");
-    dbLogger4.warn("Set DATABASE_URL environment variable to enable database");
-  }
-  return { write: getWriteInstance(), read: getReadInstance() };
-}
-async function closeDatabase() {
-  const writeInst = getWriteInstance();
-  const readInst = getReadInstance();
-  if (!writeInst && !readInst) {
-    dbLogger4.debug("No database connections to close");
-    return;
-  }
-  stopHealthCheck();
-  try {
-    const closePromises = [];
-    const writeC = getWriteClient();
-    if (writeC) {
-      dbLogger4.debug("Closing write connection...");
-      closePromises.push(
-        writeC.end({ timeout: 5 }).then(() => dbLogger4.debug("Write connection closed")).catch((err) => dbLogger4.error("Error closing write connection", err))
-      );
-    }
-    const readC = getReadClient();
-    if (readC && readC !== writeC) {
-      dbLogger4.debug("Closing read connection...");
-      closePromises.push(
-        readC.end({ timeout: 5 }).then(() => dbLogger4.debug("Read connection closed")).catch((err) => dbLogger4.error("Error closing read connection", err))
-      );
-    }
-    await Promise.all(closePromises);
-    dbLogger4.info("All database connections closed");
-  } catch (error) {
-    dbLogger4.error("Error during database cleanup", error);
-    throw error;
-  } finally {
-    setWriteInstance(void 0);
-    setReadInstance(void 0);
-    setWriteClient(void 0);
-    setReadClient(void 0);
-    setMonitoringConfig(void 0);
-  }
-}
-function getDatabaseInfo() {
-  const writeInst = getWriteInstance();
-  const readInst = getReadInstance();
-  return {
-    hasWrite: !!writeInst,
-    hasRead: !!readInst,
-    isReplica: !!(readInst && readInst !== writeInst)
-  };
-}
-var dbLogger4;
-var init_manager = __esm({
-  "src/db/manager/manager.ts"() {
-    init_logger2();
-    init_factory2();
-    init_config3();
-    init_global_state();
-    init_health_check();
-    dbLogger4 = logger.child("database");
-  }
-});
-
-// src/db/manager/index.ts
-var init_manager2 = __esm({
-  "src/db/manager/index.ts"() {
-    init_factory2();
-    init_manager();
-    init_connection();
-  }
-});
-function expandGlobPattern(pattern) {
-  if (!pattern.includes("*")) {
-    return existsSync(pattern) ? [pattern] : [];
-  }
-  const files = [];
-  if (pattern.includes("**")) {
-    const [baseDir, ...rest] = pattern.split("**");
-    const extension = rest.join("").replace(/[\/\\]\*\./g, "").trim();
-    const scanRecursive = (dir) => {
-      if (!existsSync(dir)) return;
-      try {
-        const entries = readdirSync(dir);
-        for (const entry of entries) {
-          const fullPath = join(dir, entry);
-          try {
-            const stat2 = statSync(fullPath);
-            if (stat2.isDirectory()) {
-              scanRecursive(fullPath);
-            } else if (stat2.isFile()) {
-              if (!extension || fullPath.endsWith(extension)) {
-                files.push(fullPath);
-              }
-            }
-          } catch {
-          }
-        }
-      } catch {
-      }
-    };
-    scanRecursive(baseDir.trim() || ".");
-  } else if (pattern.includes("*")) {
-    const dir = dirname(pattern);
-    const filePattern = basename(pattern);
-    if (!existsSync(dir)) return [];
-    try {
-      const entries = readdirSync(dir);
-      for (const entry of entries) {
-        const fullPath = join(dir, entry);
-        try {
-          const stat2 = statSync(fullPath);
-          if (stat2.isFile()) {
-            if (filePattern === "*" || filePattern.startsWith("*.") && entry.endsWith(filePattern.slice(1))) {
-              files.push(fullPath);
-            }
-          }
-        } catch {
-        }
-      }
-    } catch {
-    }
-  }
-  return files;
-}
-function discoverPackageSchemas(cwd) {
-  const schemas = [];
-  const nodeModulesPath = join(cwd, "node_modules");
-  if (!existsSync(nodeModulesPath)) {
-    return schemas;
-  }
-  const projectPkgPath = join(cwd, "package.json");
-  let directDeps = /* @__PURE__ */ new Set();
-  if (existsSync(projectPkgPath)) {
-    try {
-      const projectPkg = JSON.parse(readFileSync(projectPkgPath, "utf-8"));
-      directDeps = /* @__PURE__ */ new Set([
-        ...Object.keys(projectPkg.dependencies || {}),
-        ...Object.keys(projectPkg.devDependencies || {})
-      ]);
-    } catch (error) {
-    }
-  }
-  const checkPackage = (_pkgName, pkgPath) => {
-    const pkgJsonPath = join(pkgPath, "package.json");
-    if (!existsSync(pkgJsonPath)) return;
-    try {
-      const pkgJson = JSON.parse(readFileSync(pkgJsonPath, "utf-8"));
-      if (pkgJson.spfn?.schemas) {
-        const packageSchemas = Array.isArray(pkgJson.spfn.schemas) ? pkgJson.spfn.schemas : [pkgJson.spfn.schemas];
-        for (const schema of packageSchemas) {
-          const absolutePath = join(pkgPath, schema);
-          const expandedFiles = expandGlobPattern(absolutePath);
-          const schemaFiles = expandedFiles.filter(
-            (file) => !file.endsWith("/index.js") && !file.endsWith("/index.ts") && !file.endsWith("/index.mjs") && !file.endsWith("\\index.js") && !file.endsWith("\\index.ts") && !file.endsWith("\\index.mjs")
-          );
-          schemas.push(...schemaFiles);
-        }
-      }
-    } catch (error) {
-    }
-  };
-  const spfnDir = join(nodeModulesPath, "@spfn");
-  if (existsSync(spfnDir)) {
-    try {
-      const spfnPackages = readdirSync(spfnDir);
-      for (const pkg of spfnPackages) {
-        checkPackage(`@spfn/${pkg}`, join(spfnDir, pkg));
-      }
-    } catch (error) {
-    }
-  }
-  for (const depName of directDeps) {
-    if (depName.startsWith("@spfn/")) continue;
-    const pkgPath = depName.startsWith("@") ? join(nodeModulesPath, ...depName.split("/")) : join(nodeModulesPath, depName);
-    checkPackage(depName, pkgPath);
-  }
-  return schemas;
-}
-function detectDialect(url) {
-  if (url.startsWith("postgres://") || url.startsWith("postgresql://")) {
-    return "postgresql";
-  }
-  if (url.startsWith("mysql://")) {
-    return "mysql";
-  }
-  if (url.startsWith("sqlite://") || url.includes(".db") || url.includes(".sqlite")) {
-    return "sqlite";
-  }
-  throw new Error(
-    `Unsupported database URL format: ${url}. Supported: postgresql://, mysql://, sqlite://`
-  );
-}
-function getDrizzleConfig(options = {}) {
-  const databaseUrl = options.databaseUrl ?? process.env.DATABASE_URL;
-  if (!databaseUrl) {
-    throw new Error(
-      "DATABASE_URL is required. Set it in .env or pass it to getDrizzleConfig()"
-    );
-  }
-  const dialect = options.dialect ?? detectDialect(databaseUrl);
-  const out = options.out ?? "./src/server/drizzle";
-  if (options.packageFilter) {
-    const packageSchemas2 = options.disablePackageDiscovery ? [] : discoverPackageSchemas(options.cwd ?? process.cwd());
-    const filteredSchemas = packageSchemas2.filter(
-      (schemaPath) => schemaPath.includes(`node_modules/${options.packageFilter}/`)
-    );
-    if (filteredSchemas.length === 0) {
-      throw new Error(
-        `No schemas found for package ${options.packageFilter}. Make sure the package is installed and has "spfn.schemas" in package.json.`
-      );
-    }
-    const schema2 = filteredSchemas.length === 1 ? filteredSchemas[0] : filteredSchemas;
-    return {
-      schema: schema2,
-      out,
-      dialect,
-      dbCredentials: getDbCredentials(dialect, databaseUrl)
-    };
-  }
-  const userSchema = options.schema ?? "./src/server/entities/**/*.ts";
-  const userSchemas = Array.isArray(userSchema) ? userSchema : [userSchema];
-  const packageSchemas = options.disablePackageDiscovery ? [] : discoverPackageSchemas(options.cwd ?? process.cwd());
-  const allSchemas = [...userSchemas, ...packageSchemas];
-  const schema = allSchemas.length === 1 ? allSchemas[0] : allSchemas;
-  return {
-    schema,
-    out,
-    dialect,
-    dbCredentials: getDbCredentials(dialect, databaseUrl)
-  };
-}
-function getDbCredentials(dialect, url) {
-  switch (dialect) {
-    case "postgresql":
-    case "mysql":
-      return { url };
-    case "sqlite":
-      const dbPath = url.replace("sqlite://", "").replace("sqlite:", "");
-      return { url: dbPath };
-    default:
-      throw new Error(`Unsupported dialect: ${dialect}`);
-  }
-}
-function generateDrizzleConfigFile(options = {}) {
-  const config = getDrizzleConfig(options);
-  const schemaValue = Array.isArray(config.schema) ? `[
-        ${config.schema.map((s) => `'${s}'`).join(",\n        ")}
-    ]` : `'${config.schema}'`;
-  return `import { defineConfig } from 'drizzle-kit';
-
-export default defineConfig({
-    schema: ${schemaValue},
-    out: '${config.out}',
-    dialect: '${config.dialect}',
-    dbCredentials: ${JSON.stringify(config.dbCredentials, null, 4)},
-});
-`;
-}
-var init_config_generator = __esm({
-  "src/db/manager/config-generator.ts"() {
-  }
-});
-function id() {
-  return bigserial("id", { mode: "number" }).primaryKey();
-}
-function timestamps(options) {
-  const updatedAtColumn = timestamp("updated_at", { withTimezone: true, mode: "date" }).defaultNow().notNull();
-  if (options?.autoUpdate) {
-    updatedAtColumn.__autoUpdate = true;
-  }
-  return {
-    createdAt: timestamp("created_at", { withTimezone: true, mode: "date" }).defaultNow().notNull(),
-    updatedAt: updatedAtColumn
-  };
-}
-function foreignKey(name, reference, options) {
-  return bigserial(`${name}_id`, { mode: "number" }).notNull().references(reference, { onDelete: options?.onDelete ?? "cascade" });
-}
-function optionalForeignKey(name, reference, options) {
-  return bigserial(`${name}_id`, { mode: "number" }).references(reference, { onDelete: options?.onDelete ?? "set null" });
-}
-var init_helpers = __esm({
-  "src/db/schema/helpers.ts"() {
-  }
-});
-
-// src/db/schema/index.ts
-var init_schema = __esm({
-  "src/db/schema/index.ts"() {
-    init_helpers();
-  }
-});
-function createFunctionSchema(packageName) {
-  const schemaName = packageNameToSchema(packageName);
-  return pgSchema(schemaName);
-}
-function packageNameToSchema(packageName) {
-  return packageName.replace("@", "").replace("/", "_").replace(/-/g, "_");
-}
-function getSchemaInfo(packageName) {
-  const isScoped = packageName.startsWith("@");
-  const scope = isScoped ? packageName.split("/")[0].substring(1) : null;
-  const schemaName = packageNameToSchema(packageName);
-  return {
-    schemaName,
-    isScoped,
-    scope
-  };
-}
-var init_schema_helper = __esm({
-  "src/db/schema-helper.ts"() {
-  }
-});
-function getTransactionContext() {
-  return asyncContext.getStore() ?? null;
-}
-function getTransaction() {
-  const context = getTransactionContext();
-  return context?.tx ?? null;
-}
-function runWithTransaction(tx, txId, callback) {
-  const existingContext = getTransactionContext();
-  const newLevel = existingContext ? existingContext.level + 1 : 1;
-  if (existingContext) {
-    txLogger.info("Nested transaction started (SAVEPOINT)", {
-      outerTxId: existingContext.txId,
-      innerTxId: txId,
-      level: newLevel
-    });
-  } else {
-    txLogger.debug("Root transaction context set", { txId, level: newLevel });
-  }
-  return asyncContext.run({ tx, txId, level: newLevel }, callback);
-}
-var txLogger, asyncContext;
-var init_context = __esm({
-  "src/db/transaction/context.ts"() {
-    init_logger2();
-    txLogger = logger.child("transaction");
-    asyncContext = new AsyncLocalStorage();
-  }
-});
-function Transactional(options = {}) {
-  const defaultTimeout = parseInt(process.env.TRANSACTION_TIMEOUT || "30000", 10);
-  const {
-    slowThreshold = 1e3,
-    enableLogging = true,
-    timeout = defaultTimeout
-  } = options;
-  const txLogger2 = logger.child("transaction");
-  return createMiddleware(async (c, next) => {
-    const txId = `tx_${randomUUID()}`;
-    const startTime = Date.now();
-    const route = `${c.req.method} ${c.req.path}`;
-    if (enableLogging) {
-      txLogger2.debug("Transaction started", { txId, route });
-    }
-    try {
-      const writeDb = getDatabase("write");
-      if (!writeDb) {
-        throw new TransactionError(
-          "Database not initialized. Cannot start transaction.",
-          500,
-          { txId, route }
-        );
-      }
-      const transactionPromise = writeDb.transaction(async (tx) => {
-        await runWithTransaction(tx, txId, async () => {
-          await next();
-          const contextWithError = c;
-          if (contextWithError.error) {
-            throw contextWithError.error;
-          }
-        });
-      });
-      if (timeout > 0) {
-        const timeoutPromise = new Promise((_, reject) => {
-          setTimeout(() => {
-            reject(
-              new TransactionError(
-                `Transaction timeout after ${timeout}ms`,
-                500,
-                {
-                  txId,
-                  route,
-                  timeout: `${timeout}ms`
-                }
-              )
-            );
-          }, timeout);
-        });
-        await Promise.race([transactionPromise, timeoutPromise]);
-      } else {
-        await transactionPromise;
-      }
-      const duration = Date.now() - startTime;
-      if (enableLogging) {
-        if (duration >= slowThreshold) {
-          txLogger2.warn("Slow transaction committed", {
-            txId,
-            route,
-            duration: `${duration}ms`,
-            threshold: `${slowThreshold}ms`
-          });
-        } else {
-          txLogger2.debug("Transaction committed", {
-            txId,
-            route,
-            duration: `${duration}ms`
-          });
-        }
-      }
-    } catch (error) {
-      const duration = Date.now() - startTime;
-      const customError = error instanceof TransactionError ? error : fromPostgresError(error);
-      if (enableLogging) {
-        txLogger2.error("Transaction rolled back", {
-          txId,
-          route,
-          duration: `${duration}ms`,
-          error: customError.message,
-          errorType: customError.name
-        });
-      }
-      throw customError;
-    }
-  });
-}
-var init_middleware = __esm({
-  "src/db/transaction/middleware.ts"() {
-    init_logger2();
-    init_manager2();
-    init_context();
-    init_errors();
-    init_postgres_errors();
-  }
-});
-
-// src/db/transaction/index.ts
-var init_transaction = __esm({
-  "src/db/transaction/index.ts"() {
-    init_context();
-    init_middleware();
-  }
-});
-function isSQLWrapper(value) {
-  return value && typeof value === "object" && "queryChunks" in value;
-}
-function buildWhereFromObject(table, where) {
-  const entries = Object.entries(where).filter(([_, value]) => value !== void 0);
-  if (entries.length === 0) return void 0;
-  const conditions = entries.map(
-    ([key, value]) => eq(table[key], value)
-  );
-  return conditions.length === 1 ? conditions[0] : and(...conditions);
-}
-async function findOne(table, where) {
-  const db = getDatabase("read");
-  if (!db) {
-    throw new Error("Database not initialized. Call initDatabase() first.");
-  }
-  const whereClause = isSQLWrapper(where) ? where : where ? buildWhereFromObject(table, where) : void 0;
-  if (!whereClause) {
-    throw new Error("findOne requires at least one where condition");
-  }
-  const results = await db.select().from(table).where(whereClause).limit(1);
-  return results[0] ?? null;
-}
-async function findMany(table, options) {
-  const db = getDatabase("read");
-  if (!db) {
-    throw new Error("Database not initialized. Call initDatabase() first.");
-  }
-  let query = db.select().from(table);
-  if (options?.where) {
-    const whereClause = isSQLWrapper(options.where) ? options.where : options.where ? buildWhereFromObject(table, options.where) : void 0;
-    if (whereClause) {
-      query = query.where(whereClause);
-    }
-  }
-  if (options?.orderBy) {
-    const orderByArray = Array.isArray(options.orderBy) ? options.orderBy : [options.orderBy];
-    query = query.orderBy(...orderByArray);
-  }
-  if (options?.limit) {
-    query = query.limit(options.limit);
-  }
-  if (options?.offset) {
-    query = query.offset(options.offset);
-  }
-  return query;
-}
-async function create(table, data) {
-  const db = getDatabase("write");
-  if (!db) {
-    throw new Error("Database not initialized. Call initDatabase() first.");
-  }
-  const [result] = await db.insert(table).values(data).returning();
-  return result;
-}
-async function createMany(table, data) {
-  const db = getDatabase("write");
-  if (!db) {
-    throw new Error("Database not initialized. Call initDatabase() first.");
-  }
-  const results = await db.insert(table).values(data).returning();
-  return results;
-}
-async function upsert(table, data, options) {
-  const db = getDatabase("write");
-  if (!db) {
-    throw new Error("Database not initialized. Call initDatabase() first.");
-  }
-  const [result] = await db.insert(table).values(data).onConflictDoUpdate({
-    target: options.target,
-    set: options.set || data
-  }).returning();
-  return result;
-}
-async function updateOne(table, where, data) {
-  const db = getDatabase("write");
-  if (!db) {
-    throw new Error("Database not initialized. Call initDatabase() first.");
-  }
-  const whereClause = isSQLWrapper(where) ? where : where ? buildWhereFromObject(table, where) : void 0;
-  if (!whereClause) {
-    throw new Error("updateOne requires at least one where condition");
-  }
-  const [result] = await db.update(table).set(data).where(whereClause).returning();
-  return result ?? null;
-}
-async function updateMany(table, where, data) {
-  const db = getDatabase("write");
-  if (!db) {
-    throw new Error("Database not initialized. Call initDatabase() first.");
-  }
-  const whereClause = isSQLWrapper(where) ? where : where ? buildWhereFromObject(table, where) : void 0;
-  if (!whereClause) {
-    throw new Error("updateMany requires at least one where condition");
-  }
-  const results = await db.update(table).set(data).where(whereClause).returning();
-  return results;
-}
-async function deleteOne(table, where) {
-  const db = getDatabase("write");
-  if (!db) {
-    throw new Error("Database not initialized. Call initDatabase() first.");
-  }
-  const whereClause = isSQLWrapper(where) ? where : where ? buildWhereFromObject(table, where) : void 0;
-  if (!whereClause) {
-    throw new Error("deleteOne requires at least one where condition");
-  }
-  const [result] = await db.delete(table).where(whereClause).returning();
-  return result ?? null;
-}
-async function deleteMany(table, where) {
-  const db = getDatabase("write");
-  if (!db) {
-    throw new Error("Database not initialized. Call initDatabase() first.");
-  }
-  const whereClause = isSQLWrapper(where) ? where : where ? buildWhereFromObject(table, where) : void 0;
-  if (!whereClause) {
-    throw new Error("deleteMany requires at least one where condition");
-  }
-  const results = await db.delete(table).where(whereClause).returning();
-  return results;
-}
-async function count(table, where) {
-  const db = getDatabase("read");
-  if (!db) {
-    throw new Error("Database not initialized. Call initDatabase() first.");
-  }
-  let query = db.select().from(table);
-  if (where) {
-    const whereClause = isSQLWrapper(where) ? where : where ? buildWhereFromObject(table, where) : void 0;
-    if (whereClause) {
-      query = query.where(whereClause);
-    }
-  }
-  const results = await query;
-  return results.length;
-}
-var init_helpers2 = __esm({
-  "src/db/helpers.ts"() {
-    init_manager2();
-  }
-});
-
-// src/db/index.ts
-var db_exports = {};
-__export(db_exports, {
-  Transactional: () => Transactional,
-  checkConnection: () => checkConnection,
-  closeDatabase: () => closeDatabase,
-  count: () => count,
-  create: () => create,
-  createDatabaseConnection: () => createDatabaseConnection,
-  createDatabaseFromEnv: () => createDatabaseFromEnv,
-  createFunctionSchema: () => createFunctionSchema,
-  createMany: () => createMany,
-  deleteMany: () => deleteMany,
-  deleteOne: () => deleteOne,
-  detectDialect: () => detectDialect,
-  findMany: () => findMany,
-  findOne: () => findOne,
-  foreignKey: () => foreignKey,
-  fromPostgresError: () => fromPostgresError,
-  generateDrizzleConfigFile: () => generateDrizzleConfigFile,
-  getDatabase: () => getDatabase,
-  getDatabaseInfo: () => getDatabaseInfo,
-  getDrizzleConfig: () => getDrizzleConfig,
-  getSchemaInfo: () => getSchemaInfo,
-  getTransaction: () => getTransaction,
-  id: () => id,
-  initDatabase: () => initDatabase,
-  optionalForeignKey: () => optionalForeignKey,
-  packageNameToSchema: () => packageNameToSchema,
-  runWithTransaction: () => runWithTransaction,
-  setDatabase: () => setDatabase,
-  timestamps: () => timestamps,
-  updateMany: () => updateMany,
-  updateOne: () => updateOne,
-  upsert: () => upsert
-});
-var init_db = __esm({
-  "src/db/index.ts"() {
-    init_manager2();
-    init_config_generator();
-    init_schema();
-    init_schema_helper();
-    init_transaction();
-    init_postgres_errors();
-    init_helpers2();
-  }
-});
-
-// src/cache/cache-factory.ts
-function hasCacheConfig() {
-  return !!// Modern (Valkey/Cache)
-  (process.env.VALKEY_URL || process.env.CACHE_URL || process.env.VALKEY_WRITE_URL || process.env.VALKEY_READ_URL || process.env.CACHE_WRITE_URL || process.env.CACHE_READ_URL || process.env.VALKEY_SENTINEL_HOSTS || process.env.VALKEY_CLUSTER_NODES || // Legacy (Redis - backward compatibility)
-  process.env.REDIS_URL || process.env.REDIS_WRITE_URL || process.env.REDIS_READ_URL || process.env.REDIS_SENTINEL_HOSTS || process.env.REDIS_CLUSTER_NODES);
-}
-function getEnv(valkeyKey, cacheKey, redisKey) {
-  return process.env[valkeyKey] || process.env[cacheKey] || process.env[redisKey];
-}
-function createClient(RedisClient, url) {
-  const options = {};
-  if (url.startsWith("rediss://") || url.startsWith("valkeys://")) {
-    const rejectUnauthorized = getEnv(
-      "VALKEY_TLS_REJECT_UNAUTHORIZED",
-      "CACHE_TLS_REJECT_UNAUTHORIZED",
-      "REDIS_TLS_REJECT_UNAUTHORIZED"
-    );
-    options.tls = {
-      rejectUnauthorized: rejectUnauthorized !== "false"
-    };
-  }
-  return new RedisClient(url, options);
-}
-async function createCacheFromEnv() {
-  if (!hasCacheConfig()) {
-    cacheLogger.info("No cache configuration found - running without cache");
-    return { write: void 0, read: void 0 };
-  }
-  try {
-    const ioredis = await import('ioredis');
-    const RedisClient = ioredis.default;
-    const singleUrl = getEnv("VALKEY_URL", "CACHE_URL", "REDIS_URL");
-    const writeUrl = getEnv("VALKEY_WRITE_URL", "CACHE_WRITE_URL", "REDIS_WRITE_URL");
-    const readUrl = getEnv("VALKEY_READ_URL", "CACHE_READ_URL", "REDIS_READ_URL");
-    const clusterNodes = getEnv("VALKEY_CLUSTER_NODES", "CACHE_CLUSTER_NODES", "REDIS_CLUSTER_NODES");
-    const sentinelHosts = getEnv("VALKEY_SENTINEL_HOSTS", "CACHE_SENTINEL_HOSTS", "REDIS_SENTINEL_HOSTS");
-    const masterName = getEnv("VALKEY_MASTER_NAME", "CACHE_MASTER_NAME", "REDIS_MASTER_NAME");
-    const password = getEnv("VALKEY_PASSWORD", "CACHE_PASSWORD", "REDIS_PASSWORD");
-    if (singleUrl && !writeUrl && !readUrl && !clusterNodes) {
-      const client = createClient(RedisClient, singleUrl);
-      cacheLogger.debug("Created single cache instance", { url: singleUrl.replace(/:[^:@]+@/, ":***@") });
-      return { write: client, read: client };
-    }
-    if (writeUrl && readUrl) {
-      const write = createClient(RedisClient, writeUrl);
-      const read = createClient(RedisClient, readUrl);
-      cacheLogger.debug("Created master-replica cache instances");
-      return { write, read };
-    }
-    if (sentinelHosts && masterName) {
-      const sentinels = sentinelHosts.split(",").map((host) => {
-        const [hostname, port] = host.trim().split(":");
-        return { host: hostname, port: Number(port) || 26379 };
-      });
-      const options = {
-        sentinels,
-        name: masterName,
-        password
-      };
-      const client = new RedisClient(options);
-      cacheLogger.debug("Created sentinel cache instance", { masterName, sentinels: sentinels.length });
-      return { write: client, read: client };
-    }
-    if (clusterNodes) {
-      const nodes = clusterNodes.split(",").map((node) => {
-        const [host, port] = node.trim().split(":");
-        return { host, port: Number(port) || 6379 };
-      });
-      const clusterOptions = {
-        redisOptions: {
-          password
-        }
-      };
-      const cluster = new RedisClient.Cluster(nodes, clusterOptions);
-      cacheLogger.debug("Created cluster cache instance", { nodes: nodes.length });
-      return { write: cluster, read: cluster };
-    }
-    if (singleUrl) {
-      const client = createClient(RedisClient, singleUrl);
-      cacheLogger.debug("Created cache instance (fallback)", { url: singleUrl.replace(/:[^:@]+@/, ":***@") });
-      return { write: client, read: client };
-    }
-    cacheLogger.info("No valid cache configuration found - running without cache");
-    return { write: void 0, read: void 0 };
-  } catch (error) {
-    if (error instanceof Error) {
-      if (error.message.includes("Cannot find module")) {
-        cacheLogger.warn(
-          "Cache client library not installed",
-          error,
-          {
-            suggestion: "Install ioredis to enable cache: pnpm install ioredis",
-            mode: "disabled"
-          }
-        );
-      } else {
-        cacheLogger.warn(
-          "Failed to create cache client",
-          error,
-          { mode: "disabled" }
-        );
-      }
-    } else {
-      cacheLogger.warn(
-        "Failed to create cache client",
-        { error: String(error), mode: "disabled" }
-      );
-    }
-    return { write: void 0, read: void 0 };
-  }
-}
-async function createSingleCacheFromEnv() {
-  const { write } = await createCacheFromEnv();
-  return write;
-}
-var cacheLogger;
-var init_cache_factory = __esm({
-  "src/cache/cache-factory.ts"() {
-    init_logger2();
-    cacheLogger = logger.child("cache");
-  }
-});
-
-// src/cache/cache-manager.ts
-function getCache() {
-  return writeInstance;
-}
-function getCacheRead() {
-  return readInstance ?? writeInstance;
-}
-function isCacheDisabled() {
-  return isDisabled;
-}
-function setCache(write, read) {
-  writeInstance = write;
-  readInstance = read ?? write;
-  isDisabled = !write;
-}
-async function initCache() {
-  if (writeInstance) {
-    return { write: writeInstance, read: readInstance, disabled: isDisabled };
-  }
-  const { write, read } = await createCacheFromEnv();
-  if (write) {
-    try {
-      await write.ping();
-      if (read && read !== write) {
-        await read.ping();
-      }
-      writeInstance = write;
-      readInstance = read;
-      isDisabled = false;
-      const hasReplica = read && read !== write;
-      cacheLogger2.info(
-        hasReplica ? "Cache connected (Master-Replica)" : "Cache connected",
-        { mode: "enabled" }
-      );
-      return { write: writeInstance, read: readInstance, disabled: false };
-    } catch (error) {
-      cacheLogger2.error(
-        "Cache connection failed - running in disabled mode",
-        error instanceof Error ? error : new Error(String(error)),
-        { mode: "disabled" }
-      );
-      try {
-        await write.quit();
-        if (read && read !== write) {
-          await read.quit();
-        }
-      } catch {
-      }
-      isDisabled = true;
-      return { write: void 0, read: void 0, disabled: true };
-    }
-  }
-  isDisabled = true;
-  cacheLogger2.info("Cache disabled - no configuration or library not installed", { mode: "disabled" });
-  return { write: void 0, read: void 0, disabled: true };
-}
-async function closeCache() {
-  if (isDisabled) {
-    cacheLogger2.debug("Cache already disabled, nothing to close");
-    return;
-  }
-  const closePromises = [];
-  if (writeInstance) {
-    closePromises.push(
-      writeInstance.quit().catch((err) => {
-        cacheLogger2.error("Error closing cache write instance", err);
-      })
-    );
-  }
-  if (readInstance && readInstance !== writeInstance) {
-    closePromises.push(
-      readInstance.quit().catch((err) => {
-        cacheLogger2.error("Error closing cache read instance", err);
-      })
-    );
-  }
-  await Promise.all(closePromises);
-  writeInstance = void 0;
-  readInstance = void 0;
-  isDisabled = true;
-  cacheLogger2.info("Cache connections closed", { mode: "disabled" });
-}
-function getCacheInfo() {
-  return {
-    hasWrite: !!writeInstance,
-    hasRead: !!readInstance,
-    isReplica: !!(readInstance && readInstance !== writeInstance),
-    disabled: isDisabled
-  };
-}
-var cacheLogger2, writeInstance, readInstance, isDisabled, getRedis, getRedisRead, setRedis, initRedis, closeRedis, getRedisInfo;
-var init_cache_manager = __esm({
-  "src/cache/cache-manager.ts"() {
-    init_cache_factory();
-    init_logger2();
-    cacheLogger2 = logger.child("cache");
-    isDisabled = false;
-    getRedis = getCache;
-    getRedisRead = getCacheRead;
-    setRedis = setCache;
-    initRedis = initCache;
-    closeRedis = closeCache;
-    getRedisInfo = getCacheInfo;
-  }
-});
-
-// src/cache/index.ts
-var cache_exports = {};
-__export(cache_exports, {
-  closeCache: () => closeCache,
-  closeRedis: () => closeRedis,
-  createCacheFromEnv: () => createCacheFromEnv,
-  createRedisFromEnv: () => createCacheFromEnv,
-  createSingleCacheFromEnv: () => createSingleCacheFromEnv,
-  createSingleRedisFromEnv: () => createSingleCacheFromEnv,
-  getCache: () => getCache,
-  getCacheInfo: () => getCacheInfo,
-  getCacheRead: () => getCacheRead,
-  getRedis: () => getRedis,
-  getRedisInfo: () => getRedisInfo,
-  getRedisRead: () => getRedisRead,
-  initCache: () => initCache,
-  initRedis: () => initRedis,
-  isCacheDisabled: () => isCacheDisabled,
-  setCache: () => setCache,
-  setRedis: () => setRedis
-});
-var init_cache = __esm({
-  "src/cache/index.ts"() {
-    init_cache_factory();
-    init_cache_manager();
-    init_cache_manager();
-    init_cache_factory();
-  }
-});
-
-// src/route/auto-loader.ts
-init_logger2();
-var routeLogger2 = logger.child("route");
-var AutoRouteLoader = class {
-  constructor(routesDir, debug = false, middlewares = []) {
-    this.routesDir = routesDir;
-    this.debug = debug;
-    this.middlewares = middlewares;
-  }
-  routes = [];
-  debug;
-  middlewares;
-  async load(app) {
-    const startTime = Date.now();
-    const files = await this.scanFiles(this.routesDir);
-    if (files.length === 0) {
-      routeLogger2.warn("No route files found");
-      return this.getStats();
-    }
-    let failureCount = 0;
-    for (const file of files) {
-      const success = await this.loadRoute(app, file);
-      if (success) ; else {
-        failureCount++;
-      }
-    }
-    const elapsed = Date.now() - startTime;
-    const stats = this.getStats();
-    if (this.debug) {
-      this.logStats(stats, elapsed);
-    }
-    if (failureCount > 0) {
-      routeLogger2.warn("Some routes failed to load", { failureCount });
-    }
-    return stats;
-  }
-  /**
-   * Load routes from an external directory (e.g., from SPFN function packages)
-   * Reads package.json spfn.prefix and mounts routes under that prefix
-   *
-   * @param app - Hono app instance
-   * @param routesDir - Directory containing route handlers
-   * @param packageName - Name of the package (for logging)
-   * @param prefix - Optional prefix to mount routes under (from package.json spfn.prefix)
-   * @returns Route statistics
-   */
-  async loadExternalRoutes(app, routesDir, packageName, prefix) {
-    const startTime = Date.now();
-    const tempRoutesDir = this.routesDir;
-    this.routesDir = routesDir;
-    const files = await this.scanFiles(routesDir);
-    if (files.length === 0) {
-      routeLogger2.warn("No route files found", { dir: routesDir, package: packageName });
-      this.routesDir = tempRoutesDir;
-      return this.getStats();
-    }
-    let successCount = 0;
-    let failureCount = 0;
-    for (const file of files) {
-      const success = await this.loadRoute(app, file, prefix);
-      if (success) {
-        successCount++;
-      } else {
-        failureCount++;
-      }
-    }
-    const elapsed = Date.now() - startTime;
-    if (this.debug) {
-      routeLogger2.info("External routes loaded", {
-        package: packageName,
-        prefix: prefix || "/",
-        total: successCount,
-        failed: failureCount,
-        elapsed: `${elapsed}ms`
-      });
-    }
-    this.routesDir = tempRoutesDir;
-    return this.getStats();
-  }
-  getStats() {
-    const stats = {
-      total: this.routes.length,
-      byPriority: { static: 0, dynamic: 0, catchAll: 0 },
-      byTag: {},
-      routes: this.routes
-    };
-    for (const route of this.routes) {
-      if (route.priority === 1) stats.byPriority.static++;
-      else if (route.priority === 2) stats.byPriority.dynamic++;
-      else if (route.priority === 3) stats.byPriority.catchAll++;
-      if (route.meta?.tags) {
-        for (const tag of route.meta.tags) {
-          stats.byTag[tag] = (stats.byTag[tag] || 0) + 1;
-        }
-      }
-    }
-    return stats;
-  }
-  async scanFiles(dir, files = []) {
-    const entries = await readdir(dir);
-    for (const entry of entries) {
-      const fullPath = join(dir, entry);
-      const fileStat = await stat(fullPath);
-      if (fileStat.isDirectory()) {
-        await this.scanFiles(fullPath, files);
-      } else if (this.isValidRouteFile(entry)) {
-        files.push(fullPath);
-      }
-    }
-    return files;
-  }
-  isValidRouteFile(fileName) {
-    return fileName === "index.ts" || fileName === "index.js" || fileName === "index.mjs";
-  }
-  async loadRoute(app, absolutePath, prefix) {
-    const relativePath = relative(this.routesDir, absolutePath);
-    try {
-      const module = await import(absolutePath);
-      if (!this.validateModule(module, relativePath)) {
-        return false;
-      }
-      const hasContractMetas = module.default._contractMetas && module.default._contractMetas.size > 0;
-      if (!hasContractMetas) {
-        routeLogger2.error("Route must use contract-based routing", {
-          file: relativePath,
-          hint: "Export contracts using satisfies RouteContract and use app.bind()"
-        });
-        return false;
-      }
-      const contractPaths = this.extractContractPaths(module);
-      if (prefix) {
-        const invalidPaths = contractPaths.filter((path) => !path.startsWith(prefix));
-        if (invalidPaths.length > 0) {
-          routeLogger2.error("Contract paths must include the package prefix", {
-            file: relativePath,
-            prefix,
-            invalidPaths,
-            hint: `Contract paths should start with "${prefix}". Example: path: "${prefix}/labels"`
-          });
-          return false;
-        }
-      }
-      this.registerContractBasedMiddlewares(app, contractPaths, module);
-      app.route("/", module.default);
-      contractPaths.forEach((path) => {
-        this.routes.push({
-          path,
-          // Use contract path as-is (already includes prefix)
-          file: relativePath,
-          meta: module.meta,
-          priority: this.calculateContractPriority(path)
-        });
-        if (this.debug) {
-          const icon = path.includes("*") ? "\u2B50" : path.includes(":") ? "\u{1F538}" : "\u{1F539}";
-          routeLogger2.debug(`Registered route: ${path}`, { icon, file: relativePath });
-        }
-      });
-      return true;
-    } catch (error) {
-      this.categorizeAndLogError(error, relativePath);
-      return false;
-    }
-  }
-  extractContractPaths(module) {
-    const paths = /* @__PURE__ */ new Set();
-    if (module.default._contractMetas) {
-      for (const key of module.default._contractMetas.keys()) {
-        const path = key.split(" ")[1];
-        if (path) {
-          paths.add(path);
-        }
-      }
-    }
-    return Array.from(paths);
-  }
-  calculateContractPriority(path) {
-    if (path.includes("*")) return 3;
-    if (path.includes(":")) return 2;
-    return 1;
-  }
-  validateModule(module, relativePath) {
-    if (!module.default) {
-      routeLogger2.error("Route must export Hono instance as default", { file: relativePath });
-      return false;
-    }
-    if (typeof module.default.route !== "function") {
-      routeLogger2.error("Default export is not a Hono instance", { file: relativePath });
-      return false;
-    }
-    return true;
-  }
-  registerContractBasedMiddlewares(app, contractPaths, module) {
-    app.use("*", (c, next) => {
-      const method = c.req.method;
-      const requestPath = new URL(c.req.url).pathname;
-      const key = `${method} ${requestPath}`;
-      const meta = module.default._contractMetas?.get(key);
-      if (meta?.skipMiddlewares) {
-        c.set("_skipMiddlewares", meta.skipMiddlewares);
-      }
-      return next();
-    });
-    for (const contractPath of contractPaths) {
-      const middlewarePath = contractPath === "/" ? "/*" : `${contractPath}/*`;
-      for (const middleware of this.middlewares) {
-        app.use(middlewarePath, async (c, next) => {
-          const skipList = c.get("_skipMiddlewares") || [];
-          if (skipList.includes(middleware.name)) {
-            return next();
-          }
-          return middleware.handler(c, next);
-        });
-      }
-    }
-  }
-  categorizeAndLogError(error, relativePath) {
-    const message = error.message;
-    const stack = error.stack;
-    if (message.includes("Cannot find module") || message.includes("MODULE_NOT_FOUND")) {
-      routeLogger2.error("Missing dependency", {
-        file: relativePath,
-        error: message,
-        hint: "Run: npm install"
-      });
-    } else if (message.includes("SyntaxError") || stack?.includes("SyntaxError")) {
-      routeLogger2.error("Syntax error", {
-        file: relativePath,
-        error: message,
-        ...this.debug && stack && {
-          stack: stack.split("\n").slice(0, 5).join("\n")
-        }
-      });
-    } else if (message.includes("Unexpected token")) {
-      routeLogger2.error("Parse error", {
-        file: relativePath,
-        error: message,
-        hint: "Check for syntax errors or invalid TypeScript"
-      });
-    } else {
-      routeLogger2.error("Route loading failed", {
-        file: relativePath,
-        error: message,
-        ...this.debug && stack && { stack }
-      });
-    }
-  }
-  logStats(stats, elapsed) {
-    const tagCounts = Object.entries(stats.byTag).map(([tag, count2]) => `${tag}(${count2})`).join(", ");
-    routeLogger2.info("Routes loaded successfully", {
-      total: stats.total,
-      priority: {
-        static: stats.byPriority.static,
-        dynamic: stats.byPriority.dynamic,
-        catchAll: stats.byPriority.catchAll
-      },
-      ...tagCounts && { tags: tagCounts },
-      elapsed: `${elapsed}ms`
-    });
-  }
-};
-async function loadRoutes(app, options) {
-  const routesDir = options?.routesDir ?? join(process.cwd(), "src", "server", "routes");
-  const debug = options?.debug ?? false;
-  const middlewares = options?.middlewares ?? [];
-  const includeFunctionRoutes = options?.includeFunctionRoutes ?? true;
-  const loader = new AutoRouteLoader(routesDir, debug, middlewares);
-  const stats = await loader.load(app);
-  if (includeFunctionRoutes) {
-    const { discoverFunctionRoutes: discoverFunctionRoutes2 } = await Promise.resolve().then(() => (init_function_routes(), function_routes_exports));
-    const functionRoutes = discoverFunctionRoutes2();
-    if (functionRoutes.length > 0) {
-      routeLogger2.info("Loading function routes", { count: functionRoutes.length });
-      for (const func of functionRoutes) {
-        try {
-          await loader.loadExternalRoutes(app, func.routesDir, func.packageName, func.prefix);
-          routeLogger2.info("Function routes loaded", {
-            package: func.packageName,
-            routesDir: func.routesDir,
-            prefix: func.prefix || "/"
-          });
-        } catch (error) {
-          routeLogger2.error("Failed to load function routes", {
-            package: func.packageName,
-            error: error instanceof Error ? error.message : "Unknown error"
-          });
-        }
-      }
-    }
-  }
-  return stats;
-}
-
-// src/route/bind.ts
-init_errors();
-init_logger2();
-
-// src/middleware/error-handler.ts
-init_logger2();
-var errorLogger = logger.child("error-handler");
-function ErrorHandler(options = {}) {
-  const {
-    includeStack = process.env.NODE_ENV !== "production",
-    enableLogging = true
-  } = options;
-  return (err, c) => {
-    const errorWithCode = err;
-    const statusCode = errorWithCode.statusCode || 500;
-    const errorType = err.name || "Error";
-    if (enableLogging) {
-      const logLevel = statusCode >= 500 ? "error" : "warn";
-      const logData = {
-        type: errorType,
-        message: err.message,
-        statusCode,
-        path: c.req.path,
-        method: c.req.method
-      };
-      if (errorWithCode.details) {
-        logData.details = errorWithCode.details;
-      }
-      if (statusCode >= 500 && includeStack) {
-        logData.stack = err.stack;
-      }
-      errorLogger[logLevel]("Error occurred", logData);
-    }
-    const response = {
-      success: false,
-      error: {
-        message: err.message || "Internal Server Error",
-        type: errorType,
-        statusCode
-      }
-    };
-    if (errorWithCode.details) {
-      response.error.details = errorWithCode.details;
-    }
-    if (includeStack) {
-      response.error.stack = err.stack;
-    }
-    return c.json(response, statusCode);
-  };
-}
-
-// src/middleware/request-logger.ts
-init_logger2();
-var DEFAULT_CONFIG = {
-  excludePaths: ["/health", "/ping", "/favicon.ico"],
-  sensitiveFields: ["password", "token", "apiKey", "secret", "authorization"],
-  slowRequestThreshold: 1e3
-};
-function generateRequestId() {
-  const timestamp2 = Date.now();
-  const randomPart = randomBytes(6).toString("hex");
-  return `req_${timestamp2}_${randomPart}`;
-}
-function maskSensitiveData2(obj, sensitiveFields, seen = /* @__PURE__ */ new WeakSet()) {
-  if (!obj || typeof obj !== "object") return obj;
-  if (seen.has(obj)) return "[Circular]";
-  seen.add(obj);
-  const lowerFields = sensitiveFields.map((f) => f.toLowerCase());
-  const masked = Array.isArray(obj) ? [...obj] : { ...obj };
-  for (const key in masked) {
-    const lowerKey = key.toLowerCase();
-    if (lowerFields.some((field) => lowerKey.includes(field))) {
-      masked[key] = "***MASKED***";
-    } else if (typeof masked[key] === "object" && masked[key] !== null) {
-      masked[key] = maskSensitiveData2(masked[key], sensitiveFields, seen);
-    }
-  }
-  return masked;
-}
-function RequestLogger(config) {
-  const cfg = { ...DEFAULT_CONFIG, ...config };
-  const apiLogger = logger.child("api");
-  return async (c, next) => {
-    const path = new URL(c.req.url).pathname;
-    if (cfg.excludePaths.includes(path)) {
-      return next();
-    }
-    const requestId = generateRequestId();
-    c.set("requestId", requestId);
-    const method = c.req.method;
-    const userAgent = c.req.header("user-agent");
-    const ip = c.req.header("x-forwarded-for") || c.req.header("x-real-ip") || "unknown";
-    const startTime = Date.now();
-    apiLogger.info("Request received", {
-      requestId,
-      method,
-      path,
-      ip,
-      userAgent
-    });
-    try {
-      await next();
-      const duration = Date.now() - startTime;
-      const status = c.res.status;
-      const logData = {
-        requestId,
-        method,
-        path,
-        status,
-        duration
-      };
-      const isSlowRequest = duration >= cfg.slowRequestThreshold;
-      if (isSlowRequest) {
-        logData.slow = true;
-      }
-      if (status >= 400) {
-        try {
-          const responseBody = await c.res.clone().json();
-          logData.response = responseBody;
-        } catch {
-        }
-        if (["POST", "PUT", "PATCH"].includes(method)) {
-          try {
-            const requestBody = await c.req.json();
-            logData.request = maskSensitiveData2(requestBody, cfg.sensitiveFields);
-          } catch {
-          }
-        }
-      }
-      const logLevel = status >= 500 ? "error" : status >= 400 ? "warn" : "info";
-      apiLogger[logLevel]("Request completed", logData);
-    } catch (error) {
-      const duration = Date.now() - startTime;
-      apiLogger.error("Request failed", error, {
-        requestId,
-        method,
-        path,
-        duration
-      });
-      throw error;
-    }
-  };
-}
-
-// src/server/create-server.ts
-init_logger2();
-
-// src/server/helpers.ts
-function createHealthCheckHandler(detailed) {
-  return async (c) => {
-    const response = {
-      status: "ok",
-      timestamp: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    if (detailed) {
-      const { getDatabase: getDatabase2 } = await Promise.resolve().then(() => (init_db(), db_exports));
-      const { getRedis: getRedis2 } = await Promise.resolve().then(() => (init_cache(), cache_exports));
-      const db = getDatabase2();
-      let dbStatus = "disconnected";
-      let dbError;
-      if (db) {
-        try {
-          await db.execute("SELECT 1");
-          dbStatus = "connected";
-        } catch (error) {
-          dbStatus = "error";
-          dbError = error instanceof Error ? error.message : String(error);
-        }
-      }
-      const redis = getRedis2();
-      let redisStatus = "disconnected";
-      let redisError;
-      if (redis) {
-        try {
-          await redis.ping();
-          redisStatus = "connected";
-        } catch (error) {
-          redisStatus = "error";
-          redisError = error instanceof Error ? error.message : String(error);
-        }
-      }
-      response.services = {
-        database: {
-          status: dbStatus,
-          ...dbError && { error: dbError }
-        },
-        redis: {
-          status: redisStatus,
-          ...redisError && { error: redisError }
-        }
-      };
-      const hasErrors = dbStatus === "error" || redisStatus === "error";
-      response.status = hasErrors ? "degraded" : "ok";
-    }
-    const statusCode = response.status === "ok" ? 200 : 503;
-    return c.json(response, statusCode);
-  };
-}
-function applyServerTimeouts(server, timeouts) {
-  if ("timeout" in server) {
-    server.timeout = timeouts.request;
-    server.keepAliveTimeout = timeouts.keepAlive;
-    server.headersTimeout = timeouts.headers;
-  }
-}
-function getTimeoutConfig(config) {
-  return {
-    request: config?.request ?? (parseInt(process.env.SERVER_TIMEOUT || "", 10) || 12e4),
-    keepAlive: config?.keepAlive ?? (parseInt(process.env.SERVER_KEEPALIVE_TIMEOUT || "", 10) || 65e3),
-    headers: config?.headers ?? (parseInt(process.env.SERVER_HEADERS_TIMEOUT || "", 10) || 6e4)
-  };
-}
-function getShutdownTimeout(config) {
-  return config?.timeout ?? (parseInt(process.env.SHUTDOWN_TIMEOUT || "", 10) || 3e4);
-}
-function buildMiddlewareOrder(config) {
-  const order = [];
-  const middlewareConfig = config.middleware ?? {};
-  const enableLogger = middlewareConfig.logger !== false;
-  const enableCors = middlewareConfig.cors !== false;
-  const enableErrorHandler = middlewareConfig.errorHandler !== false;
-  if (enableLogger) order.push("RequestLogger");
-  if (enableCors) order.push("CORS");
-  config.use?.forEach((_, i) => order.push(`Custom[${i}]`));
-  if (config.beforeRoutes) order.push("beforeRoutes hook");
-  order.push("Routes");
-  if (config.afterRoutes) order.push("afterRoutes hook");
-  if (enableErrorHandler) order.push("ErrorHandler");
-  return order;
-}
-function buildStartupConfig(config, timeouts) {
-  const middlewareConfig = config.middleware ?? {};
-  const healthCheckConfig = config.healthCheck ?? {};
-  const healthCheckEnabled = healthCheckConfig.enabled !== false;
-  const healthCheckPath = healthCheckConfig.path ?? "/health";
-  const healthCheckDetailed = healthCheckConfig.detailed ?? process.env.NODE_ENV === "development";
-  return {
-    middleware: {
-      logger: middlewareConfig.logger !== false,
-      cors: middlewareConfig.cors !== false,
-      errorHandler: middlewareConfig.errorHandler !== false,
-      custom: config.use?.length ?? 0
-    },
-    healthCheck: healthCheckEnabled ? {
-      enabled: true,
-      path: healthCheckPath,
-      detailed: healthCheckDetailed
-    } : { enabled: false },
-    hooks: {
-      beforeRoutes: !!config.beforeRoutes,
-      afterRoutes: !!config.afterRoutes
-    },
-    timeout: {
-      request: `${timeouts.request}ms`,
-      keepAlive: `${timeouts.keepAlive}ms`,
-      headers: `${timeouts.headers}ms`
-    },
-    shutdown: {
-      timeout: `${config.shutdown?.timeout ?? 3e4}ms`
-    }
-  };
-}
-
-// src/server/plugin-discovery.ts
-init_logger2();
-var pluginLogger = logger.child("plugin");
-async function discoverPlugins(cwd = process.cwd()) {
-  const plugins = [];
-  const nodeModulesPath = join(cwd, "node_modules");
-  try {
-    const projectPkgPath = join(cwd, "package.json");
-    if (!existsSync(projectPkgPath)) {
-      pluginLogger.debug("No package.json found, skipping plugin discovery");
-      return plugins;
-    }
-    const projectPkg = JSON.parse(readFileSync(projectPkgPath, "utf-8"));
-    const dependencies = {
-      ...projectPkg.dependencies,
-      ...projectPkg.devDependencies
-    };
-    for (const [packageName] of Object.entries(dependencies)) {
-      if (!packageName.startsWith("@spfn/")) {
-        continue;
-      }
-      try {
-        const plugin = await loadPluginFromPackage(packageName, nodeModulesPath);
-        if (plugin) {
-          plugins.push(plugin);
-          pluginLogger.info("Plugin discovered", {
-            name: plugin.name,
-            hooks: getPluginHookNames(plugin)
-          });
-        }
-      } catch (error) {
-        pluginLogger.debug("Failed to load plugin", {
-          package: packageName,
-          error: error instanceof Error ? error.message : "Unknown error"
-        });
-      }
-    }
-  } catch (error) {
-    pluginLogger.warn("Plugin discovery failed", {
-      error: error instanceof Error ? error.message : "Unknown error"
-    });
-  }
-  return plugins;
-}
-async function loadPluginFromPackage(packageName, nodeModulesPath) {
-  const pkgPath = join(nodeModulesPath, ...packageName.split("/"), "package.json");
-  if (!existsSync(pkgPath)) {
-    return null;
-  }
-  const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
-  const packageDir = dirname(pkgPath);
-  const mainEntry = pkg.main || "dist/index.js";
-  const mainPath = join(packageDir, mainEntry);
-  if (!existsSync(mainPath)) {
-    return null;
-  }
-  try {
-    const module = await import(mainPath);
-    if (module.spfnPlugin && isValidPlugin(module.spfnPlugin)) {
-      return module.spfnPlugin;
-    }
-    return null;
-  } catch (error) {
-    return null;
-  }
-}
-function isValidPlugin(plugin) {
-  return plugin && typeof plugin === "object" && typeof plugin.name === "string" && (typeof plugin.afterInfrastructure === "function" || typeof plugin.beforeRoutes === "function" || typeof plugin.afterRoutes === "function" || typeof plugin.afterStart === "function" || typeof plugin.beforeShutdown === "function");
-}
-function getPluginHookNames(plugin) {
-  const hooks = [];
-  if (plugin.afterInfrastructure) hooks.push("afterInfrastructure");
-  if (plugin.beforeRoutes) hooks.push("beforeRoutes");
-  if (plugin.afterRoutes) hooks.push("afterRoutes");
-  if (plugin.afterStart) hooks.push("afterStart");
-  if (plugin.beforeShutdown) hooks.push("beforeShutdown");
-  return hooks;
-}
-async function executePluginHooks(plugins, hookName, ...args) {
-  for (const plugin of plugins) {
-    const hook = plugin[hookName];
-    if (typeof hook === "function") {
-      try {
-        pluginLogger.debug("Executing plugin hook", {
-          plugin: plugin.name,
-          hook: hookName
-        });
-        await hook(...args);
-      } catch (error) {
-        pluginLogger.error("Plugin hook failed", {
-          plugin: plugin.name,
-          hook: hookName,
-          error: error instanceof Error ? error.message : "Unknown error"
-        });
-        throw new Error(
-          `Plugin ${plugin.name} failed in ${hookName} hook: ${error instanceof Error ? error.message : "Unknown error"}`
-        );
-      }
+function buildStartupConfig(config2, timeouts) {
+  const middlewareConfig = config2.middleware ?? {};
+  const healthCheckConfig = config2.healthCheck ?? {};
+  const healthCheckEnabled = healthCheckConfig.enabled !== false;
+  const healthCheckPath = healthCheckConfig.path ?? "/health";
+  const healthCheckDetailed = healthCheckConfig.detailed ?? env.NODE_ENV === "development";
+  return {
+    middleware: {
+      logger: middlewareConfig.logger !== false,
+      cors: middlewareConfig.cors !== false,
+      errorHandler: middlewareConfig.errorHandler !== false,
+      custom: config2.use?.length ?? 0
+    },
+    healthCheck: healthCheckEnabled ? {
+      enabled: true,
+      path: healthCheckPath,
+      detailed: healthCheckDetailed
+    } : { enabled: false },
+    hooks: {
+      beforeRoutes: !!config2.beforeRoutes,
+      afterRoutes: !!config2.afterRoutes
+    },
+    timeout: {
+      request: `${timeouts.request}ms`,
+      keepAlive: `${timeouts.keepAlive}ms`,
+      headers: `${timeouts.headers}ms`
+    },
+    shutdown: {
+      timeout: `${config2.shutdown?.timeout ?? env.SHUTDOWN_TIMEOUT}ms`
     }
-  }
+  };
 }
+var serverLogger = logger.child("@spfn/core:server");
 
 // src/server/create-server.ts
-var serverLogger = logger.child("server");
-async function createServer(config, plugins = []) {
+async function createServer(config2) {
   const cwd = process.cwd();
   const appPath = join(cwd, "src", "server", "app.ts");
-  const appJsPath = join(cwd, "src", "server", "app.js");
+  const appJsPath = join(cwd, "src", "server", "app");
   if (existsSync(appPath) || existsSync(appJsPath)) {
-    return await loadCustomApp(appPath, appJsPath, config, plugins);
+    return await loadCustomApp(appPath, appJsPath, config2);
   }
-  return await createAutoConfiguredApp(config, plugins);
+  return await createAutoConfiguredApp(config2);
 }
-async function loadCustomApp(appPath, appJsPath, config, plugins = []) {
-  const appModule = await (existsSync(appPath) ? import(appPath) : import(appJsPath));
+async function loadCustomApp(appPath, appJsPath, config2) {
+  const actualPath = existsSync(appPath) ? appPath : appJsPath;
+  const appModule = await import(actualPath);
   const appFactory = appModule.default;
   if (!appFactory) {
     throw new Error("app.ts must export a default function that returns a Hono app");
   }
   const app = await appFactory();
-  await executePluginHooks(plugins, "beforeRoutes", app);
-  const debug = config?.debug ?? process.env.NODE_ENV === "development";
-  await loadRoutes(app, { routesDir: config?.routesPath, debug });
-  await executePluginHooks(plugins, "afterRoutes", app);
+  if (config2?.routes) {
+    const routes = registerRoutes(app, config2.routes, config2.middlewares);
+    logRegisteredRoutes(routes, config2?.debug ?? false);
+  }
   return app;
 }
-async function createAutoConfiguredApp(config, plugins = []) {
+async function createAutoConfiguredApp(config2) {
   const app = new Hono();
-  const middlewareConfig = config?.middleware ?? {};
+  const middlewareConfig = config2?.middleware ?? {};
   const enableLogger = middlewareConfig.logger !== false;
   const enableCors = middlewareConfig.cors !== false;
   const enableErrorHandler = middlewareConfig.errorHandler !== false;
@@ -3261,29 +569,31 @@ async function createAutoConfiguredApp(config, plugins = []) {
       await next();
     });
   }
-  applyDefaultMiddleware(app, config, enableLogger, enableCors);
-  config?.use?.forEach((mw) => app.use("*", mw));
-  registerHealthCheckEndpoint(app, config);
-  await executeBeforeRoutesHook(app, config);
-  await executePluginHooks(plugins, "beforeRoutes", app);
-  await loadAppRoutes(app, config);
-  await executeAfterRoutesHook(app, config);
-  await executePluginHooks(plugins, "afterRoutes", app);
+  applyDefaultMiddleware(app, config2, enableLogger, enableCors);
+  if (Array.isArray(config2?.use)) {
+    config2.use.forEach((mw) => app.use("*", mw));
+  }
+  registerHealthCheckEndpoint(app, config2);
+  await executeBeforeRoutesHook(app, config2);
+  await loadAppRoutes(app, config2);
+  registerSSEEndpoint(app, config2);
+  await executeAfterRoutesHook(app, config2);
   if (enableErrorHandler) {
     app.onError(ErrorHandler());
   }
   return app;
 }
-function applyDefaultMiddleware(app, config, enableLogger, enableCors) {
+function applyDefaultMiddleware(app, config2, enableLogger, enableCors) {
   if (enableLogger) {
     app.use("*", RequestLogger());
   }
-  if (enableCors && config?.cors !== false) {
-    app.use("*", cors(config?.cors));
+  if (enableCors) {
+    const corsOptions = config2?.cors !== false ? config2?.cors : void 0;
+    app.use("*", cors(corsOptions));
   }
 }
-function registerHealthCheckEndpoint(app, config) {
-  const healthCheckConfig = config?.healthCheck ?? {};
+function registerHealthCheckEndpoint(app, config2) {
+  const healthCheckConfig = config2?.healthCheck ?? {};
   const healthCheckEnabled = healthCheckConfig.enabled !== false;
   const healthCheckPath = healthCheckConfig.path ?? "/health";
   const healthCheckDetailed = healthCheckConfig.detailed ?? process.env.NODE_ENV === "development";
@@ -3292,41 +602,255 @@ function registerHealthCheckEndpoint(app, config) {
     serverLogger.debug(`Health check endpoint enabled at ${healthCheckPath}`);
   }
 }
-async function executeBeforeRoutesHook(app, config) {
-  if (!config?.lifecycle?.beforeRoutes) {
+async function executeBeforeRoutesHook(app, config2) {
+  if (config2?.lifecycle?.beforeRoutes) {
+    await config2.lifecycle.beforeRoutes(app);
+  }
+}
+async function loadAppRoutes(app, config2) {
+  const debug = isDebugMode(config2);
+  if (config2?.routes) {
+    const routes = registerRoutes(app, config2.routes, config2.middlewares);
+    logRegisteredRoutes(routes, debug);
+  } else if (debug) {
+    serverLogger.warn("\u26A0\uFE0F  No routes configured. Use defineServerConfig().routes() to register routes.");
+  }
+}
+function logRegisteredRoutes(routes, debug) {
+  if (routes.length === 0) {
+    if (debug) {
+      serverLogger.warn("\u26A0\uFE0F  No routes registered");
+    }
     return;
   }
-  try {
-    await config.lifecycle.beforeRoutes(app);
-  } catch (error) {
-    serverLogger.error("beforeRoutes hook failed", error);
-    throw new Error("Server initialization failed in beforeRoutes hook");
+  const sortedRoutes = [...routes].sort((a, b) => a.path.localeCompare(b.path));
+  const maxMethodLen = Math.max(...sortedRoutes.map((r) => r.method.length));
+  const routeLines = sortedRoutes.map(
+    (r) => `  ${r.method.padEnd(maxMethodLen)}  ${r.path}`
+  ).join("\n");
+  serverLogger.info(`\u2713 Routes registered (${routes.length}):
+${routeLines}`);
+}
+async function executeAfterRoutesHook(app, config2) {
+  if (config2?.lifecycle?.afterRoutes) {
+    await config2.lifecycle.afterRoutes(app);
+  }
+}
+function registerSSEEndpoint(app, config2) {
+  if (!config2?.events) {
+    return;
+  }
+  const eventsConfig = config2.eventsConfig ?? {};
+  const path = eventsConfig.path ?? "/events/stream";
+  const debug = isDebugMode(config2);
+  app.get(path, createSSEHandler(config2.events, eventsConfig));
+  if (debug) {
+    const eventNames = config2.events.eventNames;
+    serverLogger.info(`\u2713 SSE endpoint registered at ${path}`, {
+      events: eventNames
+    });
   }
 }
-async function loadAppRoutes(app, config) {
-  const debug = config?.debug ?? process.env.NODE_ENV === "development";
-  await loadRoutes(app, {
-    routesDir: config?.routesPath,
-    debug,
-    middlewares: config?.middlewares
+function isDebugMode(config2) {
+  return config2?.debug ?? process.env.NODE_ENV === "development";
+}
+var jobLogger = logger.child("@spfn/core:job");
+var bossInstance = null;
+var bossConfig = null;
+async function initBoss(options) {
+  if (bossInstance) {
+    jobLogger.warn("pg-boss already initialized, returning existing instance");
+    return bossInstance;
+  }
+  jobLogger.info("Initializing pg-boss...");
+  bossConfig = options;
+  const pgBossOptions = {
+    connectionString: options.connectionString,
+    schema: options.schema ?? "spfn_queue",
+    maintenanceIntervalSeconds: options.maintenanceIntervalSeconds ?? 120
+  };
+  if (options.monitorIntervalSeconds !== void 0 && options.monitorIntervalSeconds >= 1) {
+    pgBossOptions.monitorIntervalSeconds = options.monitorIntervalSeconds;
+  }
+  bossInstance = new PgBoss(pgBossOptions);
+  bossInstance.on("error", (error) => {
+    jobLogger.error("pg-boss error:", error);
   });
+  await bossInstance.start();
+  jobLogger.info("pg-boss started successfully");
+  return bossInstance;
 }
-async function executeAfterRoutesHook(app, config) {
-  if (!config?.lifecycle?.afterRoutes) {
+function getBoss() {
+  return bossInstance;
+}
+async function stopBoss() {
+  if (!bossInstance) {
     return;
   }
+  jobLogger.info("Stopping pg-boss...");
   try {
-    await config.lifecycle.afterRoutes(app);
+    await bossInstance.stop({ graceful: true, timeout: 3e4 });
+    jobLogger.info("pg-boss stopped gracefully");
   } catch (error) {
-    serverLogger.error("afterRoutes hook failed", error);
-    throw new Error("Server initialization failed in afterRoutes hook");
+    jobLogger.error("Error stopping pg-boss:", error);
+    throw error;
+  } finally {
+    bossInstance = null;
+    bossConfig = null;
   }
 }
+function shouldClearOnStart() {
+  return bossConfig?.clearOnStart ?? false;
+}
 
-// src/server/start-server.ts
-init_cache();
-init_db();
-init_logger2();
+// src/job/job-router.ts
+function isJobDef(value) {
+  return value !== null && typeof value === "object" && "name" in value && "handler" in value && "send" in value && "run" in value;
+}
+function isJobRouter(value) {
+  return value !== null && typeof value === "object" && "jobs" in value && "_jobs" in value;
+}
+function collectJobs(router, prefix = "") {
+  const jobs = [];
+  for (const [key, value] of Object.entries(router.jobs)) {
+    const name = prefix ? `${prefix}.${key}` : key;
+    if (isJobRouter(value)) {
+      jobs.push(...collectJobs(value, name));
+    } else if (isJobDef(value)) {
+      jobs.push(value);
+    }
+  }
+  return jobs;
+}
+var jobLogger2 = logger.child("@spfn/core:job");
+function getEventQueueName(eventName) {
+  return `event:${eventName}`;
+}
+function getDefaultJobOptions(options) {
+  return {
+    retryLimit: options?.retryLimit ?? 3,
+    retryDelay: options?.retryDelay ?? 1e3,
+    expireInSeconds: options?.expireInSeconds ?? 300
+  };
+}
+async function registerJobs(router) {
+  const boss = getBoss();
+  if (!boss) {
+    throw new Error(
+      "pg-boss not initialized. Call initBoss() before registerJobs()"
+    );
+  }
+  const jobs = collectJobs(router);
+  const clearOnStart = shouldClearOnStart();
+  jobLogger2.info(`Registering ${jobs.length} job(s)...`);
+  if (clearOnStart) {
+    jobLogger2.info("Clearing existing jobs before registration...");
+    for (const job2 of jobs) {
+      await boss.deleteAllJobs(job2.name);
+      if (job2.subscribedEvent) {
+        const eventQueue = getEventQueueName(job2.subscribedEvent);
+        await boss.deleteAllJobs(eventQueue);
+      }
+    }
+    jobLogger2.info("Existing jobs cleared");
+  }
+  for (const job2 of jobs) {
+    await registerJob(job2);
+  }
+  jobLogger2.info("All jobs registered successfully");
+}
+async function ensureQueue(boss, queueName) {
+  await boss.createQueue(queueName);
+}
+async function registerWorker(boss, job2, queueName) {
+  await ensureQueue(boss, queueName);
+  await boss.work(
+    queueName,
+    { batchSize: 1 },
+    async (jobs) => {
+      for (const pgBossJob of jobs) {
+        jobLogger2.debug(`[Job:${job2.name}] Executing...`, { jobId: pgBossJob.id });
+        const startTime = Date.now();
+        try {
+          if (job2.inputSchema) {
+            await job2.handler(pgBossJob.data);
+          } else {
+            await job2.handler();
+          }
+          const duration = Date.now() - startTime;
+          jobLogger2.info(`[Job:${job2.name}] Completed in ${duration}ms`, {
+            jobId: pgBossJob.id,
+            duration
+          });
+        } catch (error) {
+          const duration = Date.now() - startTime;
+          jobLogger2.error(`[Job:${job2.name}] Failed after ${duration}ms`, {
+            jobId: pgBossJob.id,
+            duration,
+            error: error instanceof Error ? error.message : String(error)
+          });
+          throw error;
+        }
+      }
+    }
+  );
+}
+function connectEventToQueue(boss, job2, queueName) {
+  if (!job2._subscribedEventDef) {
+    return;
+  }
+  const eventDef = job2._subscribedEventDef;
+  eventDef._registerJobQueue(queueName, async (queue, payload) => {
+    await boss.send(queue, payload, getDefaultJobOptions(job2.options));
+  });
+  jobLogger2.debug(`[Job:${job2.name}] Connected to event: ${job2.subscribedEvent}`);
+}
+async function registerCronSchedule(boss, job2) {
+  if (!job2.cronExpression) {
+    return;
+  }
+  jobLogger2.debug(`[Job:${job2.name}] Scheduling cron: ${job2.cronExpression}`);
+  await ensureQueue(boss, job2.name);
+  await boss.schedule(
+    job2.name,
+    job2.cronExpression,
+    {},
+    getDefaultJobOptions(job2.options)
+  );
+  jobLogger2.info(`[Job:${job2.name}] Cron scheduled: ${job2.cronExpression}`);
+}
+async function queueRunOnceJob(boss, job2) {
+  if (!job2.runOnce) {
+    return;
+  }
+  jobLogger2.debug(`[Job:${job2.name}] Queuing runOnce job`);
+  await ensureQueue(boss, job2.name);
+  await boss.send(
+    job2.name,
+    {},
+    {
+      ...getDefaultJobOptions(job2.options),
+      singletonKey: `runOnce:${job2.name}`
+    }
+  );
+  jobLogger2.info(`[Job:${job2.name}] runOnce job queued`);
+}
+async function registerJob(job2) {
+  const boss = getBoss();
+  if (!boss) {
+    throw new Error("pg-boss not initialized");
+  }
+  const queueName = job2.subscribedEvent ? getEventQueueName(job2.subscribedEvent) : job2.name;
+  jobLogger2.debug(`Registering job: ${job2.name}`, {
+    queueName,
+    subscribedEvent: job2.subscribedEvent
+  });
+  await registerWorker(boss, job2, queueName);
+  connectEventToQueue(boss, job2, queueName);
+  await registerCronSchedule(boss, job2);
+  await queueRunOnceJob(boss, job2);
+  jobLogger2.debug(`Job registered: ${job2.name}`);
+}
 function getNetworkAddress() {
   const nets = networkInterfaces();
   for (const name of Object.keys(nets)) {
@@ -3364,16 +888,16 @@ function printBanner(options) {
 }
 
 // src/server/validation.ts
-function validateServerConfig(config) {
-  if (config.port !== void 0) {
-    if (!Number.isInteger(config.port) || config.port < 0 || config.port > 65535) {
+function validateServerConfig(config2) {
+  if (config2.port !== void 0) {
+    if (!Number.isInteger(config2.port) || config2.port < 0 || config2.port > 65535) {
       throw new Error(
-        `Invalid port: ${config.port}. Port must be an integer between 0 and 65535.`
+        `Invalid port: ${config2.port}. Port must be an integer between 0 and 65535.`
       );
     }
   }
-  if (config.timeout) {
-    const { request, keepAlive, headers } = config.timeout;
+  if (config2.timeout) {
+    const { request, keepAlive, headers } = config2.timeout;
     if (request !== void 0 && (request < 0 || !Number.isFinite(request))) {
       throw new Error(`Invalid timeout.request: ${request}. Must be a positive number.`);
     }
@@ -3389,41 +913,51 @@ function validateServerConfig(config) {
       );
     }
   }
-  if (config.shutdown?.timeout !== void 0) {
-    const timeout = config.shutdown.timeout;
+  if (config2.shutdown?.timeout !== void 0) {
+    const timeout = config2.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("/")) {
+  if (config2.healthCheck?.path) {
+    if (!config2.healthCheck.path.startsWith("/")) {
       throw new Error(
-        `Invalid healthCheck.path: "${config.healthCheck.path}". Must start with "/".`
+        `Invalid healthCheck.path: "${config2.healthCheck.path}". Must start with "/".`
       );
     }
   }
 }
-
-// src/server/start-server.ts
-var serverLogger2 = logger.child("server");
-async function startServer(config) {
-  const finalConfig = await loadAndMergeConfig(config);
+var DEFAULT_MAX_LISTENERS = 15;
+var TIMEOUTS = {
+  SERVER_CLOSE: 5e3,
+  DATABASE_CLOSE: 5e3,
+  REDIS_CLOSE: 5e3,
+  PRODUCTION_ERROR_SHUTDOWN: 1e4
+};
+var CONFIG_FILE_PATHS = [
+  ".spfn/server/server.config.mjs",
+  ".spfn/server/server.config",
+  "src/server/server.config",
+  "src/server/server.config.ts"
+];
+var processHandlersRegistered = false;
+async function startServer(config2) {
+  loadEnvFiles();
+  const finalConfig = await loadAndMergeConfig(config2);
   const { host, port, debug } = finalConfig;
   validateServerConfig(finalConfig);
+  if (!host || !port) {
+    throw new Error("Server host and port are required");
+  }
   if (debug) {
     logMiddlewareOrder(finalConfig);
   }
-  serverLogger2.debug("Discovering plugins...");
-  const plugins = await discoverPlugins();
-  if (plugins.length > 0) {
-    serverLogger2.info("Plugins discovered", {
-      count: plugins.length,
-      plugins: plugins.map((p) => p.name)
-    });
-  }
+  const shutdownState = {
+    isShuttingDown: false
+  };
   try {
-    await initializeInfrastructure(finalConfig, plugins);
-    const app = await createServer(finalConfig, plugins);
+    await initializeInfrastructure(finalConfig);
+    const app = await createServer(finalConfig);
     const server = startHttpServer(app, host, port);
     const timeouts = getTimeoutConfig(finalConfig.timeout);
     applyServerTimeouts(server, timeouts);
@@ -3434,236 +968,643 @@ async function startServer(config) {
       port
     });
     logServerStarted(debug, host, port, finalConfig, timeouts);
-    const shutdownServer = createShutdownHandler(server, finalConfig, plugins);
-    const shutdown = createGracefulShutdown(shutdownServer, finalConfig);
-    registerShutdownHandlers(shutdown);
+    const shutdownServer = createShutdownHandler(server, finalConfig, shutdownState);
+    const shutdown = createGracefulShutdown(shutdownServer, finalConfig, shutdownState);
+    registerProcessHandlers(shutdown);
     const serverInstance = {
       server,
       app,
       config: finalConfig,
       close: async () => {
-        serverLogger2.info("Manual server shutdown requested");
+        serverLogger.info("Manual server shutdown requested");
+        if (shutdownState.isShuttingDown) {
+          serverLogger.warn("Shutdown already in progress, ignoring manual close request");
+          return;
+        }
+        shutdownState.isShuttingDown = true;
         await shutdownServer();
       }
     };
     if (finalConfig.lifecycle?.afterStart) {
-      serverLogger2.debug("Executing afterStart hook...");
+      serverLogger.debug("Executing afterStart hook...");
       try {
         await finalConfig.lifecycle.afterStart(serverInstance);
       } catch (error) {
-        serverLogger2.error("afterStart hook failed", error);
+        serverLogger.error("afterStart hook failed", error);
       }
     }
-    await executePluginHooks(plugins, "afterStart", serverInstance);
     return serverInstance;
   } catch (error) {
     const err = error;
-    serverLogger2.error("Server initialization failed", err);
+    serverLogger.error("Server initialization failed", err);
     await cleanupOnFailure(finalConfig);
     throw error;
   }
 }
-async function loadAndMergeConfig(config) {
+async function loadAndMergeConfig(config2) {
   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 ?? {};
+  let loadedConfigPath = null;
+  for (const configPath of CONFIG_FILE_PATHS) {
+    const fullPath = join(cwd, configPath);
+    if (existsSync(fullPath)) {
+      try {
+        const configModule = await import(fullPath);
+        fileConfig = configModule.default ?? {};
+        loadedConfigPath = configPath;
+        break;
+      } catch (error) {
+        serverLogger.error(`Failed to load config from ${configPath} - file exists but import failed`, error);
+      }
+    }
+  }
+  if (loadedConfigPath) {
+    serverLogger.debug(`Loaded configuration from ${loadedConfigPath}`);
+  } else {
+    serverLogger.debug("No configuration file found, using defaults");
   }
   return {
     ...fileConfig,
-    ...config,
-    port: config?.port ?? fileConfig?.port ?? (parseInt(process.env.PORT || "", 10) || 4e3),
-    host: config?.host ?? fileConfig?.host ?? (process.env.HOST || "localhost")
+    ...config2,
+    port: config2?.port ?? fileConfig?.port ?? env.PORT,
+    host: config2?.host ?? fileConfig?.host ?? env.HOST
   };
 }
-function logMiddlewareOrder(config) {
-  const middlewareOrder = buildMiddlewareOrder(config);
-  serverLogger2.debug("Middleware execution order", {
-    order: middlewareOrder
-  });
+function getInfrastructureConfig(config2) {
+  return {
+    database: config2.infrastructure?.database !== false,
+    redis: config2.infrastructure?.redis !== false
+  };
 }
-async function initializeInfrastructure(config, plugins) {
-  if (config.lifecycle?.beforeInfrastructure) {
-    serverLogger2.debug("Executing beforeInfrastructure hook...");
-    try {
-      await config.lifecycle.beforeInfrastructure(config);
-    } catch (error) {
-      serverLogger2.error("beforeInfrastructure hook failed", error);
-      throw new Error("Server initialization failed in beforeInfrastructure hook");
-    }
+async function initializeInfrastructure(config2) {
+  if (config2.lifecycle?.beforeInfrastructure) {
+    serverLogger.debug("Executing beforeInfrastructure hook...");
+    await config2.lifecycle.beforeInfrastructure(config2);
   }
-  const shouldInitDatabase = config.infrastructure?.database !== false;
-  if (shouldInitDatabase) {
-    serverLogger2.debug("Initializing database...");
-    await initDatabase(config.database);
+  const infraConfig = getInfrastructureConfig(config2);
+  if (infraConfig.database) {
+    serverLogger.debug("Initializing database...");
+    await initDatabase(config2.database);
   } else {
-    serverLogger2.debug("Database initialization disabled");
+    serverLogger.debug("Database initialization disabled");
   }
-  const shouldInitRedis = config.infrastructure?.redis !== false;
-  if (shouldInitRedis) {
-    serverLogger2.debug("Initializing Redis...");
-    await initRedis();
+  if (infraConfig.redis) {
+    serverLogger.debug("Initializing Redis...");
+    await initCache();
   } else {
-    serverLogger2.debug("Redis initialization disabled");
+    serverLogger.debug("Redis initialization disabled");
   }
-  if (config.lifecycle?.afterInfrastructure) {
-    serverLogger2.debug("Executing afterInfrastructure hook...");
-    try {
-      await config.lifecycle.afterInfrastructure();
-    } catch (error) {
-      serverLogger2.error("afterInfrastructure hook failed", error);
-      throw new Error("Server initialization failed in afterInfrastructure hook");
+  if (config2.lifecycle?.afterInfrastructure) {
+    serverLogger.debug("Executing afterInfrastructure hook...");
+    await config2.lifecycle.afterInfrastructure();
+  }
+  if (config2.jobs) {
+    const dbUrl = env.DATABASE_URL;
+    if (!dbUrl) {
+      throw new Error(
+        "Jobs require database connection. Ensure DATABASE_URL is set or database is enabled."
+      );
+    }
+    serverLogger.debug("Initializing pg-boss...");
+    await initBoss({
+      connectionString: dbUrl,
+      ...config2.jobsConfig
+    });
+    serverLogger.debug("Registering jobs...");
+    await registerJobs(config2.jobs);
+  }
+  if (config2.workflows) {
+    const infraConfig2 = getInfrastructureConfig(config2);
+    if (!infraConfig2.database) {
+      throw new Error(
+        "Workflows require database connection. Ensure database is enabled in infrastructure config."
+      );
     }
+    serverLogger.debug("Initializing workflow engine...");
+    config2.workflows._init(
+      getDatabase(),
+      config2.workflowsConfig
+    );
+    serverLogger.info("Workflow engine initialized");
   }
-  await executePluginHooks(plugins, "afterInfrastructure");
 }
 function startHttpServer(app, host, port) {
-  serverLogger2.debug(`Starting server on ${host}:${port}...`);
-  const server = serve({
+  serverLogger.debug(`Starting server on ${host}:${port}...`);
+  return serve({
     fetch: app.fetch,
     port,
     hostname: host
   });
-  return server;
+}
+function logMiddlewareOrder(config2) {
+  const middlewareOrder = buildMiddlewareOrder(config2);
+  serverLogger.debug("Middleware execution order", {
+    order: middlewareOrder
+  });
 }
 function logServerTimeouts(timeouts) {
-  serverLogger2.info("Server timeouts configured", {
+  serverLogger.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", {
+function logServerStarted(debug, host, port, config2, timeouts) {
+  const startupConfig = buildStartupConfig(config2, timeouts);
+  serverLogger.info("Server started successfully", {
     mode: debug ? "development" : "production",
     host,
     port,
     config: startupConfig
   });
 }
-function createShutdownHandler(server, config, plugins) {
+function createShutdownHandler(server, config2, shutdownState) {
   return async () => {
-    serverLogger2.debug("Closing HTTP server...");
-    await new Promise((resolve) => {
-      server.close(() => {
-        serverLogger2.info("HTTP server closed");
-        resolve();
-      });
+    if (shutdownState.isShuttingDown) {
+      serverLogger.debug("Shutdown already in progress for this instance, skipping");
+      return;
+    }
+    shutdownState.isShuttingDown = true;
+    serverLogger.debug("Closing HTTP server...");
+    let timeoutId;
+    await Promise.race([
+      new Promise((resolve2, reject) => {
+        server.close((err) => {
+          if (timeoutId) clearTimeout(timeoutId);
+          if (err) {
+            serverLogger.error("HTTP server close error", err);
+            reject(err);
+          } else {
+            serverLogger.info("HTTP server closed");
+            resolve2();
+          }
+        });
+      }),
+      new Promise((_, reject) => {
+        timeoutId = setTimeout(() => {
+          reject(new Error(`HTTP server close timeout after ${TIMEOUTS.SERVER_CLOSE}ms`));
+        }, TIMEOUTS.SERVER_CLOSE);
+      })
+    ]).catch((error) => {
+      if (timeoutId) clearTimeout(timeoutId);
+      serverLogger.warn("HTTP server close timeout, forcing shutdown", error);
     });
-    if (config.lifecycle?.beforeShutdown) {
-      serverLogger2.debug("Executing beforeShutdown hook...");
+    if (config2.jobs) {
+      serverLogger.debug("Stopping pg-boss...");
       try {
-        await config.lifecycle.beforeShutdown();
+        await stopBoss();
       } catch (error) {
-        serverLogger2.error("beforeShutdown hook failed", error);
+        serverLogger.error("pg-boss stop failed", error);
       }
     }
-    try {
-      await executePluginHooks(plugins, "beforeShutdown");
-    } catch (error) {
-      serverLogger2.error("Plugin beforeShutdown hooks failed", error);
+    if (config2.lifecycle?.beforeShutdown) {
+      serverLogger.debug("Executing beforeShutdown hook...");
+      try {
+        await config2.lifecycle.beforeShutdown();
+      } catch (error) {
+        serverLogger.error("beforeShutdown hook failed", error);
+      }
     }
-    const shouldCloseDatabase = config.infrastructure?.database !== false;
-    const shouldCloseRedis = config.infrastructure?.redis !== false;
-    if (shouldCloseDatabase) {
-      serverLogger2.debug("Closing database connections...");
-      await closeDatabase();
+    const infraConfig = getInfrastructureConfig(config2);
+    if (infraConfig.database) {
+      serverLogger.debug("Closing database connections...");
+      await closeInfrastructure(closeDatabase, "Database", TIMEOUTS.DATABASE_CLOSE);
     }
-    if (shouldCloseRedis) {
-      serverLogger2.debug("Closing Redis connections...");
-      await closeRedis();
+    if (infraConfig.redis) {
+      serverLogger.debug("Closing Redis connections...");
+      await closeInfrastructure(closeCache, "Redis", TIMEOUTS.REDIS_CLOSE);
     }
-    serverLogger2.info("Server shutdown completed");
+    serverLogger.info("Server shutdown completed");
   };
 }
-function createGracefulShutdown(shutdownServer, config) {
+async function closeInfrastructure(closeFn, name, timeout) {
+  let timeoutId;
+  try {
+    await Promise.race([
+      closeFn().then(() => {
+        if (timeoutId) clearTimeout(timeoutId);
+      }),
+      new Promise((_, reject) => {
+        timeoutId = setTimeout(() => {
+          reject(new Error(`${name} close timeout after ${timeout}ms`));
+        }, timeout);
+      })
+    ]);
+    serverLogger.info(`${name} connections closed successfully`);
+  } catch (error) {
+    if (timeoutId) clearTimeout(timeoutId);
+    serverLogger.error(`${name} close failed or timed out`, error);
+  }
+}
+function createGracefulShutdown(shutdownServer, config2, shutdownState) {
   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);
-    });
+    if (shutdownState.isShuttingDown) {
+      serverLogger.warn(`${signal} received but shutdown already in progress, ignoring`);
+      return;
+    }
+    serverLogger.info(`${signal} received, starting graceful shutdown...`);
+    const shutdownTimeout = getShutdownTimeout(config2.shutdown);
+    let timeoutId;
     try {
       await Promise.race([
-        shutdownServer(),
-        timeoutPromise
+        shutdownServer().then(() => {
+          if (timeoutId) clearTimeout(timeoutId);
+        }),
+        new Promise((_, reject) => {
+          timeoutId = setTimeout(() => {
+            reject(new Error(`Graceful shutdown timeout after ${shutdownTimeout}ms`));
+          }, shutdownTimeout);
+        })
       ]);
-      serverLogger2.info("Graceful shutdown completed successfully");
+      if (timeoutId) clearTimeout(timeoutId);
+      serverLogger.info("Graceful shutdown completed successfully");
       process.exit(0);
     } catch (error) {
+      if (timeoutId) clearTimeout(timeoutId);
       const err = error;
       if (err.message && err.message.includes("timeout")) {
-        serverLogger2.error("Graceful shutdown timeout, forcing exit", err);
+        serverLogger.error("Graceful shutdown timeout, forcing exit", err);
       } else {
-        serverLogger2.error("Error during graceful shutdown", err);
+        serverLogger.error("Error during graceful shutdown", err);
       }
       process.exit(1);
     }
   };
 }
-function registerShutdownHandlers(shutdown) {
-  process.setMaxListeners(15);
-  process.on("SIGTERM", () => shutdown("SIGTERM"));
-  process.on("SIGINT", () => shutdown("SIGINT"));
+function handleProcessError(errorType, shutdown) {
+  const isProduction = env.NODE_ENV === "production";
+  const isDevelopment = env.NODE_ENV === "development";
+  if (isDevelopment || process.env.WATCH_MODE === "true") {
+    serverLogger.info("Exiting immediately for clean restart");
+    process.exit(1);
+  } else if (isProduction) {
+    serverLogger.info(`Attempting graceful shutdown after ${errorType}`);
+    const forceExitTimer = setTimeout(() => {
+      serverLogger.error(`Forced exit after ${TIMEOUTS.PRODUCTION_ERROR_SHUTDOWN}ms - graceful shutdown did not complete`);
+      process.exit(1);
+    }, TIMEOUTS.PRODUCTION_ERROR_SHUTDOWN);
+    shutdown(errorType).then(() => {
+      clearTimeout(forceExitTimer);
+      serverLogger.info("Graceful shutdown completed, exiting");
+      process.exit(0);
+    }).catch((shutdownError) => {
+      clearTimeout(forceExitTimer);
+      serverLogger.error("Graceful shutdown failed", shutdownError);
+      process.exit(1);
+    });
+  } else {
+    serverLogger.info("Exiting immediately");
+    process.exit(1);
+  }
+}
+function registerProcessHandlers(shutdown) {
+  if (processHandlersRegistered) {
+    serverLogger.debug("Process handlers already registered, skipping");
+    return;
+  }
+  processHandlersRegistered = true;
+  const currentMax = process.getMaxListeners();
+  if (currentMax < DEFAULT_MAX_LISTENERS) {
+    process.setMaxListeners(DEFAULT_MAX_LISTENERS);
+  }
+  process.on("SIGTERM", () => {
+    shutdown("SIGTERM").catch((error) => {
+      serverLogger.error("SIGTERM handler failed", error);
+      process.exit(1);
+    });
+  });
+  process.on("SIGINT", () => {
+    shutdown("SIGINT").catch((error) => {
+      serverLogger.error("SIGINT handler failed", error);
+      process.exit(1);
+    });
+  });
   process.on("uncaughtException", (error) => {
     if (error.message?.includes("EADDRINUSE")) {
-      serverLogger2.error("Port conflict detected - detailed trace:", {
-        error: error.message,
-        stack: error.stack,
+      serverLogger.error("Port conflict detected - detailed trace:", error, {
         code: error.code,
         port: error.port,
         address: error.address,
         syscall: error.syscall
       });
     } else {
-      serverLogger2.error("Uncaught exception", error);
+      serverLogger.error("Uncaught exception", error);
     }
-    serverLogger2.info("Exiting immediately for clean restart");
-    process.exit(1);
+    handleProcessError("UNCAUGHT_EXCEPTION", shutdown);
   });
   process.on("unhandledRejection", (reason, promise) => {
-    serverLogger2.error("Unhandled promise rejection", {
-      reason,
-      promise
-    });
-    serverLogger2.info("Exiting immediately for clean restart");
-    process.exit(1);
+    if (reason instanceof Error) {
+      Promise.resolve().then(() => (init_formatters(), formatters_exports)).then(({ formatUnhandledRejection: formatUnhandledRejection2 }) => {
+        const { error, context } = formatUnhandledRejection2(reason, promise);
+        serverLogger.error("Unhandled promise rejection", error, context);
+      }).catch(() => {
+        serverLogger.error("Unhandled promise rejection", reason, {
+          promise
+        });
+      });
+    } else {
+      serverLogger.error("Unhandled promise rejection", {
+        reason,
+        promise
+      });
+    }
+    handleProcessError("UNHANDLED_REJECTION", shutdown);
   });
+  serverLogger.debug("Process-level shutdown handlers registered successfully");
 }
-async function cleanupOnFailure(config) {
+async function cleanupOnFailure(config2) {
   try {
-    serverLogger2.debug("Cleaning up after initialization failure...");
-    const shouldCleanupDatabase = config.infrastructure?.database !== false;
-    const shouldCleanupRedis = config.infrastructure?.redis !== false;
-    if (shouldCleanupDatabase) {
-      await closeDatabase();
+    serverLogger.debug("Cleaning up after initialization failure...");
+    const infraConfig = getInfrastructureConfig(config2);
+    if (infraConfig.database) {
+      await closeInfrastructure(closeDatabase, "Database", TIMEOUTS.DATABASE_CLOSE);
     }
-    if (shouldCleanupRedis) {
-      await closeRedis();
+    if (infraConfig.redis) {
+      await closeInfrastructure(closeCache, "Redis", TIMEOUTS.REDIS_CLOSE);
     }
-    serverLogger2.debug("Cleanup completed");
+    serverLogger.debug("Cleanup completed");
   } catch (cleanupError) {
-    serverLogger2.error("Cleanup failed", cleanupError);
+    serverLogger.error("Cleanup failed", cleanupError);
+  }
+}
+
+// src/server/config-builder.ts
+function collectHooks(lifecycles, key) {
+  return lifecycles.map((lc) => lc[key]).filter((hook) => hook !== void 0);
+}
+function createMergedHook(hooks) {
+  if (hooks.length === 0) {
+    return void 0;
+  }
+  return (async (...args) => {
+    for (const hook of hooks) {
+      await hook(...args);
+    }
+  });
+}
+var ServerConfigBuilder = class {
+  config = {};
+  lifecycles = [];
+  /**
+   * Set server port
+   */
+  port(port) {
+    this.config.port = port;
+    return this;
+  }
+  /**
+   * Set server hostname
+   */
+  host(host) {
+    this.config.host = host;
+    return this;
+  }
+  /**
+   * Set CORS configuration
+   */
+  cors(cors2) {
+    this.config.cors = cors2;
+    return this;
+  }
+  /**
+   * Configure built-in middleware
+   */
+  middleware(middleware) {
+    this.config.middleware = middleware;
+    return this;
+  }
+  /**
+   * Add custom middleware
+   */
+  use(handlers) {
+    this.config.use = handlers;
+    return this;
+  }
+  /**
+   * Add named middlewares for route-level skip control
+   */
+  middlewares(middlewares) {
+    this.config.middlewares = middlewares;
+    return this;
+  }
+  /**
+   * Register define-route based router
+   *
+   * Automatically applies:
+   * - Global middlewares from router._globalMiddlewares (via .use())
+   * - Package routers from router._packageRouters (via .packages())
+   *
+   * @example
+   * ```typescript
+   * const appRouter = defineRouter({
+   *   getUser: route.get('/users/:id')...
+   * })
+   * .packages([authRouter, cmsAppRouter])
+   * .use([authMiddleware]);
+   *
+   * export default defineServerConfig()
+   *   .routes(appRouter)  // middlewares auto-applied
+   *   .build();
+   * ```
+   */
+  routes(router) {
+    this.config.routes = router;
+    const allGlobalMiddlewares = [];
+    if (router._globalMiddlewares?.length > 0) {
+      allGlobalMiddlewares.push(...router._globalMiddlewares);
+    }
+    if (router._packageRouters?.length > 0) {
+      for (const pkgRouter of router._packageRouters) {
+        if (pkgRouter._globalMiddlewares?.length > 0) {
+          allGlobalMiddlewares.push(...pkgRouter._globalMiddlewares);
+        }
+      }
+    }
+    if (allGlobalMiddlewares.length > 0) {
+      this.config.middlewares = [
+        ...this.config.middlewares || [],
+        ...allGlobalMiddlewares
+      ];
+    }
+    return this;
+  }
+  /**
+   * Register background jobs router
+   *
+   * @example
+   * ```typescript
+   * import { job, defineJobRouter } from '@spfn/core/job';
+   *
+   * const sendEmail = job('send-email')
+   *   .input(Type.Object({ to: Type.String() }))
+   *   .handler(async (input) => { ... });
+   *
+   * const jobRouter = defineJobRouter({ sendEmail });
+   *
+   * export default defineServerConfig()
+   *   .routes(appRouter)
+   *   .jobs(jobRouter)
+   *   .build();
+   * ```
+   */
+  jobs(router, config2) {
+    this.config.jobs = router;
+    if (config2) {
+      this.config.jobsConfig = config2;
+    }
+    return this;
+  }
+  /**
+   * Register event router for SSE (Server-Sent Events)
+   *
+   * Enables real-time event streaming to frontend clients.
+   * Events defined with defineEvent() can be subscribed by:
+   * - Backend: .subscribe() for internal handlers
+   * - Jobs: .on(event) for background processing
+   * - Frontend: SSE stream for real-time updates
+   *
+   * @example
+   * ```typescript
+   * import { defineEvent, defineEventRouter } from '@spfn/core/event';
+   *
+   * const userCreated = defineEvent('user.created', Type.Object({
+   *   userId: Type.String(),
+   * }));
+   *
+   * const eventRouter = defineEventRouter({ userCreated });
+   *
+   * export default defineServerConfig()
+   *   .routes(appRouter)
+   *   .events(eventRouter)  // → GET /events/stream
+   *   .build();
+   *
+   * // Custom path
+   * .events(eventRouter, { path: '/sse' })
+   * ```
+   */
+  events(router, config2) {
+    this.config.events = router;
+    if (config2) {
+      this.config.eventsConfig = config2;
+    }
+    return this;
+  }
+  /**
+   * Enable/disable debug mode
+   */
+  debug(enabled) {
+    this.config.debug = enabled;
+    return this;
+  }
+  /**
+   * Configure database settings
+   */
+  database(database) {
+    this.config.database = database;
+    return this;
   }
+  /**
+   * Configure server timeout settings
+   */
+  timeout(timeout) {
+    this.config.timeout = timeout;
+    return this;
+  }
+  /**
+   * Configure graceful shutdown settings
+   */
+  shutdown(shutdown) {
+    this.config.shutdown = shutdown;
+    return this;
+  }
+  /**
+   * Configure health check endpoint
+   */
+  healthCheck(healthCheck) {
+    this.config.healthCheck = healthCheck;
+    return this;
+  }
+  /**
+   * Configure infrastructure initialization
+   */
+  infrastructure(infrastructure) {
+    this.config.infrastructure = infrastructure;
+    return this;
+  }
+  /**
+   * Register workflow router for workflow orchestration
+   *
+   * Automatically initializes the workflow engine after database is ready.
+   *
+   * @example
+   * ```typescript
+   * import { defineWorkflowRouter } from '@spfn/workflow';
+   *
+   * const workflowRouter = defineWorkflowRouter([
+   *     provisionTenant,
+   *     deprovisionTenant,
+   * ]);
+   *
+   * export default defineServerConfig()
+   *     .routes(appRouter)
+   *     .workflows(workflowRouter)
+   *     .build();
+   * ```
+   */
+  workflows(router, config2) {
+    this.config.workflows = router;
+    if (config2) {
+      this.config.workflowsConfig = config2;
+    }
+    return this;
+  }
+  /**
+   * Configure lifecycle hooks
+   * Can be called multiple times - hooks will be executed in registration order
+   */
+  lifecycle(lifecycle) {
+    if (lifecycle) {
+      this.lifecycles.push(lifecycle);
+    }
+    return this;
+  }
+  /**
+   * Build and return the final configuration
+   */
+  build() {
+    if (this.lifecycles.length > 0) {
+      serverLogger.info("Merging lifecycles", { count: this.lifecycles.length });
+      this.config.lifecycle = this.mergeLifecycles();
+    }
+    return this.config;
+  }
+  mergeLifecycles() {
+    return {
+      beforeInfrastructure: createMergedHook(
+        collectHooks(this.lifecycles, "beforeInfrastructure")
+      ),
+      afterInfrastructure: createMergedHook(
+        collectHooks(this.lifecycles, "afterInfrastructure")
+      ),
+      beforeRoutes: createMergedHook(
+        collectHooks(this.lifecycles, "beforeRoutes")
+      ),
+      afterRoutes: createMergedHook(
+        collectHooks(this.lifecycles, "afterRoutes")
+      ),
+      afterStart: createMergedHook(
+        collectHooks(this.lifecycles, "afterStart")
+      ),
+      beforeShutdown: createMergedHook(
+        collectHooks(this.lifecycles, "beforeShutdown")
+      )
+    };
+  }
+};
+function defineServerConfig() {
+  return new ServerConfigBuilder();
 }
 
-export { createServer, startServer };
+export { createServer, defineServerConfig, loadEnvFiles, startServer };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map