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

package/dist/codegen/index.js

@@ -1,685 +1,12 @@
 import { watch } from 'chokidar';
 import { join, relative } from 'path';
 import mm from 'micromatch';
-import { existsSync, mkdirSync, createWriteStream, statSync, readdirSync, renameSync, unlinkSync, accessSync, constants, writeFileSync, readFileSync } from 'fs';
-import { readdir, stat, mkdir, writeFile } from 'fs/promises';
-import * as ts from 'typescript';
+import { logger } from '@spfn/core/logger';
+import { existsSync, readFileSync } from 'fs';
 import { createJiti } from 'jiti';
 
 // src/codegen/core/orchestrator.ts
-
-// 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 maskSensitiveData(data) {
-  if (data === null || data === void 0) {
-    return data;
-  }
-  if (Array.isArray(data)) {
-    return data.map((item) => maskSensitiveData(item));
-  }
-  if (typeof data === "object") {
-    const masked = {};
-    for (const [key, value] of Object.entries(data)) {
-      if (isSensitiveKey(key)) {
-        masked[key] = MASKED_VALUE;
-      } else if (typeof value === "object" && value !== null) {
-        masked[key] = maskSensitiveData(value);
-      } else {
-        masked[key] = value;
-      }
-    }
-    return masked;
-  }
-  return data;
-}
-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 formatError(error) {
-  const lines = [];
-  lines.push(`${error.name}: ${error.message}`);
-  if (error.stack) {
-    const stackLines = error.stack.split("\n").slice(1);
-    lines.push(...stackLines);
-  }
-  return lines.join("\n");
-}
-function formatConsole(metadata, colorize = true) {
-  const parts = [];
-  const 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}]`);
-      }
-    });
-  }
-  const levelStr = metadata.level.toUpperCase();
-  if (colorize) {
-    const color = COLORS[metadata.level];
-    parts.push(`${color}(${levelStr})${COLORS.reset}:`);
-  } else {
-    parts.push(`(${levelStr}):`);
-  }
-  if (colorize) {
-    parts.push(`${COLORS.bright}${metadata.message}${COLORS.reset}`);
-  } else {
-    parts.push(metadata.message);
-  }
-  let output = parts.join(" ");
-  if (metadata.error) {
-    output += "\n" + formatError(metadata.error);
-  }
-  return output;
-}
-function formatJSON(metadata) {
-  const obj = {
-    timestamp: formatTimestamp(metadata.timestamp),
-    level: metadata.level,
-    message: metadata.message
-  };
-  if (metadata.module) {
-    obj.module = metadata.module;
-  }
-  if (metadata.context) {
-    obj.context = metadata.context;
-  }
-  if (metadata.error) {
-    obj.error = {
-      name: metadata.error.name,
-      message: metadata.error.message,
-      stack: metadata.error.stack
-    };
-  }
-  return JSON.stringify(obj);
-}
-
-// 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);
-  }
-  /**
-   * Info log
-   */
-  info(message, context) {
-    this.log("info", message, void 0, context);
-  }
-  warn(message, errorOrContext, context) {
-    if (errorOrContext instanceof Error) {
-      this.log("warn", message, errorOrContext, context);
-    } else {
-      this.log("warn", message, void 0, errorOrContext);
-    }
-  }
-  error(message, errorOrContext, context) {
-    if (errorOrContext instanceof Error) {
-      this.log("error", message, errorOrContext, context);
-    } else {
-      this.log("error", message, void 0, errorOrContext);
-    }
-  }
-  fatal(message, errorOrContext, context) {
-    if (errorOrContext instanceof Error) {
-      this.log("fatal", message, errorOrContext, context);
-    } else {
-      this.log("fatal", message, void 0, errorOrContext);
-    }
-  }
-  /**
-   * Log processing (internal)
-   */
-  log(level, message, error, context) {
-    if (LOG_LEVEL_PRIORITY[level] < LOG_LEVEL_PRIORITY[this.config.level]) {
-      return;
-    }
-    const metadata = {
-      timestamp: /* @__PURE__ */ new Date(),
-      level,
-      message,
-      module: this.module,
-      error,
-      // Mask sensitive information in context to prevent credential leaks
-      context: context ? maskSensitiveData(context) : void 0
-    };
-    this.processTransports(metadata);
-  }
-  /**
-   * Process Transports
-   */
-  processTransports(metadata) {
-    const promises = this.config.transports.filter((transport) => transport.enabled).map((transport) => this.safeTransportLog(transport, metadata));
-    Promise.all(promises).catch((error) => {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      process.stderr.write(`[Logger] Transport error: ${errorMessage}
-`);
-    });
-  }
-  /**
-   * Transport log (error-safe)
-   */
-  async safeTransportLog(transport, metadata) {
-    try {
-      await transport.log(metadata);
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      process.stderr.write(`[Logger] Transport "${transport.name}" failed: ${errorMessage}
-`);
-    }
-  }
-  /**
-   * Close all Transports
-   */
-  async close() {
-    const closePromises = this.config.transports.filter((transport) => transport.close).map((transport) => transport.close());
-    await Promise.all(closePromises);
-  }
-};
-
-// src/logger/transports/console.ts
-var ConsoleTransport = 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 });
-    }
-  }
-  async log(metadata) {
-    if (!this.enabled) {
-      return;
-    }
-    if (LOG_LEVEL_PRIORITY[metadata.level] < LOG_LEVEL_PRIORITY[this.level]) {
-      return;
-    }
-    const message = formatJSON(metadata);
-    const filename = this.getLogFilename(metadata.timestamp);
-    if (this.currentFilename !== filename) {
-      await this.rotateStream(filename);
-      await this.cleanOldFiles();
-    } else if (this.currentFilename) {
-      await this.checkAndRotateBySize();
-    }
-    if (this.currentStream) {
-      return new Promise((resolve, reject) => {
-        this.currentStream.write(message + "\n", "utf-8", (error) => {
-          if (error) {
-            process.stderr.write(`[FileTransport] Failed to write log: ${error.message}
-`);
-            reject(error);
-          } else {
-            resolve();
-          }
-        });
-      });
-    }
-  }
-  /**
-   * 스트림 교체 (날짜 변경 시)
-   */
-  async rotateStream(filename) {
-    if (this.currentStream) {
-      await this.closeStream();
-    }
-    const filepath = join(this.logDir, filename);
-    this.currentStream = createWriteStream(filepath, {
-      flags: "a",
-      // append mode
-      encoding: "utf-8"
-    });
-    this.currentFilename = filename;
-    this.currentStream.on("error", (error) => {
-      process.stderr.write(`[FileTransport] Stream error: ${error.message}
-`);
-      this.currentStream = null;
-      this.currentFilename = null;
-    });
-  }
-  /**
-   * 현재 스트림 닫기
-   */
-  async closeStream() {
-    if (!this.currentStream) {
-      return;
-    }
-    return new Promise((resolve, reject) => {
-      this.currentStream.end((error) => {
-        if (error) {
-          reject(error);
-        } else {
-          this.currentStream = null;
-          this.currentFilename = null;
-          resolve();
-        }
-      });
-    });
-  }
-  /**
-   * 파일 크기 체크 및 크기 기반 로테이션
-   */
-  async checkAndRotateBySize() {
-    if (!this.currentFilename) {
-      return;
-    }
-    const filepath = join(this.logDir, this.currentFilename);
-    if (!existsSync(filepath)) {
-      return;
-    }
-    try {
-      const stats = statSync(filepath);
-      if (stats.size >= this.maxFileSize) {
-        await this.rotateBySize();
-      }
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      process.stderr.write(`[FileTransport] Failed to check file size: ${errorMessage}
-`);
-    }
-  }
-  /**
-   * 크기 기반 로테이션 수행
-   * 예: 2025-01-01.log -> 2025-01-01.1.log, 2025-01-01.1.log -> 2025-01-01.2.log
-   */
-  async rotateBySize() {
-    if (!this.currentFilename) {
-      return;
-    }
-    await this.closeStream();
-    const baseName = this.currentFilename.replace(/\.log$/, "");
-    const files = readdirSync(this.logDir);
-    const relatedFiles = files.filter((file) => file.startsWith(baseName) && file.endsWith(".log")).sort().reverse();
-    for (const file of relatedFiles) {
-      const match = file.match(/\.(\d+)\.log$/);
-      if (match) {
-        const oldNum = parseInt(match[1], 10);
-        const newNum = oldNum + 1;
-        const oldPath = join(this.logDir, file);
-        const newPath2 = join(this.logDir, `${baseName}.${newNum}.log`);
-        try {
-          renameSync(oldPath, newPath2);
-        } catch (error) {
-          const errorMessage = error instanceof Error ? error.message : String(error);
-          process.stderr.write(`[FileTransport] Failed to rotate file: ${errorMessage}
-`);
-        }
-      }
-    }
-    const currentPath = join(this.logDir, this.currentFilename);
-    const newPath = join(this.logDir, `${baseName}.1.log`);
-    try {
-      if (existsSync(currentPath)) {
-        renameSync(currentPath, newPath);
-      }
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      process.stderr.write(`[FileTransport] Failed to rotate current file: ${errorMessage}
-`);
-    }
-    await this.rotateStream(this.currentFilename);
-  }
-  /**
-   * 오래된 로그 파일 정리
-   * maxFiles 개수를 초과하는 로그 파일 삭제
-   */
-  async cleanOldFiles() {
-    try {
-      if (!existsSync(this.logDir)) {
-        return;
-      }
-      const files = readdirSync(this.logDir);
-      const logFiles = files.filter((file) => file.endsWith(".log")).map((file) => {
-        const filepath = join(this.logDir, file);
-        const stats = statSync(filepath);
-        return { file, mtime: stats.mtime };
-      }).sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
-      if (logFiles.length > this.maxFiles) {
-        const filesToDelete = logFiles.slice(this.maxFiles);
-        for (const { file } of filesToDelete) {
-          const filepath = join(this.logDir, file);
-          try {
-            unlinkSync(filepath);
-          } catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            process.stderr.write(`[FileTransport] Failed to delete old file "${file}": ${errorMessage}
-`);
-          }
-        }
-      }
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      process.stderr.write(`[FileTransport] Failed to clean old files: ${errorMessage}
-`);
-    }
-  }
-  /**
-   * 날짜별 로그 파일명 생성
-   */
-  getLogFilename(date) {
-    const year = date.getFullYear();
-    const month = String(date.getMonth() + 1).padStart(2, "0");
-    const day = String(date.getDate()).padStart(2, "0");
-    return `${year}-${month}-${day}.log`;
-  }
-  async close() {
-    await this.closeStream();
-  }
-};
-function isFileLoggingEnabled() {
-  return process.env.LOGGER_FILE_ENABLED === "true";
-}
-function getDefaultLogLevel() {
-  const isProduction = process.env.NODE_ENV === "production";
-  const isDevelopment = process.env.NODE_ENV === "development";
-  if (isDevelopment) {
-    return "debug";
-  }
-  if (isProduction) {
-    return "info";
-  }
-  return "warn";
-}
-function getConsoleConfig() {
-  const isProduction = process.env.NODE_ENV === "production";
-  return {
-    level: "debug",
-    enabled: true,
-    colorize: !isProduction
-    // Dev: colored output, Production: plain text
-  };
-}
-function getFileConfig() {
-  const isProduction = process.env.NODE_ENV === "production";
-  return {
-    level: "info",
-    enabled: isProduction,
-    // File logging in production only
-    logDir: process.env.LOG_DIR || "./logs",
-    maxFileSize: 10 * 1024 * 1024,
-    // 10MB
-    maxFiles: 10
-  };
-}
-function validateDirectoryWritable(dirPath) {
-  if (!existsSync(dirPath)) {
-    try {
-      mkdirSync(dirPath, { recursive: true });
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      throw new Error(`Failed to create log directory "${dirPath}": ${errorMessage}`);
-    }
-  }
-  try {
-    accessSync(dirPath, constants.W_OK);
-  } catch {
-    throw new Error(`Log directory "${dirPath}" is not writable. Please check permissions.`);
-  }
-  const testFile = join(dirPath, ".logger-write-test");
-  try {
-    writeFileSync(testFile, "test", "utf-8");
-    unlinkSync(testFile);
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    throw new Error(`Cannot write to log directory "${dirPath}": ${errorMessage}`);
-  }
-}
-function validateFileConfig() {
-  if (!isFileLoggingEnabled()) {
-    return;
-  }
-  const logDir = process.env.LOG_DIR;
-  if (!logDir) {
-    throw new Error(
-      "LOG_DIR environment variable is required when LOGGER_FILE_ENABLED=true. Example: LOG_DIR=/var/log/myapp"
-    );
-  }
-  validateDirectoryWritable(logDir);
-}
-function validateSlackConfig() {
-  const webhookUrl = process.env.SLACK_WEBHOOK_URL;
-  if (!webhookUrl) {
-    return;
-  }
-  if (!webhookUrl.startsWith("https://hooks.slack.com/")) {
-    throw new Error(
-      `Invalid SLACK_WEBHOOK_URL: "${webhookUrl}". Slack webhook URLs must start with "https://hooks.slack.com/"`
-    );
-  }
-}
-function validateEmailConfig() {
-  const smtpHost = process.env.SMTP_HOST;
-  const smtpPort = process.env.SMTP_PORT;
-  const emailFrom = process.env.EMAIL_FROM;
-  const emailTo = process.env.EMAIL_TO;
-  const hasAnyEmailConfig = smtpHost || smtpPort || emailFrom || emailTo;
-  if (!hasAnyEmailConfig) {
-    return;
-  }
-  const missingFields = [];
-  if (!smtpHost) missingFields.push("SMTP_HOST");
-  if (!smtpPort) missingFields.push("SMTP_PORT");
-  if (!emailFrom) missingFields.push("EMAIL_FROM");
-  if (!emailTo) missingFields.push("EMAIL_TO");
-  if (missingFields.length > 0) {
-    throw new Error(
-      `Email transport configuration incomplete. Missing: ${missingFields.join(", ")}. Either set all required fields or remove all email configuration.`
-    );
-  }
-  const port = parseInt(smtpPort, 10);
-  if (isNaN(port) || port < 1 || port > 65535) {
-    throw new Error(
-      `Invalid SMTP_PORT: "${smtpPort}". Must be a number between 1 and 65535.`
-    );
-  }
-  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-  if (!emailRegex.test(emailFrom)) {
-    throw new Error(`Invalid EMAIL_FROM format: "${emailFrom}"`);
-  }
-  const recipients = emailTo.split(",").map((e) => e.trim());
-  for (const email of recipients) {
-    if (!emailRegex.test(email)) {
-      throw new Error(`Invalid email address in EMAIL_TO: "${email}"`);
-    }
-  }
-}
-function validateEnvironment() {
-  const nodeEnv = process.env.NODE_ENV;
-  if (!nodeEnv) {
-    process.stderr.write(
-      "[Logger] Warning: NODE_ENV is not set. Defaulting to test environment.\n"
-    );
-  }
-}
-function validateConfig() {
-  try {
-    validateEnvironment();
-    validateFileConfig();
-    validateSlackConfig();
-    validateEmailConfig();
-  } catch (error) {
-    if (error instanceof Error) {
-      throw new Error(`[Logger] Configuration validation failed: ${error.message}`);
-    }
-    throw error;
-  }
-}
-
-// src/logger/factory.ts
-function initializeTransports() {
-  const transports = [];
-  const consoleConfig = getConsoleConfig();
-  transports.push(new ConsoleTransport(consoleConfig));
-  const fileConfig = getFileConfig();
-  if (fileConfig.enabled) {
-    transports.push(new FileTransport(fileConfig));
-  }
-  return transports;
-}
-function initializeLogger() {
-  validateConfig();
-  return new Logger({
-    level: getDefaultLogLevel(),
-    transports: initializeTransports()
-  });
-}
-var logger = initializeLogger();
-
-// src/codegen/core/orchestrator.ts
-var orchestratorLogger = logger.child("orchestrator");
+var orchestratorLogger = logger.child("@spfn/core:orchestrator");
 var CodegenOrchestrator = class {
   generators;
   cwd;
@@ -687,6 +14,7 @@ var CodegenOrchestrator = class {
   isGenerating = false;
   pendingRegenerations = /* @__PURE__ */ new Set();
   watcher;
+  watcherClosePromise;
   constructor(options) {
     this.generators = options.generators;
     this.cwd = options.cwd ?? process.cwd();
@@ -703,6 +31,10 @@ var CodegenOrchestrator = class {
       await this.watcher.close();
       this.watcher = void 0;
     }
+    if (this.watcherClosePromise) {
+      this.watcherClosePromise.resolve();
+      this.watcherClosePromise = void 0;
+    }
   }
   /**
    * Check if generator should run for given trigger
@@ -717,13 +49,15 @@ var CodegenOrchestrator = class {
    * @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
-      });
+    const activeGenerators = this.generators.filter((g) => this.shouldRun(g, trigger));
+    if (activeGenerators.length === 0) {
+      orchestratorLogger.info("No generators to run for this trigger", { trigger });
+      return;
     }
+    orchestratorLogger.info(`Running ${activeGenerators.length} generator(s)`, {
+      generators: activeGenerators.map((g) => g.name).join(", "),
+      trigger
+    });
     for (const generator of this.generators) {
       if (!this.shouldRun(generator, trigger)) {
         if (this.debug) {
@@ -732,6 +66,7 @@ var CodegenOrchestrator = class {
         continue;
       }
       try {
+        const startTime = Date.now();
         const genOptions = {
           cwd: this.cwd,
           debug: this.debug,
@@ -740,12 +75,11 @@ var CodegenOrchestrator = class {
           }
         };
         await generator.generate(genOptions);
-        if (this.debug) {
-          orchestratorLogger.info(`[${generator.name}] Generated successfully`);
-        }
+        const duration = Date.now() - startTime;
+        orchestratorLogger.info(`[${generator.name}] \u2713 Generated successfully (${duration}ms)`);
       } catch (error) {
         const err = error instanceof Error ? error : new Error(String(error));
-        orchestratorLogger.error(`[${generator.name}] Generation failed`, err);
+        orchestratorLogger.error(`[${generator.name}] \u2717 Generation failed`, err);
       }
     }
   }
@@ -765,8 +99,12 @@ var CodegenOrchestrator = class {
       dirsToWatch.add(join(this.cwd, baseDir));
     }
     const watchDirs = Array.from(dirsToWatch);
+    orchestratorLogger.info("Watch mode started", {
+      watching: watchDirs.length === 1 ? watchDirs[0] : `${watchDirs.length} directories`,
+      generators: this.generators.filter((g) => this.shouldRun(g, "watch")).map((g) => g.name).join(", ")
+    });
     if (this.debug) {
-      orchestratorLogger.info("Starting watch mode", {
+      orchestratorLogger.info("Watch mode details", {
         patterns: allPatterns,
         watchDirs,
         cwd: this.cwd
@@ -790,9 +128,9 @@ var CodegenOrchestrator = class {
       }
       this.isGenerating = true;
       this.pendingRegenerations.clear();
-      if (this.debug) {
-        orchestratorLogger.info(`File ${event}`, { file: filePath });
-      }
+      const eventIcon = event === "add" ? "+" : event === "unlink" ? "-" : "~";
+      orchestratorLogger.info(`File ${eventIcon} ${filePath}`);
+      let regeneratedCount = 0;
       for (const generator of this.generators) {
         if (!this.shouldRun(generator, "watch")) {
           continue;
@@ -802,6 +140,7 @@ var CodegenOrchestrator = class {
         );
         if (matches) {
           try {
+            const startTime = Date.now();
             const genOptions = {
               cwd: this.cwd,
               debug: this.debug,
@@ -814,15 +153,18 @@ var CodegenOrchestrator = class {
               }
             };
             await generator.generate(genOptions);
-            if (this.debug) {
-              orchestratorLogger.info(`[${generator.name}] Regenerated`);
-            }
+            const duration = Date.now() - startTime;
+            orchestratorLogger.info(`[${generator.name}] \u2713 Regenerated (${duration}ms)`);
+            regeneratedCount++;
           } catch (error) {
             const err = error instanceof Error ? error : new Error(String(error));
-            orchestratorLogger.error(`[${generator.name}] Regeneration failed`, err);
+            orchestratorLogger.error(`[${generator.name}] \u2717 Regeneration failed`, err);
           }
         }
       }
+      if (regeneratedCount === 0 && this.debug) {
+        orchestratorLogger.info("No generators matched this file");
+      }
       this.isGenerating = false;
       if (this.pendingRegenerations.size > 0) {
         const next = Array.from(this.pendingRegenerations)[0];
@@ -830,727 +172,37 @@ var CodegenOrchestrator = class {
       }
     };
     this.watcher.on("add", (path) => handleChange(path, "add")).on("change", (path) => handleChange(path, "change")).on("unlink", (path) => handleChange(path, "unlink"));
+    return new Promise((resolve, reject) => {
+      this.watcherClosePromise = { resolve, reject };
+    });
   }
 };
-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;
-}
-function generateTypeName(mapping) {
-  let name = mapping.contractName;
-  if (name.endsWith("Contract")) {
-    name = name.slice(0, -8);
-  }
-  if (name.length > 0) {
-    name = name.charAt(0).toUpperCase() + name.slice(1);
-  }
-  return name;
+var configLogger = logger.child("@spfn/core:codegen-config");
+function defineGenerator(config) {
+  return config;
 }
-function generateFunctionName(mapping) {
-  let name = mapping.contractName;
-  if (name.endsWith("Contract")) {
-    name = name.slice(0, -8);
-  }
-  return name;
+function defineConfig(config) {
+  return config;
 }
-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 += ` */
-`;
-  }
-  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);
-    }
-  }
-  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 += `
-`;
-    }
-  }
-  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}';
-`;
-    }
-  }
-  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/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 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;
-  }
-}
-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 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 true;
-    }
-    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
+function loadCodegenConfig(cwd) {
+  const rcTsPath = join(cwd, ".spfnrc.ts");
+  if (existsSync(rcTsPath)) {
+    try {
+      const jiti = createJiti(cwd, {
+        interopDefault: true,
+        moduleCache: false
       });
-    }
-    return true;
-  } catch (error) {
-    if (debug) {
+      const module = jiti(rcTsPath);
+      const config = module.default || module;
+      if (config && typeof config === "object") {
+        configLogger.info("Loaded config from .spfnrc.ts");
+        return config;
+      }
+    } catch (error) {
       const err = error instanceof Error ? error : new Error(String(error));
-      contractLogger.warn("Incremental update failed", err);
+      configLogger.warn("Failed to load .spfnrc.ts", err);
     }
-    return false;
-  }
-}
-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);
-    }
-  }
-  return changed;
-}
-var configLogger = logger.child("config");
-function loadCodegenConfig(cwd) {
   const rcPath = join(cwd, ".spfnrc.json");
   if (existsSync(rcPath)) {
     try {
@@ -1577,16 +229,18 @@ function loadCodegenConfig(cwd) {
       configLogger.warn("Failed to parse package.json", error);
     }
   }
-  configLogger.info("Using default config");
+  configLogger.info("Using default config (no generators)");
   return {
-    generators: [
-      { name: "@spfn/core:contract", enabled: true }
-    ]
+    generators: []
   };
 }
 async function loadGeneratorFromPackage(packageName, generatorName, config) {
   try {
-    const generatorsModule = await import(`${packageName}/generators`);
+    const jiti = createJiti(import.meta.url, {
+      interopDefault: true,
+      moduleCache: false
+    });
+    const generatorsModule = jiti(`${packageName}/codegen`);
     if (generatorsModule.generators?.[generatorName]) {
       const createFn = generatorsModule.generators[generatorName];
       const generator = createFn(config);
@@ -1601,7 +255,7 @@ async function loadGeneratorFromPackage(packageName, generatorName, config) {
       return generator;
     }
     configLogger.warn(
-      `Generator "${generatorName}" not found in ${packageName}/generators. Expected: generators.${generatorName} or ${conventionalName}`
+      `Generator "${generatorName}" not found in ${packageName}/codegen. Expected: generators.${generatorName} or ${conventionalName}`
     );
     return null;
   } catch (error) {
@@ -1616,9 +270,9 @@ function capitalize(str) {
   return str.charAt(0).toUpperCase() + str.slice(1);
 }
 async function createGeneratorsFromConfig(config, cwd) {
-  const generators = [];
+  const generators2 = [];
   if (!config.generators || config.generators.length === 0) {
-    return generators;
+    return generators2;
   }
   for (const generatorConfig of config.generators) {
     try {
@@ -1637,7 +291,7 @@ async function createGeneratorsFromConfig(config, cwd) {
         const createGenerator = module.default || module.createGenerator || module;
         if (typeof createGenerator === "function") {
           const generator = createGenerator();
-          generators.push(generator);
+          generators2.push(generator);
           configLogger.info(`Custom generator loaded: ${generator.name}`);
         } else {
           configLogger.warn(`Invalid generator at ${generatorPath}: expected function`);
@@ -1652,7 +306,7 @@ async function createGeneratorsFromConfig(config, cwd) {
             generatorOptions
           );
           if (generator) {
-            generators.push(generator);
+            generators2.push(generator);
           }
         }
       } else if ("name" in generatorConfig) {
@@ -1665,9 +319,12 @@ async function createGeneratorsFromConfig(config, cwd) {
       configLogger.error("Failed to load generator", err);
     }
   }
-  return generators;
+  return generators2;
 }
 
-export { CodegenOrchestrator, createContractGenerator, createGeneratorsFromConfig, loadCodegenConfig };
+// src/codegen/generators/index.ts
+var generators = {};
+
+export { CodegenOrchestrator, createGeneratorsFromConfig, defineConfig, defineGenerator, generators, loadCodegenConfig };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map