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

package/dist/codegen/index.js

@@ -1,508 +1,256 @@
-import { mkdir, writeFile, readdir, stat } from 'fs/promises';
-import { join, dirname } from 'path';
-import * as ts from 'typescript';
-import { existsSync, mkdirSync, createWriteStream, readFileSync } from 'fs';
 import { watch } from 'chokidar';
+import { join, relative } from 'path';
+import mm from 'micromatch';
 import pino from 'pino';
+import { existsSync, mkdirSync, accessSync, constants, writeFileSync, unlinkSync, createWriteStream, statSync, readdirSync, renameSync, readFileSync } from 'fs';
+import { readdir, stat, mkdir, writeFile } from 'fs/promises';
+import * as ts from 'typescript';
+import { createJiti } from 'jiti';
 
-// src/codegen/contract-scanner.ts
-async function scanContracts(routesDir) {
-  const contractFiles = await scanContractFiles(routesDir);
-  const mappings = [];
-  for (let i = 0; i < contractFiles.length; i++) {
-    const filePath = contractFiles[i];
-    const exports = extractContractExports(filePath);
-    const basePath = getBasePathFromFile(filePath, routesDir);
-    for (let j = 0; j < exports.length; j++) {
-      const contractExport = exports[j];
-      const fullPath = combinePaths(basePath, contractExport.path);
-      mappings.push({
-        method: contractExport.method,
-        path: fullPath,
-        contractName: contractExport.name,
-        contractImportPath: getImportPathFromRoutes(filePath, routesDir),
-        routeFile: "",
-        // Not needed anymore
-        contractFile: filePath
-      });
+// src/codegen/core/orchestrator.ts
+var PinoAdapter = class _PinoAdapter {
+  logger;
+  constructor(config) {
+    this.logger = pino({
+      level: config.level,
+      // 기본 필드
+      base: config.module ? { module: config.module } : void 0
+    });
+  }
+  child(module) {
+    const childLogger = new _PinoAdapter({ level: this.logger.level, module });
+    childLogger.logger = this.logger.child({ module });
+    return childLogger;
+  }
+  debug(message, context) {
+    this.logger.debug(context || {}, message);
+  }
+  info(message, context) {
+    this.logger.info(context || {}, message);
+  }
+  warn(message, errorOrContext, context) {
+    if (errorOrContext instanceof Error) {
+      this.logger.warn({ err: errorOrContext, ...context }, message);
+    } else {
+      this.logger.warn(errorOrContext || {}, message);
     }
   }
-  return mappings;
-}
-async function scanContractFiles(dir, files = []) {
-  try {
-    const entries = await readdir(dir);
-    for (let i = 0; i < entries.length; i++) {
-      const entry = entries[i];
-      const fullPath = join(dir, entry);
-      const fileStat = await stat(fullPath);
-      if (fileStat.isDirectory()) {
-        await scanContractFiles(fullPath, files);
-      } else if (entry === "contract.ts") {
-        files.push(fullPath);
-      }
+  error(message, errorOrContext, context) {
+    if (errorOrContext instanceof Error) {
+      this.logger.error({ err: errorOrContext, ...context }, message);
+    } else {
+      this.logger.error(errorOrContext || {}, message);
     }
-  } catch (error) {
   }
-  return files;
-}
-function extractContractExports(filePath) {
-  const sourceCode = readFileSync(filePath, "utf-8");
-  const sourceFile = ts.createSourceFile(
-    filePath,
-    sourceCode,
-    ts.ScriptTarget.Latest,
-    true
-  );
-  const exports = [];
-  function visit(node) {
-    if (ts.isVariableStatement(node)) {
-      const hasExport = node.modifiers?.some(
-        (m) => m.kind === ts.SyntaxKind.ExportKeyword
-      );
-      if (hasExport && node.declarationList.declarations.length > 0) {
-        const declaration = node.declarationList.declarations[0];
-        if (ts.isVariableDeclaration(declaration) && ts.isIdentifier(declaration.name) && declaration.initializer && ts.isObjectLiteralExpression(declaration.initializer)) {
-          const name = declaration.name.text;
-          if (isContractName(name)) {
-            const contractData = extractContractData(declaration.initializer);
-            if (contractData.method && contractData.path) {
-              exports.push({
-                name,
-                method: contractData.method,
-                path: contractData.path
-              });
-            }
-          }
-        }
-      }
+  fatal(message, errorOrContext, context) {
+    if (errorOrContext instanceof Error) {
+      this.logger.fatal({ err: errorOrContext, ...context }, message);
+    } else {
+      this.logger.fatal(errorOrContext || {}, message);
     }
-    ts.forEachChild(node, visit);
   }
-  visit(sourceFile);
-  return exports;
+  async close() {
+  }
+};
+
+// src/logger/types.ts
+var LOG_LEVEL_PRIORITY = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3,
+  fatal: 4
+};
+
+// src/logger/formatters.ts
+var 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"
+];
+var MASKED_VALUE = "***MASKED***";
+function isSensitiveKey(key) {
+  const lowerKey = key.toLowerCase();
+  return SENSITIVE_KEYS.some((sensitive) => lowerKey.includes(sensitive));
 }
-function extractContractData(objectLiteral) {
-  const result = {};
-  for (let i = 0; i < objectLiteral.properties.length; i++) {
-    const prop = objectLiteral.properties[i];
-    if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
-      const propName = prop.name.text;
-      if (propName === "method") {
-        let value;
-        if (ts.isStringLiteral(prop.initializer)) {
-          value = prop.initializer.text;
-        } else if (ts.isAsExpression(prop.initializer) && ts.isStringLiteral(prop.initializer.expression)) {
-          value = prop.initializer.expression.text;
-        }
-        if (value) result.method = value;
-      } else if (propName === "path") {
-        let value;
-        if (ts.isStringLiteral(prop.initializer)) {
-          value = prop.initializer.text;
-        } else if (ts.isAsExpression(prop.initializer) && ts.isStringLiteral(prop.initializer.expression)) {
-          value = prop.initializer.expression.text;
-        }
-        if (value) result.path = value;
+function maskSensitiveData(data) {
+  if (data === null || data === void 0) {
+    return data;
+  }
+  if (Array.isArray(data)) {
+    return data.map((item) => maskSensitiveData(item));
+  }
+  if (typeof data === "object") {
+    const masked = {};
+    for (const [key, value] of Object.entries(data)) {
+      if (isSensitiveKey(key)) {
+        masked[key] = MASKED_VALUE;
+      } else if (typeof value === "object" && value !== null) {
+        masked[key] = maskSensitiveData(value);
+      } else {
+        masked[key] = value;
       }
     }
+    return masked;
   }
-  return result;
+  return data;
 }
-function isContractName(name) {
-  return name.indexOf("Contract") !== -1 || name.indexOf("contract") !== -1 || name.endsWith("Schema") || name.endsWith("schema");
+var 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"
+};
+function formatTimestamp(date) {
+  return date.toISOString();
+}
+function formatTimestampHuman(date) {
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  const hours = String(date.getHours()).padStart(2, "0");
+  const minutes = String(date.getMinutes()).padStart(2, "0");
+  const seconds = String(date.getSeconds()).padStart(2, "0");
+  const ms = String(date.getMilliseconds()).padStart(3, "0");
+  return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}.${ms}`;
 }
-function getBasePathFromFile(filePath, routesDir) {
-  let relativePath = filePath.replace(routesDir, "");
-  if (relativePath.startsWith("/")) {
-    relativePath = relativePath.slice(1);
+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);
   }
-  relativePath = relativePath.replace("/contract.ts", "");
-  if (relativePath === "index" || relativePath === "") {
-    return "/";
+  return lines.join("\n");
+}
+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}]`);
   }
-  const segments = relativePath.split("/");
-  const transformed = [];
-  for (let i = 0; i < segments.length; i++) {
-    const seg = segments[i];
-    if (seg === "index") {
-      continue;
-    }
-    if (seg.startsWith("[") && seg.endsWith("]")) {
-      transformed.push(":" + seg.slice(1, -1));
+  if (metadata.module) {
+    if (colorize) {
+      parts.push(`${COLORS.dim}[module=${metadata.module}]${COLORS.reset}`);
     } else {
-      transformed.push(seg);
+      parts.push(`[module=${metadata.module}]`);
     }
   }
-  if (transformed.length === 0) {
-    return "/";
+  if (metadata.context && Object.keys(metadata.context).length > 0) {
+    Object.entries(metadata.context).forEach(([key, value]) => {
+      const valueStr = typeof value === "string" ? value : String(value);
+      if (colorize) {
+        parts.push(`${COLORS.dim}[${key}=${valueStr}]${COLORS.reset}`);
+      } else {
+        parts.push(`[${key}=${valueStr}]`);
+      }
+    });
   }
-  return "/" + transformed.join("/");
-}
-function combinePaths(basePath, contractPath) {
-  basePath = basePath || "/";
-  contractPath = contractPath || "/";
-  if (basePath.endsWith("/") && basePath !== "/") {
-    basePath = basePath.slice(0, -1);
+  const levelStr = metadata.level.toUpperCase();
+  if (colorize) {
+    const color = COLORS[metadata.level];
+    parts.push(`${color}(${levelStr})${COLORS.reset}:`);
+  } else {
+    parts.push(`(${levelStr}):`);
   }
-  if (contractPath.startsWith("/") && contractPath !== "/") {
-    if (basePath === "/") {
-      return contractPath;
-    }
-    return basePath + contractPath;
+  if (colorize) {
+    parts.push(`${COLORS.bright}${metadata.message}${COLORS.reset}`);
+  } else {
+    parts.push(metadata.message);
   }
-  if (contractPath === "/") {
-    return basePath;
+  let output = parts.join(" ");
+  if (metadata.error) {
+    output += "\n" + formatError(metadata.error);
   }
-  return basePath + "/" + contractPath;
+  return output;
 }
-function getImportPathFromRoutes(filePath, routesDir) {
-  let relativePath = filePath.replace(routesDir, "");
-  if (relativePath.startsWith("/")) {
-    relativePath = relativePath.slice(1);
+function formatJSON(metadata) {
+  const obj = {
+    timestamp: formatTimestamp(metadata.timestamp),
+    level: metadata.level,
+    message: metadata.message
+  };
+  if (metadata.module) {
+    obj.module = metadata.module;
   }
-  if (relativePath.endsWith(".ts")) {
-    relativePath = relativePath.slice(0, -3);
+  if (metadata.context) {
+    obj.context = metadata.context;
   }
-  return "@/server/routes/" + relativePath;
-}
-
-// src/codegen/route-scanner.ts
-function groupByResource(mappings) {
-  const grouped = {};
-  for (let i = 0; i < mappings.length; i++) {
-    const mapping = mappings[i];
-    const resource = extractResourceName(mapping.path);
-    if (!grouped[resource]) {
-      grouped[resource] = [];
-    }
-    grouped[resource].push(mapping);
+  if (metadata.error) {
+    obj.error = {
+      name: metadata.error.name,
+      message: metadata.error.message,
+      stack: metadata.error.stack
+    };
   }
-  return grouped;
+  return JSON.stringify(obj);
 }
-function extractResourceName(path) {
-  const segments = path.slice(1).split("/").filter((s) => s && s !== "*");
-  const staticSegments = [];
-  for (let i = 0; i < segments.length; i++) {
-    const seg = segments[i];
-    if (!seg.startsWith(":")) {
-      staticSegments.push(seg);
-    }
+
+// src/logger/logger.ts
+var Logger = class _Logger {
+  config;
+  module;
+  constructor(config) {
+    this.config = config;
+    this.module = config.module;
   }
-  if (staticSegments.length === 0) {
-    return "root";
+  /**
+   * Get current log level
+   */
+  get level() {
+    return this.config.level;
   }
-  if (staticSegments.length === 1) {
-    return staticSegments[0];
+  /**
+   * Create child logger (per module)
+   */
+  child(module) {
+    return new _Logger({
+      ...this.config,
+      module
+    });
   }
-  const result = [staticSegments[0]];
-  for (let i = 1; i < staticSegments.length; i++) {
-    const seg = staticSegments[i];
-    result.push(seg.charAt(0).toUpperCase() + seg.slice(1));
-  }
-  return result.join("");
-}
-async function generateClient(mappings, options) {
-  const startTime = Date.now();
-  const grouped = groupByResource(mappings);
-  const resourceNames = Object.keys(grouped);
-  const code = generateClientCode(mappings, grouped, options);
-  await mkdir(dirname(options.outputPath), { recursive: true });
-  await writeFile(options.outputPath, code, "utf-8");
-  const stats = {
-    routesScanned: mappings.length,
-    contractsFound: mappings.length,
-    contractFiles: countUniqueContractFiles(mappings),
-    resourcesGenerated: resourceNames.length,
-    methodsGenerated: mappings.length,
-    duration: Date.now() - startTime
-  };
-  return stats;
-}
-function generateClientCode(mappings, grouped, options) {
-  let code = "";
-  code += generateHeader();
-  code += generateImports(mappings, options);
-  code += generateApiObject(grouped, options);
-  code += generateFooter();
-  return code;
-}
-function generateHeader() {
-  return `/**
- * Auto-generated API Client
- *
- * Generated by @spfn/core codegen
- * DO NOT EDIT MANUALLY
- *
- * @generated ${(/* @__PURE__ */ new Date()).toISOString()}
- */
-
-`;
-}
-function generateImports(mappings, options) {
-  let code = "";
-  code += `import { client } from '@spfn/core/client';
-`;
-  if (options.includeTypes !== false) {
-    code += `import type { InferContract } from '@spfn/core';
-`;
-  }
-  code += `
-`;
-  const importGroups = groupContractsByImportPath(mappings);
-  const importPaths = Object.keys(importGroups);
-  for (let i = 0; i < importPaths.length; i++) {
-    const importPath = importPaths[i];
-    const contracts = importGroups[importPath];
-    code += `import { ${contracts.join(", ")} } from '${importPath}';
-`;
-  }
-  code += `
-`;
-  return code;
-}
-function groupContractsByImportPath(mappings) {
-  const groups = {};
-  for (let i = 0; i < mappings.length; i++) {
-    const mapping = mappings[i];
-    const path = mapping.contractImportPath;
-    if (!groups[path]) {
-      groups[path] = /* @__PURE__ */ new Set();
-    }
-    groups[path].add(mapping.contractName);
-  }
-  const result = {};
-  const keys = Object.keys(groups);
-  for (let i = 0; i < keys.length; i++) {
-    const key = keys[i];
-    result[key] = Array.from(groups[key]);
-  }
-  return result;
-}
-function generateApiObject(grouped, options) {
-  let code = "";
-  code += `/**
- * Type-safe API client
- */
-export const api = {
-`;
-  const resourceNames = Object.keys(grouped);
-  for (let i = 0; i < resourceNames.length; i++) {
-    const resourceName = resourceNames[i];
-    const routes = grouped[resourceName];
-    code += `    ${resourceName}: {
-`;
-    for (let j = 0; j < routes.length; j++) {
-      const route = routes[j];
-      code += generateMethodCode(route, options);
-    }
-    code += `    }`;
-    if (i < resourceNames.length - 1) {
-      code += `,`;
-    }
-    code += `
-`;
-  }
-  code += `} as const;
-
-`;
-  return code;
-}
-function generateMethodCode(mapping, options) {
-  const methodName = generateMethodName(mapping);
-  const contractType = `typeof ${mapping.contractName}`;
-  const hasParams = mapping.path.includes(":");
-  const hasBody = ["POST", "PUT", "PATCH"].indexOf(mapping.method) !== -1;
-  let code = "";
-  if (options.includeJsDoc !== false) {
-    code += `        /**
-`;
-    code += `         * ${mapping.method} ${mapping.path}
-`;
-    code += `         */
-`;
-  }
-  code += `        ${methodName}: (`;
-  const params = [];
-  if (hasParams) {
-    params.push(`params: InferContract<${contractType}>['params']`);
-  }
-  if (hasBody) {
-    params.push(`body: InferContract<${contractType}>['body']`);
-  }
-  if (params.length > 0) {
-    code += `options: { ${params.join(", ")} }`;
-  }
-  code += `) => `;
-  code += `client.call('${mapping.path}', ${mapping.contractName}, `;
-  if (params.length > 0) {
-    code += `options`;
-  } else {
-    code += `{}`;
-  }
-  code += `),
-`;
-  return code;
-}
-function generateMethodName(mapping) {
-  const method = mapping.method.toLowerCase();
-  if (mapping.path === "/" || mapping.path.match(/^\/[\w-]+$/)) {
-    if (method === "get") {
-      return "list";
-    }
-    if (method === "post") {
-      return "create";
-    }
-  }
-  if (mapping.path.includes(":")) {
-    if (method === "get") {
-      return "getById";
-    }
-    if (method === "put" || method === "patch") {
-      return "update";
-    }
-    if (method === "delete") {
-      return "delete";
-    }
-  }
-  return method;
-}
-function generateFooter() {
-  return `/**
- * Export client instance for advanced usage
- *
- * Use this to add interceptors or customize the client:
- *
- * @example
- * \`\`\`ts
- * import { client } from './api';
- * import { createAuthInterceptor } from '@spfn/auth/nextjs';
- * import { NextJSCookieProvider } from '@spfn/auth/nextjs';
- *
- * client.use(createAuthInterceptor({
- *   cookieProvider: new NextJSCookieProvider(),
- *   encryptionKey: process.env.ENCRYPTION_KEY!
- * }));
- * \`\`\`
- */
-export { client };
-`;
-}
-function countUniqueContractFiles(mappings) {
-  const files = /* @__PURE__ */ new Set();
-  for (let i = 0; i < mappings.length; i++) {
-    if (mappings[i].contractFile) {
-      files.add(mappings[i].contractFile);
-    }
-  }
-  return files.size;
-}
-var PinoAdapter = class _PinoAdapter {
-  logger;
-  constructor(config) {
-    const isProduction = process.env.NODE_ENV === "production";
-    const isDevelopment = process.env.NODE_ENV === "development";
-    const fileLoggingEnabled = process.env.LOGGER_FILE_ENABLED === "true";
-    const targets = [];
-    if (!isProduction && isDevelopment) {
-      targets.push({
-        target: "pino-pretty",
-        level: "debug",
-        options: {
-          colorize: true,
-          translateTime: "SYS:yyyy-mm-dd HH:MM:ss.l",
-          ignore: "pid,hostname"
-        }
-      });
-    }
-    if (fileLoggingEnabled && isProduction) {
-      const logDir = process.env.LOG_DIR || "./logs";
-      const maxFileSize = process.env.LOG_MAX_FILE_SIZE || "10M";
-      const maxFiles = parseInt(process.env.LOG_MAX_FILES || "10", 10);
-      targets.push({
-        target: "pino-roll",
-        level: "info",
-        options: {
-          file: `${logDir}/app.log`,
-          frequency: "daily",
-          size: maxFileSize,
-          limit: { count: maxFiles },
-          mkdir: true
-        }
-      });
-    }
-    this.logger = pino({
-      level: config.level,
-      // Transport 설정 (targets가 있으면 사용, 없으면 기본 stdout)
-      transport: targets.length > 0 ? { targets } : void 0,
-      // 기본 필드
-      base: config.module ? { module: config.module } : void 0
-    });
-  }
-  child(module) {
-    const childLogger = new _PinoAdapter({ level: this.logger.level, module });
-    childLogger.logger = this.logger.child({ module });
-    return childLogger;
-  }
-  debug(message, context) {
-    this.logger.debug(context || {}, message);
-  }
-  info(message, context) {
-    this.logger.info(context || {}, message);
-  }
-  warn(message, errorOrContext, context) {
-    if (errorOrContext instanceof Error) {
-      this.logger.warn({ err: errorOrContext, ...context }, message);
-    } else {
-      this.logger.warn(errorOrContext || {}, message);
-    }
-  }
-  error(message, errorOrContext, context) {
-    if (errorOrContext instanceof Error) {
-      this.logger.error({ err: errorOrContext, ...context }, message);
-    } else {
-      this.logger.error(errorOrContext || {}, message);
-    }
-  }
-  fatal(message, errorOrContext, context) {
-    if (errorOrContext instanceof Error) {
-      this.logger.fatal({ err: errorOrContext, ...context }, message);
-    } else {
-      this.logger.fatal(errorOrContext || {}, message);
-    }
-  }
-  async close() {
-  }
-};
-
-// src/logger/logger.ts
-var 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);
+  /**
+   * Debug log
+   */
+  debug(message, context) {
+    this.log("debug", message, void 0, context);
   }
   /**
    * Info log
@@ -535,13 +283,17 @@ var Logger = class _Logger {
    * Log processing (internal)
    */
   log(level, message, error, context) {
+    if (LOG_LEVEL_PRIORITY[level] < LOG_LEVEL_PRIORITY[this.config.level]) {
+      return;
+    }
     const metadata = {
       timestamp: /* @__PURE__ */ new Date(),
       level,
       message,
       module: this.module,
       error,
-      context
+      // Mask sensitive information in context to prevent credential leaks
+      context: context ? maskSensitiveData(context) : void 0
     };
     this.processTransports(metadata);
   }
@@ -577,157 +329,47 @@ var Logger = class _Logger {
   }
 };
 
-// src/logger/types.ts
-var LOG_LEVEL_PRIORITY = {
-  debug: 0,
-  info: 1,
-  warn: 2,
-  error: 3,
-  fatal: 4
-};
-
-// src/logger/formatters.ts
-var 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"
-};
-function colorizeLevel(level) {
-  const color = COLORS[level];
-  const levelStr = level.toUpperCase().padEnd(5);
-  return `${color}${levelStr}${COLORS.reset}`;
-}
-function formatTimestamp(date) {
-  return date.toISOString();
-}
-function formatTimestampHuman(date) {
-  const year = date.getFullYear();
-  const month = String(date.getMonth() + 1).padStart(2, "0");
-  const day = String(date.getDate()).padStart(2, "0");
-  const hours = String(date.getHours()).padStart(2, "0");
-  const minutes = String(date.getMinutes()).padStart(2, "0");
-  const seconds = String(date.getSeconds()).padStart(2, "0");
-  const ms = String(date.getMilliseconds()).padStart(3, "0");
-  return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}.${ms}`;
-}
-function formatError(error) {
-  const lines = [];
-  lines.push(`${error.name}: ${error.message}`);
-  if (error.stack) {
-    const stackLines = error.stack.split("\n").slice(1);
-    lines.push(...stackLines);
-  }
-  return lines.join("\n");
-}
-function formatContext(context) {
-  try {
-    return JSON.stringify(context, null, 2);
-  } catch (error) {
-    return "[Context serialization failed]";
-  }
-}
-function formatConsole(metadata, colorize = true) {
-  const parts = [];
-  const timestamp = formatTimestampHuman(metadata.timestamp);
-  if (colorize) {
-    parts.push(`${COLORS.gray}${timestamp}${COLORS.reset}`);
-  } else {
-    parts.push(timestamp);
-  }
-  if (colorize) {
-    parts.push(colorizeLevel(metadata.level));
-  } else {
-    parts.push(metadata.level.toUpperCase().padEnd(5));
-  }
-  if (metadata.module) {
-    if (colorize) {
-      parts.push(`${COLORS.dim}[${metadata.module}]${COLORS.reset}`);
-    } else {
-      parts.push(`[${metadata.module}]`);
-    }
-  }
-  parts.push(metadata.message);
-  let output = parts.join(" ");
-  if (metadata.context && Object.keys(metadata.context).length > 0) {
-    output += "\n" + formatContext(metadata.context);
-  }
-  if (metadata.error) {
-    output += "\n" + formatError(metadata.error);
-  }
-  return output;
-}
-function formatJSON(metadata) {
-  const obj = {
-    timestamp: formatTimestamp(metadata.timestamp),
-    level: metadata.level,
-    message: metadata.message
-  };
-  if (metadata.module) {
-    obj.module = metadata.module;
-  }
-  if (metadata.context) {
-    obj.context = metadata.context;
-  }
-  if (metadata.error) {
-    obj.error = {
-      name: metadata.error.name,
-      message: metadata.error.message,
-      stack: metadata.error.stack
-    };
-  }
-  return JSON.stringify(obj);
-}
-
-// src/logger/transports/console.ts
-var 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);
-    }
-  }
+// src/logger/transports/console.ts
+var 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 = 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 });
     }
@@ -743,6 +385,9 @@ var FileTransport = class {
     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) => {
@@ -798,6 +443,103 @@ var FileTransport = class {
       });
     });
   }
+  /**
+   * 파일 크기 체크 및 크기 기반 로테이션
+   */
+  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}
+`);
+    }
+  }
   /**
    * 날짜별 로그 파일명 생성
    */
@@ -811,8 +553,9 @@ var FileTransport = class {
     await this.closeStream();
   }
 };
-
-// src/logger/config.ts
+function isFileLoggingEnabled() {
+  return process.env.LOGGER_FILE_ENABLED === "true";
+}
 function getDefaultLogLevel() {
   const isProduction = process.env.NODE_ENV === "production";
   const isDevelopment = process.env.NODE_ENV === "development";
@@ -845,6 +588,109 @@ function getFileConfig() {
     maxFiles: 10
   };
 }
+function validateDirectoryWritable(dirPath) {
+  if (!existsSync(dirPath)) {
+    try {
+      mkdirSync(dirPath, { recursive: true });
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      throw new Error(`Failed to create log directory "${dirPath}": ${errorMessage}`);
+    }
+  }
+  try {
+    accessSync(dirPath, constants.W_OK);
+  } catch {
+    throw new Error(`Log directory "${dirPath}" is not writable. Please check permissions.`);
+  }
+  const testFile = join(dirPath, ".logger-write-test");
+  try {
+    writeFileSync(testFile, "test", "utf-8");
+    unlinkSync(testFile);
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    throw new Error(`Cannot write to log directory "${dirPath}": ${errorMessage}`);
+  }
+}
+function validateFileConfig() {
+  if (!isFileLoggingEnabled()) {
+    return;
+  }
+  const logDir = process.env.LOG_DIR;
+  if (!logDir) {
+    throw new Error(
+      "LOG_DIR environment variable is required when LOGGER_FILE_ENABLED=true. Example: LOG_DIR=/var/log/myapp"
+    );
+  }
+  validateDirectoryWritable(logDir);
+}
+function validateSlackConfig() {
+  const webhookUrl = process.env.SLACK_WEBHOOK_URL;
+  if (!webhookUrl) {
+    return;
+  }
+  if (!webhookUrl.startsWith("https://hooks.slack.com/")) {
+    throw new Error(
+      `Invalid SLACK_WEBHOOK_URL: "${webhookUrl}". Slack webhook URLs must start with "https://hooks.slack.com/"`
+    );
+  }
+}
+function validateEmailConfig() {
+  const smtpHost = process.env.SMTP_HOST;
+  const smtpPort = process.env.SMTP_PORT;
+  const emailFrom = process.env.EMAIL_FROM;
+  const emailTo = process.env.EMAIL_TO;
+  const hasAnyEmailConfig = smtpHost || smtpPort || emailFrom || emailTo;
+  if (!hasAnyEmailConfig) {
+    return;
+  }
+  const missingFields = [];
+  if (!smtpHost) missingFields.push("SMTP_HOST");
+  if (!smtpPort) missingFields.push("SMTP_PORT");
+  if (!emailFrom) missingFields.push("EMAIL_FROM");
+  if (!emailTo) missingFields.push("EMAIL_TO");
+  if (missingFields.length > 0) {
+    throw new Error(
+      `Email transport configuration incomplete. Missing: ${missingFields.join(", ")}. Either set all required fields or remove all email configuration.`
+    );
+  }
+  const port = parseInt(smtpPort, 10);
+  if (isNaN(port) || port < 1 || port > 65535) {
+    throw new Error(
+      `Invalid SMTP_PORT: "${smtpPort}". Must be a number between 1 and 65535.`
+    );
+  }
+  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+  if (!emailRegex.test(emailFrom)) {
+    throw new Error(`Invalid EMAIL_FROM format: "${emailFrom}"`);
+  }
+  const recipients = emailTo.split(",").map((e) => e.trim());
+  for (const email of recipients) {
+    if (!emailRegex.test(email)) {
+      throw new Error(`Invalid email address in EMAIL_TO: "${email}"`);
+    }
+  }
+}
+function validateEnvironment() {
+  const nodeEnv = process.env.NODE_ENV;
+  if (!nodeEnv) {
+    process.stderr.write(
+      "[Logger] Warning: NODE_ENV is not set. Defaulting to test environment.\n"
+    );
+  }
+}
+function validateConfig() {
+  try {
+    validateEnvironment();
+    validateFileConfig();
+    validateSlackConfig();
+    validateEmailConfig();
+  } catch (error) {
+    if (error instanceof Error) {
+      throw new Error(`[Logger] Configuration validation failed: ${error.message}`);
+    }
+    throw error;
+  }
+}
 
 // src/logger/adapters/custom.ts
 function initializeTransports() {
@@ -855,161 +701,1065 @@ function initializeTransports() {
   if (fileConfig.enabled) {
     transports.push(new FileTransport(fileConfig));
   }
-  return transports;
+  return transports;
+}
+var CustomAdapter = class _CustomAdapter {
+  logger;
+  constructor(config) {
+    this.logger = new Logger({
+      level: config.level,
+      module: config.module,
+      transports: initializeTransports()
+    });
+  }
+  child(module) {
+    const adapter = new _CustomAdapter({ level: this.logger.level, module });
+    adapter.logger = this.logger.child(module);
+    return adapter;
+  }
+  debug(message, context) {
+    this.logger.debug(message, context);
+  }
+  info(message, context) {
+    this.logger.info(message, context);
+  }
+  warn(message, errorOrContext, context) {
+    if (errorOrContext instanceof Error) {
+      this.logger.warn(message, errorOrContext, context);
+    } else {
+      this.logger.warn(message, errorOrContext);
+    }
+  }
+  error(message, errorOrContext, context) {
+    if (errorOrContext instanceof Error) {
+      this.logger.error(message, errorOrContext, context);
+    } else {
+      this.logger.error(message, errorOrContext);
+    }
+  }
+  fatal(message, errorOrContext, context) {
+    if (errorOrContext instanceof Error) {
+      this.logger.fatal(message, errorOrContext, context);
+    } else {
+      this.logger.fatal(message, errorOrContext);
+    }
+  }
+  async close() {
+    await this.logger.close();
+  }
+};
+
+// src/logger/adapter-factory.ts
+function createAdapter(type) {
+  const level = getDefaultLogLevel();
+  switch (type) {
+    case "pino":
+      return new PinoAdapter({ level });
+    case "custom":
+      return new CustomAdapter({ level });
+    default:
+      return new PinoAdapter({ level });
+  }
+}
+function getAdapterType() {
+  const adapterEnv = process.env.LOGGER_ADAPTER;
+  if (adapterEnv === "custom" || adapterEnv === "pino") {
+    return adapterEnv;
+  }
+  return "pino";
+}
+function initializeLogger() {
+  validateConfig();
+  return createAdapter(getAdapterType());
+}
+var logger = initializeLogger();
+
+// src/codegen/core/orchestrator.ts
+var orchestratorLogger = logger.child("orchestrator");
+var CodegenOrchestrator = class {
+  generators;
+  cwd;
+  debug;
+  isGenerating = false;
+  pendingRegenerations = /* @__PURE__ */ new Set();
+  constructor(options) {
+    this.generators = options.generators;
+    this.cwd = options.cwd ?? process.cwd();
+    this.debug = options.debug ?? false;
+  }
+  /**
+   * Check if generator should run for given trigger
+   */
+  shouldRun(generator, trigger) {
+    const runOn = generator.runOn ?? ["watch", "manual", "build"];
+    return runOn.includes(trigger);
+  }
+  /**
+   * Run all generators once
+   *
+   * @param trigger - How the generators are being triggered
+   */
+  async generateAll(trigger = "manual") {
+    if (this.debug) {
+      orchestratorLogger.info("Running all generators", {
+        count: this.generators.length,
+        names: this.generators.map((g) => g.name),
+        trigger
+      });
+    }
+    for (const generator of this.generators) {
+      if (!this.shouldRun(generator, trigger)) {
+        if (this.debug) {
+          orchestratorLogger.info(`[${generator.name}] Skipped (runOn: ${generator.runOn?.join(", ") ?? "default"})`);
+        }
+        continue;
+      }
+      try {
+        const genOptions = {
+          cwd: this.cwd,
+          debug: this.debug,
+          trigger: {
+            type: trigger
+          }
+        };
+        await generator.generate(genOptions);
+        if (this.debug) {
+          orchestratorLogger.info(`[${generator.name}] Generated successfully`);
+        }
+      } catch (error) {
+        const err = error instanceof Error ? error : new Error(String(error));
+        orchestratorLogger.error(`[${generator.name}] Generation failed`, err);
+      }
+    }
+  }
+  /**
+   * Start watch mode
+   */
+  async watch() {
+    await this.generateAll("watch");
+    const allPatterns = this.generators.flatMap((g) => g.watchPatterns);
+    if (allPatterns.length === 0) {
+      orchestratorLogger.warn("No watch patterns defined, exiting watch mode");
+      return;
+    }
+    const dirsToWatch = /* @__PURE__ */ new Set();
+    for (const pattern of allPatterns) {
+      const baseDir = pattern.split("**")[0].replace(/\/$/, "") || ".";
+      dirsToWatch.add(join(this.cwd, baseDir));
+    }
+    const watchDirs = Array.from(dirsToWatch);
+    if (this.debug) {
+      orchestratorLogger.info("Starting watch mode", {
+        patterns: allPatterns,
+        watchDirs,
+        cwd: this.cwd
+      });
+    }
+    const watcher = watch(watchDirs, {
+      ignored: /(^|[\/\\])\../,
+      // ignore dotfiles
+      persistent: true,
+      ignoreInitial: true,
+      awaitWriteFinish: {
+        stabilityThreshold: 100,
+        pollInterval: 50
+      }
+    });
+    const handleChange = async (absolutePath, event) => {
+      const filePath = relative(this.cwd, absolutePath);
+      if (this.isGenerating) {
+        this.pendingRegenerations.add(absolutePath);
+        return;
+      }
+      this.isGenerating = true;
+      this.pendingRegenerations.clear();
+      if (this.debug) {
+        orchestratorLogger.info(`File ${event}`, { file: filePath });
+      }
+      for (const generator of this.generators) {
+        if (!this.shouldRun(generator, "watch")) {
+          continue;
+        }
+        const matches = generator.watchPatterns.some(
+          (pattern) => mm.isMatch(filePath, pattern)
+        );
+        if (matches) {
+          try {
+            const genOptions = {
+              cwd: this.cwd,
+              debug: this.debug,
+              trigger: {
+                type: "watch",
+                changedFile: {
+                  path: filePath,
+                  event
+                }
+              }
+            };
+            await generator.generate(genOptions);
+            if (this.debug) {
+              orchestratorLogger.info(`[${generator.name}] Regenerated`);
+            }
+          } catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            orchestratorLogger.error(`[${generator.name}] Regeneration failed`, err);
+          }
+        }
+      }
+      this.isGenerating = false;
+      if (this.pendingRegenerations.size > 0) {
+        const next = Array.from(this.pendingRegenerations)[0];
+        await handleChange(next, "change");
+      }
+    };
+    watcher.on("add", (path) => handleChange(path, "add")).on("change", (path) => handleChange(path, "change")).on("unlink", (path) => handleChange(path, "unlink"));
+    process.on("SIGINT", () => {
+      if (this.debug) {
+        orchestratorLogger.info("Shutting down watch mode");
+      }
+      watcher.close();
+      process.exit(0);
+    });
+    await new Promise(() => {
+    });
+  }
+};
+var scannerLogger = logger.child("contract-scanner");
+async function scanContracts(contractsDir, packagePrefix) {
+  scannerLogger.debug("Starting contract scan", { contractsDir, packagePrefix });
+  const contractFiles = await scanContractFiles(contractsDir);
+  scannerLogger.debug("Found contract files", { count: contractFiles.length, files: contractFiles });
+  const mappings = [];
+  for (let i = 0; i < contractFiles.length; i++) {
+    const filePath = contractFiles[i];
+    scannerLogger.debug("Extracting contracts from file", { filePath });
+    const exports = extractContractExports(filePath);
+    scannerLogger.debug("Extracted contracts", { filePath, count: exports.length, contracts: exports.map((e) => e.name) });
+    for (let j = 0; j < exports.length; j++) {
+      const contractExport = exports[j];
+      scannerLogger.debug("Processing contract", { name: contractExport.name, method: contractExport.method, path: contractExport.path });
+      if (!contractExport.path.startsWith("/")) {
+        throw new Error(
+          `Contract '${contractExport.name}' in ${filePath} must use absolute path. Found: '${contractExport.path}'. Use '/your-path' instead.`
+        );
+      }
+      if (packagePrefix && !contractExport.path.startsWith(packagePrefix)) {
+        throw new Error(
+          `Contract '${contractExport.name}' in ${filePath} must include package prefix. Expected path to start with '${packagePrefix}', but found: '${contractExport.path}'. Example: path: '${packagePrefix}/${contractExport.path}'`
+        );
+      }
+      mappings.push({
+        method: contractExport.method,
+        path: contractExport.path,
+        contractName: contractExport.name,
+        contractImportPath: getImportPath(filePath),
+        routeFile: "",
+        contractFile: filePath,
+        hasQuery: contractExport.hasQuery,
+        hasBody: contractExport.hasBody,
+        hasParams: contractExport.hasParams
+      });
+    }
+  }
+  scannerLogger.info("Contract scan completed", { totalMappings: mappings.length });
+  return mappings;
+}
+async function scanContractFiles(dir, files = []) {
+  try {
+    const entries = await readdir(dir);
+    for (let i = 0; i < entries.length; i++) {
+      const entry = entries[i];
+      const fullPath = join(dir, entry);
+      const fileStat = await stat(fullPath);
+      if (fileStat.isDirectory()) {
+        await scanContractFiles(fullPath, files);
+      } else {
+        if ((entry.endsWith(".ts") || entry.endsWith(".js") || entry.endsWith(".mjs")) && !entry.endsWith(".d.ts") && !entry.endsWith(".test.ts") && !entry.endsWith(".test.js") && !entry.endsWith(".test.mjs")) {
+          files.push(fullPath);
+        }
+      }
+    }
+  } catch (error) {
+  }
+  return files;
+}
+function extractContractExports(filePath) {
+  const sourceCode = readFileSync(filePath, "utf-8");
+  const sourceFile = ts.createSourceFile(
+    filePath,
+    sourceCode,
+    ts.ScriptTarget.Latest,
+    true
+  );
+  const exports = [];
+  function visit(node) {
+    if (ts.isVariableStatement(node)) {
+      const hasExport = node.modifiers?.some(
+        (m) => m.kind === ts.SyntaxKind.ExportKeyword
+      );
+      if (hasExport && node.declarationList.declarations.length > 0) {
+        const declaration = node.declarationList.declarations[0];
+        if (ts.isVariableDeclaration(declaration) && ts.isIdentifier(declaration.name) && declaration.initializer) {
+          const name = declaration.name.text;
+          const hasSatisfiesRouteContract = checkSatisfiesRouteContract(declaration.initializer);
+          if (hasSatisfiesRouteContract) {
+            const objectLiteral = extractObjectLiteral(declaration.initializer);
+            if (objectLiteral) {
+              const contractData = extractContractData(objectLiteral);
+              if (contractData.method && contractData.path) {
+                exports.push({
+                  name,
+                  method: contractData.method,
+                  path: contractData.path,
+                  hasQuery: contractData.hasQuery,
+                  hasBody: contractData.hasBody,
+                  hasParams: contractData.hasParams
+                });
+              }
+            }
+            return;
+          }
+          if (isContractName(name)) {
+            const objectLiteral = extractObjectLiteral(declaration.initializer);
+            if (objectLiteral) {
+              const contractData = extractContractData(objectLiteral);
+              if (contractData.method && contractData.path) {
+                exports.push({
+                  name,
+                  method: contractData.method,
+                  path: contractData.path,
+                  hasQuery: contractData.hasQuery,
+                  hasBody: contractData.hasBody,
+                  hasParams: contractData.hasParams
+                });
+              }
+            }
+          }
+        }
+      }
+    }
+    ts.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+  return exports;
+}
+function checkSatisfiesRouteContract(initializer) {
+  if (!ts.isSatisfiesExpression(initializer)) {
+    return false;
+  }
+  const typeNode = initializer.type;
+  if (ts.isTypeReferenceNode(typeNode) && ts.isIdentifier(typeNode.typeName)) {
+    return typeNode.typeName.text === "RouteContract";
+  }
+  return false;
+}
+function extractObjectLiteral(initializer) {
+  if (ts.isObjectLiteralExpression(initializer)) {
+    return initializer;
+  }
+  if (ts.isSatisfiesExpression(initializer)) {
+    return extractObjectLiteral(initializer.expression);
+  }
+  if (ts.isAsExpression(initializer)) {
+    return extractObjectLiteral(initializer.expression);
+  }
+  return void 0;
+}
+function extractContractData(objectLiteral) {
+  const result = {};
+  for (let i = 0; i < objectLiteral.properties.length; i++) {
+    const prop = objectLiteral.properties[i];
+    if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
+      const propName = prop.name.text;
+      if (propName === "method") {
+        let value;
+        if (ts.isStringLiteral(prop.initializer)) {
+          value = prop.initializer.text;
+        } else if (ts.isAsExpression(prop.initializer) && ts.isStringLiteral(prop.initializer.expression)) {
+          value = prop.initializer.expression.text;
+        }
+        if (value) result.method = value;
+      } else if (propName === "path") {
+        let value;
+        if (ts.isStringLiteral(prop.initializer)) {
+          value = prop.initializer.text;
+        } else if (ts.isAsExpression(prop.initializer) && ts.isStringLiteral(prop.initializer.expression)) {
+          value = prop.initializer.expression.text;
+        }
+        if (value) result.path = value;
+      } else if (propName === "query") {
+        result.hasQuery = true;
+      } else if (propName === "body") {
+        result.hasBody = true;
+      } else if (propName === "params") {
+        result.hasParams = true;
+      }
+    }
+  }
+  return result;
+}
+function isContractName(name) {
+  return name.indexOf("Contract") !== -1 || name.indexOf("contract") !== -1 || name.endsWith("Schema") || name.endsWith("schema");
+}
+function getImportPath(filePath) {
+  const srcIndex = filePath.indexOf("/src/");
+  if (srcIndex === -1) {
+    throw new Error(`Cannot determine import path for ${filePath}: /src/ directory not found`);
+  }
+  let cleanPath = filePath.substring(srcIndex + 5);
+  if (cleanPath.endsWith(".ts")) {
+    cleanPath = cleanPath.slice(0, -3);
+  } else if (cleanPath.endsWith(".js")) {
+    cleanPath = cleanPath.slice(0, -3);
+  } else if (cleanPath.endsWith(".mjs")) {
+    cleanPath = cleanPath.slice(0, -4);
+  }
+  return "@/" + cleanPath;
+}
+
+// src/codegen/built-in/contract/helpers.ts
+function groupByResource(mappings) {
+  const grouped = {};
+  for (let i = 0; i < mappings.length; i++) {
+    const mapping = mappings[i];
+    const resource = extractResourceName(mapping.path);
+    if (!grouped[resource]) {
+      grouped[resource] = [];
+    }
+    grouped[resource].push(mapping);
+  }
+  return grouped;
+}
+function extractResourceName(path) {
+  let processedPath = path;
+  if (!processedPath.startsWith("/")) {
+    processedPath = "/" + processedPath;
+  }
+  const segments = processedPath.slice(1).split("/").filter((s) => s && s !== "*");
+  const staticSegments = [];
+  for (let i = 0; i < segments.length; i++) {
+    const seg = segments[i];
+    if (!seg.startsWith(":")) {
+      staticSegments.push(seg);
+    }
+  }
+  if (staticSegments.length === 0) {
+    return "root";
+  }
+  const first = toCamelCase(staticSegments[0], false);
+  if (staticSegments.length === 1) {
+    return first;
+  }
+  const result = [first];
+  for (let i = 1; i < staticSegments.length; i++) {
+    const seg = staticSegments[i];
+    result.push(toCamelCase(seg, true));
+  }
+  return result.join("");
+}
+function toCamelCase(str, capitalize2) {
+  const parts = str.split(/[-_]/);
+  if (parts.length === 1) {
+    return capitalize2 ? str.charAt(0).toUpperCase() + str.slice(1) : str;
+  }
+  const result = [];
+  for (let i = 0; i < parts.length; i++) {
+    const part = parts[i];
+    if (i === 0 && !capitalize2) {
+      result.push(part);
+    } else {
+      result.push(part.charAt(0).toUpperCase() + part.slice(1));
+    }
+  }
+  return result.join("");
+}
+
+// src/codegen/built-in/contract/emitter.ts
+async function generateClient(mappings, options) {
+  const startTime = Date.now();
+  const grouped = groupByResource(mappings);
+  const resourceNames = Object.keys(grouped);
+  await generateSplitClient(mappings, grouped, options);
+  return {
+    routesScanned: mappings.length,
+    contractsFound: mappings.length,
+    contractFiles: countUniqueContractFiles(mappings),
+    resourcesGenerated: resourceNames.length,
+    methodsGenerated: mappings.length,
+    duration: Date.now() - startTime
+  };
+}
+function generateHeader() {
+  return `/**
+ * Auto-generated API Client
+ *
+ * Generated by @spfn/core codegen
+ * DO NOT EDIT MANUALLY
+ *
+ * @generated ${(/* @__PURE__ */ new Date()).toISOString()}
+ */
+
+`;
+}
+function groupContractsByImportPath(mappings) {
+  const groups = {};
+  for (let i = 0; i < mappings.length; i++) {
+    const mapping = mappings[i];
+    const path = mapping.contractImportPath;
+    if (!groups[path]) {
+      groups[path] = /* @__PURE__ */ new Set();
+    }
+    groups[path].add(mapping.contractName);
+  }
+  const result = {};
+  const keys = Object.keys(groups);
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i];
+    result[key] = Array.from(groups[key]);
+  }
+  return result;
 }
-var CustomAdapter = class _CustomAdapter {
-  logger;
-  constructor(config) {
-    this.logger = new Logger({
-      level: config.level,
-      module: config.module,
-      transports: initializeTransports()
-    });
+function generateTypeName(mapping) {
+  let name = mapping.contractName;
+  if (name.endsWith("Contract")) {
+    name = name.slice(0, -8);
   }
-  child(module) {
-    const adapter = new _CustomAdapter({ level: this.logger.level, module });
-    adapter.logger = this.logger.child(module);
-    return adapter;
+  if (name.length > 0) {
+    name = name.charAt(0).toUpperCase() + name.slice(1);
   }
-  debug(message, context) {
-    this.logger.debug(message, context);
+  return name;
+}
+function generateFunctionName(mapping) {
+  let name = mapping.contractName;
+  if (name.endsWith("Contract")) {
+    name = name.slice(0, -8);
   }
-  info(message, context) {
-    this.logger.info(message, context);
+  return name;
+}
+function generateFunctionCode(mapping, options) {
+  const functionName = generateFunctionName(mapping);
+  const hasParams = mapping.hasParams || mapping.path.includes(":");
+  const hasQuery = mapping.hasQuery || false;
+  const hasBody = mapping.hasBody || false;
+  let code = "";
+  if (options.includeJsDoc !== false) {
+    code += `/**
+`;
+    code += ` * ${mapping.method} ${mapping.path}
+`;
+    code += ` */
+`;
   }
-  warn(message, errorOrContext, context) {
-    if (errorOrContext instanceof Error) {
-      this.logger.warn(message, errorOrContext, context);
-    } else {
-      this.logger.warn(message, errorOrContext);
+  code += `export const ${functionName} = (`;
+  const params = [];
+  const typeName = generateTypeName(mapping);
+  if (hasParams) {
+    params.push(`params: ${typeName}Params`);
+  }
+  if (hasQuery) {
+    params.push(`query?: ${typeName}Query`);
+  }
+  if (hasBody) {
+    params.push(`body: ${typeName}Body`);
+  }
+  if (params.length > 0) {
+    code += `options: { ${params.join(", ")} }`;
+  }
+  code += `) => `;
+  code += `client.call(${mapping.contractName}`;
+  if (params.length > 0) {
+    code += `, options`;
+  }
+  code += `);
+
+`;
+  return code;
+}
+function countUniqueContractFiles(mappings) {
+  const files = /* @__PURE__ */ new Set();
+  for (let i = 0; i < mappings.length; i++) {
+    if (mappings[i].contractFile) {
+      files.add(mappings[i].contractFile);
     }
   }
-  error(message, errorOrContext, context) {
-    if (errorOrContext instanceof Error) {
-      this.logger.error(message, errorOrContext, context);
-    } else {
-      this.logger.error(message, errorOrContext);
+  return files.size;
+}
+function toKebabCase(str) {
+  if (str.length === 0) {
+    return str;
+  }
+  return str.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
+}
+async function generateSplitClient(_mappings, grouped, options) {
+  const outputPath = options.outputPath;
+  const outputDir = outputPath.endsWith(".ts") || outputPath.endsWith(".js") ? outputPath.replace(/\.[jt]s$/, "") : outputPath;
+  await mkdir(outputDir, { recursive: true });
+  const resourceNames = Object.keys(grouped);
+  for (let i = 0; i < resourceNames.length; i++) {
+    const resourceName = resourceNames[i];
+    const routes = grouped[resourceName];
+    const code = generateResourceFile(resourceName, routes, options);
+    const kebabName = toKebabCase(resourceName);
+    const filePath = `${outputDir}/${kebabName}.ts`;
+    await writeFile(filePath, code, "utf-8");
+  }
+  const indexCode = generateIndexFile(grouped, options);
+  const indexPath = `${outputDir}/index.ts`;
+  await writeFile(indexPath, indexCode, "utf-8");
+}
+function generateResourceFile(_resourceName, routes, options) {
+  let code = "";
+  code += generateHeader();
+  code += `import { client } from '@spfn/core/client';
+`;
+  if (options.includeTypes !== false) {
+    code += `import type { InferContract } from '@spfn/core';
+`;
+  }
+  code += `
+`;
+  const importGroups = groupContractsByImportPath(routes);
+  const importPaths = Object.keys(importGroups);
+  for (let i = 0; i < importPaths.length; i++) {
+    const importPath = importPaths[i];
+    const contracts = importGroups[importPath];
+    code += `import { ${contracts.join(", ")} } from '${importPath}';
+`;
+  }
+  code += `
+`;
+  if (options.includeTypes !== false) {
+    code += `// ============================================
+`;
+    code += `// Types
+`;
+    code += `// ============================================
+
+`;
+    for (let i = 0; i < routes.length; i++) {
+      const route = routes[i];
+      const typeName = generateTypeName(route);
+      const contractType = `typeof ${route.contractName}`;
+      code += `export type ${typeName}Response = InferContract<${contractType}>['response'];
+`;
+      if (route.hasQuery) {
+        code += `export type ${typeName}Query = InferContract<${contractType}>['query'];
+`;
+      }
+      if (route.hasParams || route.path.includes(":")) {
+        code += `export type ${typeName}Params = InferContract<${contractType}>['params'];
+`;
+      }
+      if (route.hasBody) {
+        code += `export type ${typeName}Body = InferContract<${contractType}>['body'];
+`;
+      }
+      code += `
+`;
     }
   }
-  fatal(message, errorOrContext, context) {
-    if (errorOrContext instanceof Error) {
-      this.logger.fatal(message, errorOrContext, context);
-    } else {
-      this.logger.fatal(message, errorOrContext);
+  code += `// ============================================
+`;
+  code += `// API Functions
+`;
+  code += `// ============================================
+
+`;
+  for (let i = 0; i < routes.length; i++) {
+    const route = routes[i];
+    code += generateFunctionCode(route, options);
+  }
+  return code;
+}
+function generateIndexFile(grouped, options) {
+  let code = "";
+  const apiName = options.apiName || "api";
+  const resourceNames = Object.keys(grouped);
+  code += generateHeader();
+  code += `export { client } from '@spfn/core/client';
+
+`;
+  for (let i = 0; i < resourceNames.length; i++) {
+    const resourceName = resourceNames[i];
+    const routes = grouped[resourceName];
+    const kebabName = toKebabCase(resourceName);
+    const typeNames = [];
+    for (let j = 0; j < routes.length; j++) {
+      const route = routes[j];
+      const typeName = generateTypeName(route);
+      typeNames.push(`${typeName}Response`);
+      if (route.hasQuery) {
+        typeNames.push(`${typeName}Query`);
+      }
+      if (route.hasParams || route.path.includes(":")) {
+        typeNames.push(`${typeName}Params`);
+      }
+      if (route.hasBody) {
+        typeNames.push(`${typeName}Body`);
+      }
+    }
+    if (typeNames.length > 0) {
+      code += `export type { ${typeNames.join(", ")} } from './${kebabName}';
+`;
     }
   }
-  async close() {
-    await this.logger.close();
+  code += `
+`;
+  for (let i = 0; i < resourceNames.length; i++) {
+    const resourceName = resourceNames[i];
+    const routes = grouped[resourceName];
+    const kebabName = toKebabCase(resourceName);
+    const functionNames = routes.map((route) => generateFunctionName(route));
+    code += `import { ${functionNames.join(", ")} } from './${kebabName}';
+`;
   }
-};
+  code += `
+`;
+  code += `/**
+`;
+  code += ` * Type-safe API client
+`;
+  code += ` */
+`;
+  code += `export const ${apiName} = {
+`;
+  let isFirst = true;
+  for (let i = 0; i < resourceNames.length; i++) {
+    const resourceName = resourceNames[i];
+    const routes = grouped[resourceName];
+    for (let j = 0; j < routes.length; j++) {
+      const route = routes[j];
+      const functionName = generateFunctionName(route);
+      if (!isFirst) {
+        code += `,
+`;
+      }
+      code += `    ${functionName}`;
+      isFirst = false;
+    }
+  }
+  code += `
+} as const;
+`;
+  return code;
+}
 
-// src/logger/adapter-factory.ts
-function createAdapter(type) {
-  const level = getDefaultLogLevel();
-  switch (type) {
-    case "pino":
-      return new PinoAdapter({ level });
-    case "custom":
-      return new CustomAdapter({ level });
-    default:
-      return new PinoAdapter({ level });
+// src/codegen/built-in/contract/index.ts
+var contractLogger = logger.child("contract-gen");
+var DEFAULT_CONTRACTS_DIR = "src/lib/contracts";
+var DEFAULT_OUTPUT_PATH = "src/lib/api";
+var contractCache = null;
+function needsFullRegeneration(event) {
+  if (event === "add" || event === "unlink") {
+    return true;
+  }
+  if (!contractCache) {
+    return true;
+  }
+  return false;
+}
+function createClientOptions(contractsDir, outputPath, baseUrl, apiName) {
+  return {
+    routesDir: contractsDir,
+    outputPath,
+    baseUrl,
+    apiName,
+    includeTypes: true,
+    includeJsDoc: true,
+    splitByResource: true
+  };
+}
+function generateApiName(prefix) {
+  if (!prefix || prefix === "/api") {
+    return "api";
   }
+  const name = prefix.replace(/^\/[_-]?/, "").replace(/[_-]/g, "");
+  if (!name) {
+    return "api";
+  }
+  return `${name}Api`;
 }
-function getAdapterType() {
-  const adapterEnv = process.env.LOGGER_ADAPTER;
-  if (adapterEnv === "custom" || adapterEnv === "pino") {
-    return adapterEnv;
+function readPrefixFromPackageJson(cwd) {
+  try {
+    const packageJsonPath = join(cwd, "package.json");
+    if (!existsSync(packageJsonPath)) {
+      return void 0;
+    }
+    const content = readFileSync(packageJsonPath, "utf-8");
+    const packageJson = JSON.parse(content);
+    return packageJson.spfn?.prefix;
+  } catch (error) {
+    return void 0;
   }
-  return "pino";
 }
-var logger = createAdapter(getAdapterType());
-
-// src/codegen/watch-generate.ts
-var codegenLogger = logger.child("codegen");
-async function generateOnce(options) {
-  const cwd = process.cwd();
-  const routesDir = options.routesDir ?? join(cwd, "src", "server", "routes");
-  const outputPath = options.outputPath ?? join(cwd, "src", "lib", "api.ts");
+function createContractGenerator(config = {}) {
+  const contractsDir = config.contractsDir ?? DEFAULT_CONTRACTS_DIR;
+  const outputPath = config.outputPath ?? DEFAULT_OUTPUT_PATH;
+  const runOn = config.runOn ?? ["watch", "manual", "build"];
+  return {
+    name: "contract",
+    watchPatterns: [
+      `${contractsDir}/**/*.ts`
+    ],
+    runOn,
+    async generate(options) {
+      const cwd = options.cwd;
+      const fullContractsDir = join(cwd, contractsDir);
+      const fullOutputPath = join(cwd, outputPath);
+      const prefix = readPrefixFromPackageJson(cwd);
+      const apiName = generateApiName(prefix);
+      try {
+        if (!existsSync(fullContractsDir)) {
+          if (options.debug) {
+            contractLogger.warn(`No contracts directory found at ${contractsDir}`);
+          }
+          return;
+        }
+        const changedFile = options.trigger?.changedFile;
+        if (changedFile && !needsFullRegeneration(changedFile.event)) {
+          if (options.debug) {
+            contractLogger.info("Attempting incremental update", {
+              file: changedFile.path,
+              event: changedFile.event
+            });
+          }
+          const success = await attemptIncrementalUpdate({
+            cwd,
+            contractsDir: fullContractsDir,
+            outputPath: fullOutputPath,
+            changedFilePath: changedFile.path,
+            baseUrl: config.baseUrl,
+            apiName,
+            debug: options.debug
+          });
+          if (success) {
+            if (options.debug) {
+              contractLogger.info("Incremental update successful");
+            }
+            return;
+          }
+          if (options.debug) {
+            contractLogger.info("Incremental update failed, doing full regen");
+          }
+        }
+        const allContracts = await scanContracts(fullContractsDir, prefix);
+        if (allContracts.length === 0) {
+          if (options.debug) {
+            contractLogger.warn("No contracts found");
+          }
+          contractCache = null;
+          return;
+        }
+        const clientOptions = createClientOptions(fullContractsDir, fullOutputPath, config.baseUrl, apiName);
+        const stats = await generateClient(allContracts, clientOptions);
+        contractCache = {
+          contracts: allContracts,
+          lastScan: Date.now()
+        };
+        if (options.debug) {
+          contractLogger.info("Client generated", {
+            endpoints: stats.methodsGenerated,
+            resources: stats.resourcesGenerated,
+            duration: stats.duration,
+            mode: changedFile ? "incremental-fallback" : "full"
+          });
+        }
+      } catch (error) {
+        const err = error instanceof Error ? error : new Error(String(error));
+        contractLogger.error("Generation failed", err);
+        throw err;
+      }
+    }
+  };
+}
+async function attemptIncrementalUpdate(options) {
+  const { cwd, contractsDir, outputPath, changedFilePath, baseUrl, apiName, debug } = options;
+  if (!contractCache) {
+    return false;
+  }
   try {
-    const contracts = await scanContracts(routesDir);
-    if (contracts.length === 0) {
-      if (options.debug) {
-        codegenLogger.warn("No contracts found");
+    const fullPath = join(cwd, changedFilePath);
+    if (!existsSync(fullPath)) {
+      return false;
+    }
+    const updatedContracts = await scanContracts(contractsDir);
+    if (updatedContracts.length === 0) {
+      contractCache = null;
+      return false;
+    }
+    const changedContracts = findChangedContracts(
+      contractCache.contracts,
+      updatedContracts,
+      changedFilePath
+    );
+    if (changedContracts.size === 0) {
+      if (debug) {
+        contractLogger.info("No contract changes detected, skipping regeneration");
       }
-      return null;
+      return true;
     }
-    const stats = await generateClient(contracts, {
-      outputPath,
-      includeTypes: true,
-      includeJsDoc: true
-    });
-    if (options.debug) {
-      codegenLogger.info("Client generated", {
+    const clientOptions = createClientOptions(contractsDir, outputPath, baseUrl, apiName);
+    const stats = await generateClient(updatedContracts, clientOptions);
+    contractCache = {
+      contracts: updatedContracts,
+      lastScan: Date.now()
+    };
+    if (debug) {
+      contractLogger.info("Incremental update successful", {
+        changedContracts: changedContracts.size,
         endpoints: stats.methodsGenerated,
         resources: stats.resourcesGenerated,
         duration: stats.duration
       });
     }
-    return stats;
+    return true;
   } catch (error) {
-    codegenLogger.error(
-      "Generation failed",
-      error instanceof Error ? error : new Error(String(error))
-    );
-    return null;
+    if (debug) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      contractLogger.warn("Incremental update failed", err);
+    }
+    return false;
   }
 }
-async function watchAndGenerate(options = {}) {
-  const cwd = process.cwd();
-  const routesDir = options.routesDir ?? join(cwd, "src", "server", "routes");
-  const outputPath = options.outputPath ?? join(cwd, "src", "lib", "api.ts");
-  const watchMode = options.watch !== false;
-  if (options.debug) {
-    codegenLogger.info("Contract Watcher Started", { routesDir, outputPath, watch: watchMode });
+function findChangedContracts(oldContracts, newContracts, changedFilePath) {
+  const changed = /* @__PURE__ */ new Set();
+  const oldInFile = oldContracts.filter((c) => c.contractFile?.includes(changedFilePath));
+  const newInFile = newContracts.filter((c) => c.contractFile?.includes(changedFilePath));
+  if (oldInFile.length !== newInFile.length) {
+    newInFile.forEach((c) => changed.add(c.contractName));
+    return changed;
+  }
+  for (const newContract of newInFile) {
+    const oldContract = oldInFile.find((c) => c.contractName === newContract.contractName);
+    if (!oldContract) {
+      changed.add(newContract.contractName);
+      continue;
+    }
+    if (oldContract.method !== newContract.method || oldContract.path !== newContract.path || oldContract.hasQuery !== newContract.hasQuery || oldContract.hasBody !== newContract.hasBody || oldContract.hasParams !== newContract.hasParams) {
+      changed.add(newContract.contractName);
+    }
   }
-  await generateOnce(options);
-  if (watchMode) {
-    let isGenerating = false;
-    let pendingRegeneration = false;
-    const watcher = watch(routesDir, {
-      ignored: /(^|[\/\\])\../,
-      // ignore dotfiles
-      persistent: true,
-      ignoreInitial: true,
-      awaitWriteFinish: {
-        stabilityThreshold: 100,
-        pollInterval: 50
-      }
-    });
-    const regenerate = async () => {
-      if (isGenerating) {
-        pendingRegeneration = true;
-        return;
-      }
-      isGenerating = true;
-      pendingRegeneration = false;
-      if (options.debug) {
-        codegenLogger.info("Contracts changed, regenerating...");
+  return changed;
+}
+var configLogger = logger.child("config");
+function loadCodegenConfig(cwd) {
+  const rcPath = join(cwd, ".spfnrc.json");
+  if (existsSync(rcPath)) {
+    try {
+      const content = readFileSync(rcPath, "utf-8");
+      const config = JSON.parse(content);
+      if (config.codegen) {
+        configLogger.info("Loaded config from .spfnrc.json");
+        return config.codegen;
       }
-      await generateOnce(options);
-      isGenerating = false;
-      if (pendingRegeneration) {
-        await regenerate();
+    } catch (error) {
+      configLogger.warn("Failed to parse .spfnrc.json", error);
+    }
+  }
+  const pkgPath = join(cwd, "package.json");
+  if (existsSync(pkgPath)) {
+    try {
+      const content = readFileSync(pkgPath, "utf-8");
+      const pkg = JSON.parse(content);
+      if (pkg.spfn?.codegen) {
+        configLogger.info("Loaded config from package.json");
+        return pkg.spfn.codegen;
       }
-    };
-    watcher.on("add", regenerate).on("change", regenerate).on("unlink", regenerate);
-    process.on("SIGINT", () => {
-      watcher.close();
-      process.exit(0);
-    });
-    await new Promise(() => {
-    });
+    } catch (error) {
+      configLogger.warn("Failed to parse package.json", error);
+    }
+  }
+  configLogger.info("Using default config");
+  return {
+    generators: [
+      { name: "@spfn/core:contract", enabled: true }
+    ]
+  };
+}
+async function loadGeneratorFromPackage(packageName, generatorName, config) {
+  try {
+    const generatorsModule = await import(`${packageName}/generators`);
+    if (generatorsModule.generators?.[generatorName]) {
+      const createFn = generatorsModule.generators[generatorName];
+      const generator = createFn(config);
+      configLogger.info(`Loaded ${packageName}:${generatorName}`);
+      return generator;
+    }
+    const conventionalName = `create${capitalize(generatorName)}Generator`;
+    if (generatorsModule[conventionalName]) {
+      const createFn = generatorsModule[conventionalName];
+      const generator = createFn(config);
+      configLogger.info(`Loaded ${packageName}:${generatorName} (via ${conventionalName})`);
+      return generator;
+    }
+    configLogger.warn(
+      `Generator "${generatorName}" not found in ${packageName}/generators. Expected: generators.${generatorName} or ${conventionalName}`
+    );
+    return null;
+  } catch (error) {
+    const err = error instanceof Error ? error : new Error(String(error));
+    configLogger.warn(
+      `Failed to load ${packageName}:${generatorName}. Make sure ${packageName} is installed. Error: ${err.message}`
+    );
+    return null;
   }
 }
-if (import.meta.url === `file://${process.argv[1]}`) {
-  watchAndGenerate({ debug: true });
+function capitalize(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+async function createGeneratorsFromConfig(config, cwd) {
+  const generators = [];
+  if (!config.generators || config.generators.length === 0) {
+    return generators;
+  }
+  for (const generatorConfig of config.generators) {
+    try {
+      if ("path" in generatorConfig) {
+        const generatorPath = generatorConfig.path.startsWith(".") ? join(cwd, generatorConfig.path) : generatorConfig.path;
+        configLogger.info(`Loading custom generator: ${generatorPath}`);
+        let module;
+        if (generatorPath.endsWith(".ts")) {
+          const jiti = createJiti(cwd, {
+            interopDefault: true
+          });
+          module = jiti(generatorPath);
+        } else {
+          module = await import(generatorPath);
+        }
+        const createGenerator = module.default || module.createGenerator || module;
+        if (typeof createGenerator === "function") {
+          const generator = createGenerator();
+          generators.push(generator);
+          configLogger.info(`Custom generator loaded: ${generator.name}`);
+        } else {
+          configLogger.warn(`Invalid generator at ${generatorPath}: expected function`);
+        }
+      } else if ("name" in generatorConfig && generatorConfig.name.includes(":")) {
+        if (generatorConfig.enabled !== false) {
+          const [packageName, generatorName] = generatorConfig.name.split(":");
+          const { enabled, name, ...generatorOptions } = generatorConfig;
+          const generator = await loadGeneratorFromPackage(
+            packageName,
+            generatorName,
+            generatorOptions
+          );
+          if (generator) {
+            generators.push(generator);
+          }
+        }
+      } else if ("name" in generatorConfig) {
+        configLogger.warn(
+          `Invalid generator name "${generatorConfig.name}". Use package:name format (e.g., "@spfn/core:contract")`
+        );
+      }
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error(String(error));
+      configLogger.error("Failed to load generator", err);
+    }
+  }
+  return generators;
 }
 
-export { generateClient, groupByResource, scanContracts, watchAndGenerate };
+export { CodegenOrchestrator, createContractGenerator, createGeneratorsFromConfig, loadCodegenConfig };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map