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

package/dist/route/index.js

@@ -1,1354 +1,780 @@
-import { readFileSync, existsSync, mkdirSync, accessSync, constants, writeFileSync, unlinkSync, createWriteStream, statSync, readdirSync, renameSync } from 'fs';
-import { join, dirname, relative } from 'path';
-import { readdir, stat } from 'fs/promises';
+import { logger } from '@spfn/core/logger';
+import { FormatRegistry, Type, Kind } from '@sinclair/typebox';
 import { Value } from '@sinclair/typebox/value';
-import { Hono } from 'hono';
-import { Type } from '@sinclair/typebox';
+import { ValidationError } from '@spfn/core/errors';
 
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
-// src/logger/types.ts
-var LOG_LEVEL_PRIORITY;
-var init_types = __esm({
-  "src/logger/types.ts"() {
-    LOG_LEVEL_PRIORITY = {
-      debug: 0,
-      info: 1,
-      warn: 2,
-      error: 3,
-      fatal: 4
+// src/route/route-builder.ts
+var RouteBuilder = class _RouteBuilder {
+  _method;
+  _path;
+  _input;
+  _interceptor;
+  _middlewares;
+  _skipMiddlewares;
+  /**
+   * Create a new RouteBuilder with copied properties and optional overrides
+   */
+  clone(overrides) {
+    const builder = new _RouteBuilder();
+    builder._method = this._method;
+    builder._path = this._path;
+    builder._input = overrides?.input ?? this._input;
+    builder._interceptor = overrides?.interceptor ?? this._interceptor;
+    builder._middlewares = overrides?.middlewares ?? this._middlewares;
+    builder._skipMiddlewares = overrides?.skipMiddlewares ?? this._skipMiddlewares;
+    return builder;
+  }
+  /**
+   * Define input schemas
+   *
+   * @example
+   * ```ts
+   * route.get('/users/:id')
+   *   .input({
+   *     params: Type.Object({ id: Type.String() }),
+   *     query: Type.Object({ page: Type.Number() }),
+   *     headers: Type.Object({ authorization: Type.String() })
+   *   })
+   *   .handler(async (c) => {
+   *     const { params, query, headers } = await c.data();
+   *     // params = { id: string }
+   *     // query = { page: number }
+   *     // headers = { authorization: string }
+   *   })
+   * ```
+   */
+  input(input) {
+    return this.clone({ input });
+  }
+  /**
+   * Define fields injected by interceptors
+   *
+   * These fields are:
+   * - Available in the handler (merged with input)
+   * - Excluded from client types (codegen uses only input)
+   * - Not validated by route input schema (injected by middleware)
+   *
+   * Use this when middleware/interceptors add fields to the request
+   * before it reaches the handler.
+   *
+   * @example
+   * ```ts
+   * // Auth interceptor injects crypto key fields
+   * route.post('/_auth/login')
+   *   .input({
+   *     body: Type.Object({
+   *       email: Type.String(),
+   *       password: Type.String()
+   *     })
+   *   })
+   *   .interceptor({
+   *     body: Type.Object({
+   *       publicKey: Type.String(),
+   *       keyId: Type.String(),
+   *       fingerprint: Type.String()
+   *     })
+   *   })
+   *   .handler(async (c) => {
+   *     const { body } = await c.data();
+   *     // body type: { email, password, publicKey, keyId, fingerprint }
+   *     // Client only sees: { email, password }
+   *     return loginService(body);
+   *   });
+   * ```
+   */
+  interceptor(interceptor) {
+    return this.clone({ interceptor });
+  }
+  /**
+   * Add middlewares to the route
+   *
+   * Accepts both regular middleware handlers and named middlewares (NamedMiddleware).
+   * Named middlewares that are already registered globally will be automatically
+   * deduplicated to prevent double execution.
+   *
+   * @example
+   * ```ts
+   * import { authenticate } from '@spfn/auth/server/middleware';
+   *
+   * // With NamedMiddleware (auto-deduped if registered globally)
+   * route.get('/users')
+   *   .use([authenticate, RateLimitMiddleware()])
+   *
+   * // With regular middleware handlers
+   * route.get('/users')
+   *   .use([AuthMiddleware(), RateLimitMiddleware()])
+   * ```
+   */
+  middleware(middlewares) {
+    return this.clone({ middlewares });
+  }
+  /**
+   * Add middlewares to the route (alias for `.middleware()`)
+   *
+   * Accepts both regular middleware handlers and named middlewares (NamedMiddleware).
+   * Named middlewares that are already registered globally will be automatically
+   * deduplicated to prevent double execution.
+   *
+   * @example
+   * ```ts
+   * import { authenticate } from '@spfn/auth/server/middleware';
+   *
+   * // With NamedMiddleware (auto-deduped if registered globally)
+   * route.get('/users')
+   *   .use([authenticate, RateLimitMiddleware()])
+   *
+   * // With regular middleware handlers
+   * route.get('/users')
+   *   .use([AuthMiddleware(), RateLimitMiddleware()])
+   * ```
+   */
+  use(middlewares) {
+    return this.middleware(middlewares);
+  }
+  /**
+   * Skip server-level named middlewares
+   *
+   * Useful for public endpoints that should bypass auth or rate limiting
+   *
+   * @param middlewareNames - Array of middleware names to skip, or '*' to skip all
+   *
+   * @example
+   * ```ts
+   * // Skip specific middlewares
+   * route.get('/health')
+   *   .skip(['auth', 'rateLimit'])
+   *   .handler(async (c) => c.json({ status: 'ok' }));
+   *
+   * // Skip only auth (still apply rate limiting)
+   * route.get('/public-data')
+   *   .skip(['auth'])
+   *   .handler(async (c) => { ... });
+   *
+   * // Skip all middlewares
+   * route.get('/public-health')
+   *   .skip('*')
+   *   .handler(async (c) => c.json({ status: 'ok' }));
+   * ```
+   */
+  skip(middlewareNames) {
+    return this.clone({ skipMiddlewares: middlewareNames });
+  }
+  /**
+   * Define handler function
+   *
+   * Response type is automatically inferred from the return value.
+   * Use helper methods like `c.created()`, `c.paginated()` for proper type inference.
+   *
+   * @example
+   * ```ts
+   * // Direct return - type inferred from data
+   * route.get('/users/:id')
+   *   .input({ params: Type.Object({ id: Type.String() }) })
+   *   .handler(async (c) => {
+   *     const { params } = await c.data();
+   *     return await getUser(params.id); // Type: User
+   *   })
+   *
+   * // Using c.created() - returns data with 201 status, type preserved
+   * route.post('/users')
+   *   .input({ body: Type.Object({ name: Type.String() }) })
+   *   .handler(async (c) => {
+   *     const { body } = await c.data();
+   *     return c.created(await createUser(body)); // Type: User
+   *   })
+   *
+   * // Using c.paginated() - returns PaginatedResult<T>
+   * route.get('/users')
+   *   .handler(async (c) => {
+   *     const users = await getUsers();
+   *     return c.paginated(users, 1, 20, 100); // Type: PaginatedResult<User>
+   *   })
+   *
+   * // Using c.noContent() - returns void
+   * route.delete('/users/:id')
+   *   .handler(async (c) => {
+   *     await deleteUser(params.id);
+   *     return c.noContent(); // Type: void
+   *   })
+   *
+   * // Using c.json() - returns Response (type inference lost)
+   * // Use only when you need custom status codes not covered by helpers
+   * route.get('/custom')
+   *   .handler(async (c) => {
+   *     return c.json({ data }, 418); // Type: Response
+   *   })
+   * ```
+   */
+  handler(fn) {
+    return {
+      method: this._method,
+      path: this._path,
+      input: this._input,
+      interceptor: this._interceptor,
+      middlewares: this._middlewares,
+      skipMiddlewares: this._skipMiddlewares,
+      handler: fn,
+      _input: {},
+      _interceptor: {},
+      _response: {}
     };
   }
-});
+};
+function createMethodRoute(method) {
+  return (path) => {
+    const builder = new RouteBuilder();
+    builder._method = method;
+    builder._path = path;
+    return builder;
+  };
+}
+var route = {
+  get: createMethodRoute("GET"),
+  post: createMethodRoute("POST"),
+  put: createMethodRoute("PUT"),
+  patch: createMethodRoute("PATCH"),
+  delete: createMethodRoute("DELETE")
+};
 
-// src/logger/formatters.ts
-function isSensitiveKey(key) {
-  const lowerKey = key.toLowerCase();
-  return SENSITIVE_KEYS.some((sensitive) => lowerKey.includes(sensitive));
+// src/route/router.ts
+function createRouterInstance(routes, packageRouters = [], globalMiddlewares = []) {
+  return {
+    routes,
+    _routes: routes,
+    _packageRouters: packageRouters,
+    _globalMiddlewares: globalMiddlewares,
+    packages(routers) {
+      const newPackageRouters = [...this._packageRouters, ...routers];
+      for (const pkgRouter of routers) {
+        if (pkgRouter._packageRouters?.length > 0) {
+          newPackageRouters.push(...pkgRouter._packageRouters);
+        }
+      }
+      return createRouterInstance(this.routes, newPackageRouters, this._globalMiddlewares);
+    },
+    use(middlewares) {
+      return createRouterInstance(this.routes, this._packageRouters, [...this._globalMiddlewares, ...middlewares]);
+    }
+  };
+}
+function defineRouter(routes) {
+  return createRouterInstance(routes);
+}
+function FileSchema(options) {
+  return Type.Unsafe({
+    [Kind]: "File",
+    type: "object",
+    fileOptions: options
+  });
+}
+function FileArraySchema(options) {
+  return Type.Unsafe({
+    [Kind]: "FileArray",
+    type: "array",
+    items: { [Kind]: "File", type: "object" },
+    fileOptions: options
+  });
 }
-function maskSensitiveData(data) {
-  if (data === null || data === void 0) {
-    return data;
+function OptionalFileSchema(options) {
+  return Type.Optional(FileSchema(options));
+}
+function isFileSchema(schema) {
+  const kind = schema[Symbol.for("TypeBox.Kind")];
+  return kind === "File";
+}
+function isFileArraySchema(schema) {
+  const kind = schema[Symbol.for("TypeBox.Kind")];
+  return kind === "FileArray";
+}
+function getFileOptions(schema) {
+  return schema.fileOptions;
+}
+function formatFileSize(bytes) {
+  if (bytes >= 1024 * 1024 * 1024) {
+    return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)}GB`;
   }
-  if (Array.isArray(data)) {
-    return data.map((item) => maskSensitiveData(item));
+  if (bytes >= 1024 * 1024) {
+    return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
   }
-  if (typeof data === "object") {
-    const masked = {};
-    for (const [key, value] of Object.entries(data)) {
-      if (isSensitiveKey(key)) {
-        masked[key] = MASKED_VALUE;
-      } else if (typeof value === "object" && value !== null) {
-        masked[key] = maskSensitiveData(value);
-      } else {
-        masked[key] = value;
-      }
-    }
-    return masked;
+  if (bytes >= 1024) {
+    return `${(bytes / 1024).toFixed(1)}KB`;
   }
-  return data;
+  return `${bytes}B`;
 }
-function formatTimestamp(date) {
-  return date.toISOString();
+
+// src/route/validation.ts
+FormatRegistry.Set(
+  "email",
+  (value) => /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value)
+);
+FormatRegistry.Set(
+  "uri",
+  (value) => /^https?:\/\/.+/.test(value)
+);
+FormatRegistry.Set(
+  "uuid",
+  (value) => /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value)
+);
+FormatRegistry.Set(
+  "date",
+  (value) => /^\d{4}-\d{2}-\d{2}$/.test(value)
+);
+FormatRegistry.Set(
+  "date-time",
+  (value) => !isNaN(Date.parse(value))
+);
+function isFile(value) {
+  return value instanceof File || typeof value === "object" && value !== null && "name" in value && "size" in value && "type" in value && typeof value.arrayBuffer === "function";
 }
-function formatTimestampHuman(date) {
-  const year = date.getFullYear();
-  const month = String(date.getMonth() + 1).padStart(2, "0");
-  const day = String(date.getDate()).padStart(2, "0");
-  const hours = String(date.getHours()).padStart(2, "0");
-  const minutes = String(date.getMinutes()).padStart(2, "0");
-  const seconds = String(date.getSeconds()).padStart(2, "0");
-  const ms = String(date.getMilliseconds()).padStart(3, "0");
-  return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}.${ms}`;
+function isFileSchemaDef(schema) {
+  const kind = schema[Symbol.for("TypeBox.Kind")];
+  return kind === "File";
 }
-function formatError(error) {
-  const lines = [];
-  lines.push(`${error.name}: ${error.message}`);
-  if (error.stack) {
-    const stackLines = error.stack.split("\n").slice(1);
-    lines.push(...stackLines);
-  }
-  return lines.join("\n");
+function isFileArraySchemaDef(schema) {
+  const kind = schema[Symbol.for("TypeBox.Kind")];
+  return kind === "FileArray";
 }
-function formatConsole(metadata, colorize = true) {
-  const parts = [];
-  const timestamp = formatTimestampHuman(metadata.timestamp);
-  if (colorize) {
-    parts.push(`${COLORS.gray}[${timestamp}]${COLORS.reset}`);
-  } else {
-    parts.push(`[${timestamp}]`);
-  }
-  if (metadata.module) {
-    if (colorize) {
-      parts.push(`${COLORS.dim}[module=${metadata.module}]${COLORS.reset}`);
-    } else {
-      parts.push(`[module=${metadata.module}]`);
-    }
-  }
-  if (metadata.context && Object.keys(metadata.context).length > 0) {
-    Object.entries(metadata.context).forEach(([key, value]) => {
-      let valueStr;
-      if (typeof value === "string") {
-        valueStr = value;
-      } else if (typeof value === "object" && value !== null) {
-        try {
-          valueStr = JSON.stringify(value);
-        } catch (error) {
-          valueStr = "[circular]";
-        }
-      } else {
-        valueStr = String(value);
-      }
-      if (colorize) {
-        parts.push(`${COLORS.dim}[${key}=${valueStr}]${COLORS.reset}`);
-      } else {
-        parts.push(`[${key}=${valueStr}]`);
-      }
+function getSchemaFileOptions(schema) {
+  return schema.fileOptions;
+}
+function validateSingleFile(file, fieldPath, options, errors) {
+  if (!options) return;
+  const { maxSize, minSize, allowedTypes } = options;
+  if (maxSize !== void 0 && file.size > maxSize) {
+    errors.push({
+      path: fieldPath,
+      message: `File size ${formatFileSize(file.size)} exceeds maximum ${formatFileSize(maxSize)}`,
+      value: file.size
     });
   }
-  const levelStr = metadata.level.toUpperCase();
-  if (colorize) {
-    const color = COLORS[metadata.level];
-    parts.push(`${color}(${levelStr})${COLORS.reset}:`);
-  } else {
-    parts.push(`(${levelStr}):`);
-  }
-  if (colorize) {
-    parts.push(`${COLORS.bright}${metadata.message}${COLORS.reset}`);
-  } else {
-    parts.push(metadata.message);
+  if (minSize !== void 0 && file.size < minSize) {
+    errors.push({
+      path: fieldPath,
+      message: `File size ${formatFileSize(file.size)} is below minimum ${formatFileSize(minSize)}`,
+      value: file.size
+    });
   }
-  let output = parts.join(" ");
-  if (metadata.error) {
-    output += "\n" + formatError(metadata.error);
+  if (allowedTypes && allowedTypes.length > 0 && !allowedTypes.includes(file.type)) {
+    errors.push({
+      path: fieldPath,
+      message: `File type "${file.type}" is not allowed. Allowed: ${allowedTypes.join(", ")}`,
+      value: file.type
+    });
   }
-  return output;
 }
-function formatJSON(metadata) {
-  const obj = {
-    timestamp: formatTimestamp(metadata.timestamp),
-    level: metadata.level,
-    message: metadata.message
-  };
-  if (metadata.module) {
-    obj.module = metadata.module;
-  }
-  if (metadata.context) {
-    obj.context = metadata.context;
-  }
-  if (metadata.error) {
-    obj.error = {
-      name: metadata.error.name,
-      message: metadata.error.message,
-      stack: metadata.error.stack
-    };
+function validateField(schema, rawValue, fieldName) {
+  if (!schema) {
+    return {};
+  }
+  const converted = Value.Convert(schema, rawValue);
+  const errors = [...Value.Errors(schema, converted)];
+  if (errors.length > 0) {
+    throw new ValidationError({
+      message: `Invalid ${fieldName}`,
+      fields: errors.map((e) => ({
+        path: e.path,
+        message: e.message,
+        value: e.value
+      }))
+    });
   }
-  return JSON.stringify(obj);
+  return converted;
 }
-var SENSITIVE_KEYS, MASKED_VALUE, COLORS;
-var init_formatters = __esm({
-  "src/logger/formatters.ts"() {
-    SENSITIVE_KEYS = [
-      "password",
-      "passwd",
-      "pwd",
-      "secret",
-      "token",
-      "apikey",
-      "api_key",
-      "accesstoken",
-      "access_token",
-      "refreshtoken",
-      "refresh_token",
-      "authorization",
-      "auth",
-      "cookie",
-      "session",
-      "sessionid",
-      "session_id",
-      "privatekey",
-      "private_key",
-      "creditcard",
-      "credit_card",
-      "cardnumber",
-      "card_number",
-      "cvv",
-      "ssn",
-      "pin"
-    ];
-    MASKED_VALUE = "***MASKED***";
-    COLORS = {
-      reset: "\x1B[0m",
-      bright: "\x1B[1m",
-      dim: "\x1B[2m",
-      // 로그 레벨 컬러
-      debug: "\x1B[36m",
-      // cyan
-      info: "\x1B[32m",
-      // green
-      warn: "\x1B[33m",
-      // yellow
-      error: "\x1B[31m",
-      // red
-      fatal: "\x1B[35m",
-      // magenta
-      // 추가 컬러
-      gray: "\x1B[90m"
-    };
-  }
-});
-
-// src/logger/logger.ts
-var Logger;
-var init_logger = __esm({
-  "src/logger/logger.ts"() {
-    init_types();
-    init_formatters();
-    Logger = class _Logger {
-      config;
-      module;
-      constructor(config) {
-        this.config = config;
-        this.module = config.module;
-      }
-      /**
-       * Get current log level
-       */
-      get level() {
-        return this.config.level;
-      }
-      /**
-       * Create child logger (per module)
-       */
-      child(module) {
-        return new _Logger({
-          ...this.config,
-          module
+function validateFormData(schema, rawValue, fieldName) {
+  if (!schema) {
+    return {};
+  }
+  const schemaProps = schema.properties;
+  if (!schemaProps) {
+    return rawValue;
+  }
+  const result = {};
+  const nonFileData = {};
+  const nonFileSchema = {};
+  const fileErrors = [];
+  for (const [key, value] of Object.entries(rawValue)) {
+    const propSchema = schemaProps[key];
+    if (propSchema && isFileSchemaDef(propSchema)) {
+      result[key] = value;
+      if (isFile(value)) {
+        const fileOptions = getSchemaFileOptions(propSchema);
+        validateSingleFile(value, `/${key}`, fileOptions, fileErrors);
+      }
+    } else if (propSchema && isFileArraySchemaDef(propSchema)) {
+      result[key] = value;
+      const fileOptions = getSchemaFileOptions(propSchema);
+      const files = Array.isArray(value) ? value : [value];
+      const fileArray = files.filter(isFile);
+      if (fileOptions?.maxFiles !== void 0 && fileArray.length > fileOptions.maxFiles) {
+        fileErrors.push({
+          path: `/${key}`,
+          message: `Too many files. Maximum: ${fileOptions.maxFiles}, received: ${fileArray.length}`,
+          value: fileArray.length
         });
       }
-      /**
-       * 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}
-`);
+      if (fileOptions?.minFiles !== void 0 && fileArray.length < fileOptions.minFiles) {
+        fileErrors.push({
+          path: `/${key}`,
+          message: `Too few files. Minimum: ${fileOptions.minFiles}, received: ${fileArray.length}`,
+          value: fileArray.length
         });
       }
-      /**
-       * 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);
+      fileArray.forEach((file, index) => {
+        validateSingleFile(file, `/${key}/${index}`, fileOptions, fileErrors);
+      });
+    } else if (isFile(value) || Array.isArray(value) && value.some(isFile)) {
+      result[key] = value;
+    } else {
+      nonFileData[key] = value;
+      if (propSchema) {
+        nonFileSchema[key] = propSchema;
       }
-    };
+    }
   }
-});
-
-// 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);
-        }
-      }
-    };
+  if (fileErrors.length > 0) {
+    throw new ValidationError({
+      message: `Invalid ${fieldName}`,
+      fields: fileErrors
+    });
   }
-});
-var FileTransport;
-var init_file = __esm({
-  "src/logger/transports/file.ts"() {
-    init_types();
-    init_formatters();
-    FileTransport = class {
-      name = "file";
-      level;
-      enabled;
-      logDir;
-      maxFileSize;
-      maxFiles;
-      currentStream = null;
-      currentFilename = null;
-      constructor(config) {
-        this.level = config.level;
-        this.enabled = config.enabled;
-        this.logDir = config.logDir;
-        this.maxFileSize = config.maxFileSize ?? 10 * 1024 * 1024;
-        this.maxFiles = config.maxFiles ?? 10;
-        if (!existsSync(this.logDir)) {
-          mkdirSync(this.logDir, { recursive: true });
-        }
-      }
-      async log(metadata) {
-        if (!this.enabled) {
-          return;
-        }
-        if (LOG_LEVEL_PRIORITY[metadata.level] < LOG_LEVEL_PRIORITY[this.level]) {
-          return;
-        }
-        const message = formatJSON(metadata);
-        const filename = this.getLogFilename(metadata.timestamp);
-        if (this.currentFilename !== filename) {
-          await this.rotateStream(filename);
-          await this.cleanOldFiles();
-        } else if (this.currentFilename) {
-          await this.checkAndRotateBySize();
-        }
-        if (this.currentStream) {
-          return new Promise((resolve, reject) => {
-            this.currentStream.write(message + "\n", "utf-8", (error) => {
-              if (error) {
-                process.stderr.write(`[FileTransport] Failed to write log: ${error.message}
-`);
-                reject(error);
-              } else {
-                resolve();
-              }
-            });
-          });
-        }
-      }
-      /**
-       * 스트림 교체 (날짜 변경 시)
-       */
-      async rotateStream(filename) {
-        if (this.currentStream) {
-          await this.closeStream();
-        }
-        const filepath = join(this.logDir, filename);
-        this.currentStream = createWriteStream(filepath, {
-          flags: "a",
-          // append mode
-          encoding: "utf-8"
-        });
-        this.currentFilename = filename;
-        this.currentStream.on("error", (error) => {
-          process.stderr.write(`[FileTransport] Stream error: ${error.message}
-`);
-          this.currentStream = null;
-          this.currentFilename = null;
-        });
-      }
-      /**
-       * 현재 스트림 닫기
-       */
-      async closeStream() {
-        if (!this.currentStream) {
-          return;
-        }
-        return new Promise((resolve, reject) => {
-          this.currentStream.end((error) => {
-            if (error) {
-              reject(error);
-            } else {
-              this.currentStream = null;
-              this.currentFilename = null;
-              resolve();
-            }
-          });
-        });
-      }
-      /**
-       * 파일 크기 체크 및 크기 기반 로테이션
-       */
-      async checkAndRotateBySize() {
-        if (!this.currentFilename) {
-          return;
-        }
-        const filepath = join(this.logDir, this.currentFilename);
-        if (!existsSync(filepath)) {
-          return;
-        }
-        try {
-          const stats = statSync(filepath);
-          if (stats.size >= this.maxFileSize) {
-            await this.rotateBySize();
-          }
-        } catch (error) {
-          const errorMessage = error instanceof Error ? error.message : String(error);
-          process.stderr.write(`[FileTransport] Failed to check file size: ${errorMessage}
-`);
-        }
-      }
-      /**
-       * 크기 기반 로테이션 수행
-       * 예: 2025-01-01.log -> 2025-01-01.1.log, 2025-01-01.1.log -> 2025-01-01.2.log
-       */
-      async rotateBySize() {
-        if (!this.currentFilename) {
-          return;
-        }
-        await this.closeStream();
-        const baseName = this.currentFilename.replace(/\.log$/, "");
-        const files = readdirSync(this.logDir);
-        const relatedFiles = files.filter((file) => file.startsWith(baseName) && file.endsWith(".log")).sort().reverse();
-        for (const file of relatedFiles) {
-          const match = file.match(/\.(\d+)\.log$/);
-          if (match) {
-            const oldNum = parseInt(match[1], 10);
-            const newNum = oldNum + 1;
-            const oldPath = join(this.logDir, file);
-            const newPath2 = join(this.logDir, `${baseName}.${newNum}.log`);
-            try {
-              renameSync(oldPath, newPath2);
-            } catch (error) {
-              const errorMessage = error instanceof Error ? error.message : String(error);
-              process.stderr.write(`[FileTransport] Failed to rotate file: ${errorMessage}
-`);
-            }
-          }
-        }
-        const currentPath = join(this.logDir, this.currentFilename);
-        const newPath = join(this.logDir, `${baseName}.1.log`);
-        try {
-          if (existsSync(currentPath)) {
-            renameSync(currentPath, newPath);
-          }
-        } catch (error) {
-          const errorMessage = error instanceof Error ? error.message : String(error);
-          process.stderr.write(`[FileTransport] Failed to rotate current file: ${errorMessage}
-`);
-        }
-        await this.rotateStream(this.currentFilename);
-      }
-      /**
-       * 오래된 로그 파일 정리
-       * maxFiles 개수를 초과하는 로그 파일 삭제
-       */
-      async cleanOldFiles() {
-        try {
-          if (!existsSync(this.logDir)) {
-            return;
-          }
-          const files = readdirSync(this.logDir);
-          const logFiles = files.filter((file) => file.endsWith(".log")).map((file) => {
-            const filepath = join(this.logDir, file);
-            const stats = statSync(filepath);
-            return { file, mtime: stats.mtime };
-          }).sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
-          if (logFiles.length > this.maxFiles) {
-            const filesToDelete = logFiles.slice(this.maxFiles);
-            for (const { file } of filesToDelete) {
-              const filepath = join(this.logDir, file);
-              try {
-                unlinkSync(filepath);
-              } catch (error) {
-                const errorMessage = error instanceof Error ? error.message : String(error);
-                process.stderr.write(`[FileTransport] Failed to delete old file "${file}": ${errorMessage}
-`);
-              }
-            }
-          }
-        } catch (error) {
-          const errorMessage = error instanceof Error ? error.message : String(error);
-          process.stderr.write(`[FileTransport] Failed to clean old files: ${errorMessage}
-`);
-        }
-      }
-      /**
-       * 날짜별 로그 파일명 생성
-       */
-      getLogFilename(date) {
-        const year = date.getFullYear();
-        const month = String(date.getMonth() + 1).padStart(2, "0");
-        const day = String(date.getDate()).padStart(2, "0");
-        return `${year}-${month}-${day}.log`;
-      }
-      async close() {
-        await this.closeStream();
-      }
+  if (Object.keys(nonFileSchema).length > 0) {
+    const tempSchema = {
+      ...schema,
+      properties: nonFileSchema,
+      required: schema.required?.filter((r) => r in nonFileSchema) ?? []
     };
-  }
-});
-function isFileLoggingEnabled() {
-  return process.env.LOGGER_FILE_ENABLED === "true";
-}
-function getDefaultLogLevel() {
-  const isProduction = process.env.NODE_ENV === "production";
-  const isDevelopment = process.env.NODE_ENV === "development";
-  if (isDevelopment) {
-    return "debug";
-  }
-  if (isProduction) {
-    return "info";
-  }
-  return "warn";
-}
-function getConsoleConfig() {
-  const isProduction = process.env.NODE_ENV === "production";
-  return {
-    level: "debug",
-    enabled: true,
-    colorize: !isProduction
-    // Dev: colored output, Production: plain text
-  };
-}
-function getFileConfig() {
-  const isProduction = process.env.NODE_ENV === "production";
-  return {
-    level: "info",
-    enabled: isProduction,
-    // File logging in production only
-    logDir: process.env.LOG_DIR || "./logs",
-    maxFileSize: 10 * 1024 * 1024,
-    // 10MB
-    maxFiles: 10
-  };
-}
-function validateDirectoryWritable(dirPath) {
-  if (!existsSync(dirPath)) {
-    try {
-      mkdirSync(dirPath, { recursive: true });
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      throw new Error(`Failed to create log directory "${dirPath}": ${errorMessage}`);
+    const converted = Value.Convert(tempSchema, nonFileData);
+    const errors = [...Value.Errors(tempSchema, converted)];
+    if (errors.length > 0) {
+      throw new ValidationError({
+        message: `Invalid ${fieldName}`,
+        fields: errors.map((e) => ({
+          path: e.path,
+          message: e.message,
+          value: e.value
+        }))
+      });
     }
+    Object.assign(result, converted);
+  } else {
+    Object.assign(result, nonFileData);
   }
-  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/"`
-    );
-  }
+  return result;
 }
-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 extractQueryParams(c) {
+  const url = new URL(c.req.url);
+  const queryObj = {};
+  url.searchParams.forEach((v, k) => {
+    const existing = queryObj[k];
+    if (existing) {
+      queryObj[k] = Array.isArray(existing) ? [...existing, v] : [existing, v];
+    } else {
+      queryObj[k] = v;
     }
-  }
+  });
+  return queryObj;
 }
-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 extractHeaders(c) {
+  const rawHeaders = {};
+  c.req.raw.headers.forEach((value, key) => {
+    rawHeaders[key.toLowerCase()] = value;
+  });
+  return rawHeaders;
+}
+function extractCookies(c) {
+  const cookieHeader = c.req.header("cookie");
+  const rawCookies = {};
+  if (cookieHeader) {
+    cookieHeader.split(";").forEach((cookie) => {
+      const [key, value] = cookie.trim().split("=");
+      if (key && value) {
+        rawCookies[key] = decodeURIComponent(value);
+      }
+    });
   }
+  return rawCookies;
 }
-function validateConfig() {
+async function parseJsonBody(c) {
   try {
-    validateEnvironment();
-    validateFileConfig();
-    validateSlackConfig();
-    validateEmailConfig();
+    return await c.req.json();
   } 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));
+    throw new ValidationError({
+      message: "Invalid JSON body",
+      fields: [{
+        path: "/",
+        message: "Failed to parse JSON",
+        value: error instanceof Error ? error.message : "Unknown error"
+      }]
+    });
   }
-  return transports;
 }
-function initializeLogger() {
-  validateConfig();
-  return new Logger({
-    level: getDefaultLogLevel(),
-    transports: initializeTransports()
-  });
-}
-var logger;
-var init_factory = __esm({
-  "src/logger/factory.ts"() {
-    init_logger();
-    init_console();
-    init_file();
-    init_config();
-    logger = initializeLogger();
-  }
-});
-
-// src/logger/index.ts
-var init_logger2 = __esm({
-  "src/logger/index.ts"() {
-    init_factory();
-    init_logger();
-  }
-});
-
-// src/route/function-routes.ts
-var function_routes_exports = {};
-__export(function_routes_exports, {
-  discoverFunctionRoutes: () => discoverFunctionRoutes
-});
-function discoverFunctionRoutes(cwd = process.cwd()) {
-  const functions = [];
-  const nodeModulesPath = join(cwd, "node_modules");
+async function parseFormData(c) {
   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)"
-          });
+    const formData = await c.req.formData();
+    const result = {};
+    formData.forEach((value, key) => {
+      const existing = result[key];
+      if (existing !== void 0) {
+        if (Array.isArray(existing)) {
+          existing.push(value);
+        } else {
+          result[key] = [existing, value];
         }
-      } catch (error) {
+      } else {
+        result[key] = value;
       }
-    }
+    });
+    return result;
   } catch (error) {
-    routeLogger.warn("Failed to discover function routes", {
-      error: error instanceof Error ? error.message : "Unknown error"
+    throw new ValidationError({
+      message: "Invalid form data",
+      fields: [{
+        path: "/",
+        message: "Failed to parse form data",
+        value: error instanceof Error ? error.message : "Unknown error"
+      }]
     });
   }
-  return functions;
 }
-var routeLogger;
-var init_function_routes = __esm({
-  "src/route/function-routes.ts"() {
-    init_logger2();
-    routeLogger = logger.child("function-routes");
-  }
-});
 
-// src/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++;
+// src/route/register-routes.ts
+function isRouter(value) {
+  return value !== null && typeof value === "object" && "routes" in value && "_routes" in value;
+}
+function isRouteDef(value) {
+  return value !== null && typeof value === "object" && "handler" in value;
+}
+function isNamedMiddleware(value) {
+  return value !== null && typeof value === "object" && "name" in value && "handler" in value && "_name" in value;
+}
+function registerRoutes(app, router, namedMiddlewares, collectedRoutes) {
+  const routes = collectedRoutes ?? [];
+  const allNamedMiddlewares = [
+    ...namedMiddlewares ?? [],
+    ...router._globalMiddlewares.map((mw) => ({ name: mw.name, handler: mw.handler }))
+  ];
+  for (const [name, routeOrRouter] of Object.entries(router.routes)) {
+    if (isRouter(routeOrRouter)) {
+      registerRoutes(app, routeOrRouter, allNamedMiddlewares, routes);
+    } else if (isRouteDef(routeOrRouter)) {
+      const registered = registerRoute(app, name, routeOrRouter, allNamedMiddlewares);
+      if (registered) {
+        routes.push(registered);
       }
-    }
-    const elapsed = Date.now() - startTime;
-    if (this.debug) {
-      routeLogger2.info("External routes loaded", {
-        package: packageName,
-        prefix: prefix || "/",
-        total: successCount,
-        failed: failureCount,
-        elapsed: `${elapsed}ms`
+    } else {
+      logger.warn(`Unknown route type for "${name}" - skipping`, {
+        type: typeof routeOrRouter
       });
     }
-    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;
-        }
-      }
+  if (router._packageRouters && router._packageRouters.length > 0) {
+    for (const pkgRouter of router._packageRouters) {
+      registerRoutes(app, pkgRouter, allNamedMiddlewares, routes);
     }
-    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;
-    }
+  return routes;
+}
+function registerRoute(app, name, routeDef, namedMiddlewares) {
+  const { method, path, input, middlewares = [], skipMiddlewares, handler } = routeDef;
+  if (!method || !path) {
+    logger.warn(`Route "${name}" is missing method or path - skipping`, {
+      method,
+      path
+    });
+    return null;
   }
-  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);
-        }
-      }
+  const wrappedHandler = async (c) => {
+    const { context, responseMeta } = await createRouteBuilderContext(c, input || {});
+    const result = await handler(context);
+    if (result instanceof Response) {
+      return result;
     }
-    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 (responseMeta.isEmpty) {
+      return c.body(null, responseMeta.status);
     }
-    if (typeof module.default.route !== "function") {
-      routeLogger2.error("Default export is not a Hono instance", { file: relativePath });
-      return false;
+    const hasCustomHeaders = Object.keys(responseMeta.headers).length > 0;
+    if (hasCustomHeaders) {
+      return c.json(result, responseMeta.status, responseMeta.headers);
     }
-    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);
-        });
+    return c.json(result, responseMeta.status);
+  };
+  const allMiddlewares = [];
+  const registeredNames = /* @__PURE__ */ new Set();
+  const registeredHandlers = /* @__PURE__ */ new Set();
+  const skipAll = skipMiddlewares === "*";
+  if (namedMiddlewares && namedMiddlewares.length > 0) {
+    if (skipAll) {
+      logger.debug(`\u23ED\uFE0F  Skipping all middlewares (*) for route: ${method} ${path}`, { name });
+    } else {
+      const skipSet = new Set(Array.isArray(skipMiddlewares) ? skipMiddlewares : []);
+      for (const middleware of namedMiddlewares) {
+        if (!skipSet.has(middleware.name)) {
+          allMiddlewares.push(middleware.handler);
+          registeredNames.add(middleware.name);
+          registeredHandlers.add(middleware.handler);
+        } else {
+          logger.debug(`\u23ED\uFE0F  Skipping middleware '${middleware.name}' for route: ${method} ${path}`, { name });
+        }
       }
     }
   }
-  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"
-      });
+  for (const mw of middlewares) {
+    if (isNamedMiddleware(mw)) {
+      if (registeredNames.has(mw.name)) {
+        logger.debug(`\u{1F504} Skipping duplicate middleware '${mw.name}' for route: ${method} ${path}`, { name });
+        continue;
+      }
+      registeredNames.add(mw.name);
+      allMiddlewares.push(mw.handler);
     } 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, count]) => `${tag}(${count})`).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"
-          });
-        }
+      if (registeredHandlers.has(mw)) {
+        logger.debug(`\u{1F504} Skipping duplicate middleware handler for route: ${method} ${path}`, { name });
+        continue;
       }
+      registeredHandlers.add(mw);
+      allMiddlewares.push(mw);
     }
   }
-  return stats;
-}
-
-// src/errors/http-errors.ts
-var HttpError = class extends Error {
-  statusCode;
-  details;
-  timestamp;
-  constructor(message, statusCode, details) {
-    super(message);
-    this.name = "HttpError";
-    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()
-    };
-  }
-};
-var ValidationError = class extends HttpError {
-  constructor(message, details) {
-    super(message, 400, details);
-    this.name = "ValidationError";
+  const methodLower = method.toLowerCase();
+  if (allMiddlewares.length > 0) {
+    app[methodLower](path, ...allMiddlewares, wrappedHandler);
+  } else {
+    app[methodLower](path, wrappedHandler);
   }
-};
-
-// src/route/bind.ts
-init_logger2();
-function bind(contract, handler) {
-  return async (rawContext) => {
-    let params = rawContext.req.param();
-    if (contract.params) {
-      params = Value.Convert(contract.params, params);
-      const errors = [...Value.Errors(contract.params, params)];
-      if (errors.length > 0) {
-        throw new ValidationError(
-          "Invalid path parameters",
-          {
-            fields: errors.map((e) => ({
-              path: e.path,
-              message: e.message,
-              value: e.value
-            }))
-          }
-        );
-      }
-    }
-    const url = new URL(rawContext.req.url);
-    let query = {};
-    url.searchParams.forEach((v, k) => {
-      const existing = query[k];
-      if (existing) {
-        query[k] = Array.isArray(existing) ? [...existing, v] : [existing, v];
-      } else {
-        query[k] = v;
-      }
-    });
-    if (contract.query) {
-      query = Value.Convert(contract.query, query);
-      const errors = [...Value.Errors(contract.query, query)];
-      if (errors.length > 0) {
-        throw new ValidationError(
-          "Invalid query parameters",
-          {
-            fields: errors.map((e) => ({
-              path: e.path,
-              message: e.message,
-              value: e.value
-            }))
-          }
-        );
-      }
+  logger.debug(`Registered route: ${method} ${path}`, { name });
+  return { method, path, name };
+}
+async function createRouteBuilderContext(c, input) {
+  const params = validateField(input.params, c.req.param(), "path parameters");
+  const query = validateField(input.query, extractQueryParams(c), "query parameters");
+  const headers = validateField(input.headers, extractHeaders(c), "headers");
+  const cookies = validateField(input.cookies, extractCookies(c), "cookies");
+  let body = {};
+  let formData = {};
+  if (input.body || input.formData) {
+    const contentType = c.req.header("content-type") || "";
+    if (contentType.includes("multipart/form-data") && input.formData) {
+      const rawFormData = await parseFormData(c);
+      formData = validateFormData(input.formData, rawFormData, "form data");
+    } else if (input.body) {
+      const rawBody = await parseJsonBody(c);
+      body = validateField(input.body, rawBody, "request body");
     }
-    const routeContext = {
-      params,
-      query,
-      data: async () => {
-        let body = await rawContext.req.json();
-        if (contract.body) {
-          body = Value.Convert(contract.body, body);
-          const errors = [...Value.Errors(contract.body, body)];
-          if (errors.length > 0) {
-            throw new ValidationError(
-              "Invalid request body",
-              {
-                fields: errors.map((e) => ({
-                  path: e.path,
-                  message: e.message,
-                  value: e.value
-                }))
-              }
-            );
-          }
-        }
-        return body;
-      },
-      json: (data, status, headers) => {
-        const errorHandlerEnabled = rawContext.get("errorHandlerEnabled");
-        if (errorHandlerEnabled && process.env.NODE_ENV !== "production") {
-          const hasSuccessField = data && typeof data === "object" && "success" in data;
-          if (!hasSuccessField) {
-            logger.warn(
-              "ErrorHandler is enabled but c.json() is being used with non-standard response format.\nConsider using c.success() for consistent API responses, or disable ErrorHandler if you prefer custom formats."
-            );
-          }
-        }
-        return rawContext.json(data, status, headers);
-      },
-      success: (data, meta, status = 200) => {
-        const response = {
-          success: true,
-          data
-        };
-        if (meta) {
-          response.meta = meta;
-        }
-        return rawContext.json(response, status);
-      },
-      paginated: (data, page, limit, total) => {
-        const response = {
-          success: true,
-          data,
-          meta: {
-            pagination: {
-              page,
-              limit,
-              total,
-              totalPages: Math.ceil(total / limit)
-            }
-          }
-        };
-        return rawContext.json(response, 200);
-      },
-      raw: rawContext
-    };
-    return handler(routeContext);
+  }
+  let cachedData = null;
+  const responseMeta = {
+    status: 200,
+    headers: {},
+    isEmpty: false
   };
-}
-
-// 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
+  const context = {
+    data: async () => {
+      if (!cachedData) {
+        cachedData = { params, query, body, formData, headers, cookies };
+      }
+      return cachedData;
+    },
+    json: (data, status, resHeaders) => {
+      return c.json(data, status, resHeaders);
+    },
+    created: (data, location) => {
+      responseMeta.status = 201;
+      if (location) {
+        responseMeta.headers["Location"] = location;
+      }
+      return data;
+    },
+    accepted: (data) => {
+      responseMeta.status = 202;
+      if (data === void 0) {
+        responseMeta.isEmpty = true;
+        return void 0;
+      }
+      return data;
+    },
+    noContent: () => {
+      responseMeta.status = 204;
+      responseMeta.isEmpty = true;
+    },
+    notModified: () => {
+      responseMeta.status = 304;
+      responseMeta.isEmpty = true;
+    },
+    paginated: (data, page, limit, total) => {
+      return {
+        items: data,
+        pagination: {
+          page,
+          limit,
+          total,
+          totalPages: Math.ceil(total / limit)
+        }
       };
-      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);
+    },
+    redirect: (url, status) => {
+      return c.redirect(url, status);
+    },
+    raw: c
   };
+  return { context, responseMeta };
 }
 
-// src/middleware/request-logger.ts
-init_logger2();
-
-// src/route/create-app.ts
-function createApp() {
-  const hono = new Hono();
-  const app = hono;
-  app._contractMetas = /* @__PURE__ */ new Map();
-  app.onError(ErrorHandler());
-  const methodMap = /* @__PURE__ */ new Map([
-    ["get", (path, handlers) => hono.get(path, ...handlers)],
-    ["post", (path, handlers) => hono.post(path, ...handlers)],
-    ["put", (path, handlers) => hono.put(path, ...handlers)],
-    ["patch", (path, handlers) => hono.patch(path, ...handlers)],
-    ["delete", (path, handlers) => hono.delete(path, ...handlers)]
-  ]);
-  app.bind = function(contract, ...args) {
-    const method = contract.method.toLowerCase();
-    const path = contract.path;
-    const [middlewares, handler] = args.length === 1 ? [[], args[0]] : [args[0], args[1]];
-    const key = `${contract.method} ${path}`;
-    app._contractMetas.set(key, contract.meta || {});
-    const boundHandler = bind(contract, handler);
-    const handlers = middlewares.length > 0 ? [...middlewares, boundHandler] : [boundHandler];
-    const registerMethod = methodMap.get(method);
-    if (!registerMethod) {
-      throw new Error(`Unsupported HTTP method: ${contract.method}`);
+// src/route/define-middleware.ts
+function defineMiddleware(name, handlerOrFactory) {
+  if (typeof handlerOrFactory === "function") {
+    const paramCount = handlerOrFactory.length;
+    if (paramCount === 2) {
+      return {
+        name,
+        handler: handlerOrFactory,
+        _name: name
+      };
+    } else {
+      const factory = handlerOrFactory;
+      const wrapper = (...args) => factory(...args);
+      Object.defineProperty(wrapper, "name", {
+        value: name,
+        writable: false,
+        enumerable: false,
+        configurable: true
+      });
+      Object.defineProperty(wrapper, "_name", {
+        value: name,
+        writable: false,
+        enumerable: false,
+        configurable: true
+      });
+      return wrapper;
     }
-    registerMethod(path, handlers);
+  }
+  return {
+    name,
+    handler: handlerOrFactory,
+    _name: name
   };
-  return app;
 }
-function ApiSuccessSchema(dataSchema) {
-  return Type.Object({
-    success: Type.Literal(true),
-    data: dataSchema,
-    meta: Type.Optional(Type.Object({
-      timestamp: Type.Optional(Type.String()),
-      requestId: Type.Optional(Type.String()),
-      pagination: Type.Optional(Type.Object({
-        page: Type.Number(),
-        limit: Type.Number(),
-        total: Type.Number(),
-        totalPages: Type.Number()
-      }))
-    }))
+function defineMiddlewareFactory(name, factory) {
+  const wrapper = (...args) => factory(...args);
+  Object.defineProperty(wrapper, "name", {
+    value: name,
+    writable: false,
+    enumerable: false,
+    configurable: true
   });
-}
-function ApiErrorSchema() {
-  return Type.Object({
-    success: Type.Literal(false),
-    error: Type.Object({
-      message: Type.String(),
-      type: Type.String(),
-      statusCode: Type.Number(),
-      stack: Type.Optional(Type.String()),
-      details: Type.Optional(Type.Any())
-    })
+  Object.defineProperty(wrapper, "_name", {
+    value: name,
+    writable: false,
+    enumerable: false,
+    configurable: true
   });
+  return wrapper;
 }
-function ApiResponseSchema(dataSchema) {
-  return ApiSuccessSchema(dataSchema);
-}
-
-// src/route/types.ts
 function isHttpMethod(value) {
   return typeof value === "string" && ["GET", "POST", "PUT", "PATCH", "DELETE"].includes(value);
 }
+var Nullable = (schema) => Type.Union([schema, Type.Null()]);
+var OptionalNullable = (schema) => Type.Optional(Type.Union([schema, Type.Null()]));
 
-export { ApiErrorSchema, ApiResponseSchema, ApiSuccessSchema, AutoRouteLoader, bind, createApp, isHttpMethod, loadRoutes };
+export { FileArraySchema, FileSchema, Nullable, OptionalFileSchema, OptionalNullable, defineMiddleware, defineMiddlewareFactory, defineRouter, formatFileSize, getFileOptions, isFileArraySchema, isFileSchema, isHttpMethod, registerRoutes, route };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map