@atomic-ehr/codegen 0.0.1-canary.20250810124254.c6a6c21 → 0.0.1-canary.20250811234617.ea1d6c1

package/dist/{index-t2hbzagh.js → index-ts25e982.js}

@@ -18,6 +18,76 @@ var __toESM = (mod, isNodeMode, target) => {
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
+// node_modules/picocolors/picocolors.js
+var require_picocolors = __commonJS((exports, module) => {
+  var p = process || {};
+  var argv = p.argv || [];
+  var env = p.env || {};
+  var isColorSupported = !(!!env.NO_COLOR || argv.includes("--no-color")) && (!!env.FORCE_COLOR || argv.includes("--color") || p.platform === "win32" || (p.stdout || {}).isTTY && env.TERM !== "dumb" || !!env.CI);
+  var formatter = (open, close, replace = open) => (input) => {
+    let string = "" + input, index = string.indexOf(close, open.length);
+    return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
+  };
+  var replaceClose = (string, close, replace, index) => {
+    let result = "", cursor = 0;
+    do {
+      result += string.substring(cursor, index) + replace;
+      cursor = index + close.length;
+      index = string.indexOf(close, cursor);
+    } while (~index);
+    return result + string.substring(cursor);
+  };
+  var createColors = (enabled = isColorSupported) => {
+    let f = enabled ? formatter : () => String;
+    return {
+      isColorSupported: enabled,
+      reset: f("\x1B[0m", "\x1B[0m"),
+      bold: f("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m"),
+      dim: f("\x1B[2m", "\x1B[22m", "\x1B[22m\x1B[2m"),
+      italic: f("\x1B[3m", "\x1B[23m"),
+      underline: f("\x1B[4m", "\x1B[24m"),
+      inverse: f("\x1B[7m", "\x1B[27m"),
+      hidden: f("\x1B[8m", "\x1B[28m"),
+      strikethrough: f("\x1B[9m", "\x1B[29m"),
+      black: f("\x1B[30m", "\x1B[39m"),
+      red: f("\x1B[31m", "\x1B[39m"),
+      green: f("\x1B[32m", "\x1B[39m"),
+      yellow: f("\x1B[33m", "\x1B[39m"),
+      blue: f("\x1B[34m", "\x1B[39m"),
+      magenta: f("\x1B[35m", "\x1B[39m"),
+      cyan: f("\x1B[36m", "\x1B[39m"),
+      white: f("\x1B[37m", "\x1B[39m"),
+      gray: f("\x1B[90m", "\x1B[39m"),
+      bgBlack: f("\x1B[40m", "\x1B[49m"),
+      bgRed: f("\x1B[41m", "\x1B[49m"),
+      bgGreen: f("\x1B[42m", "\x1B[49m"),
+      bgYellow: f("\x1B[43m", "\x1B[49m"),
+      bgBlue: f("\x1B[44m", "\x1B[49m"),
+      bgMagenta: f("\x1B[45m", "\x1B[49m"),
+      bgCyan: f("\x1B[46m", "\x1B[49m"),
+      bgWhite: f("\x1B[47m", "\x1B[49m"),
+      blackBright: f("\x1B[90m", "\x1B[39m"),
+      redBright: f("\x1B[91m", "\x1B[39m"),
+      greenBright: f("\x1B[92m", "\x1B[39m"),
+      yellowBright: f("\x1B[93m", "\x1B[39m"),
+      blueBright: f("\x1B[94m", "\x1B[39m"),
+      magentaBright: f("\x1B[95m", "\x1B[39m"),
+      cyanBright: f("\x1B[96m", "\x1B[39m"),
+      whiteBright: f("\x1B[97m", "\x1B[39m"),
+      bgBlackBright: f("\x1B[100m", "\x1B[49m"),
+      bgRedBright: f("\x1B[101m", "\x1B[49m"),
+      bgGreenBright: f("\x1B[102m", "\x1B[49m"),
+      bgYellowBright: f("\x1B[103m", "\x1B[49m"),
+      bgBlueBright: f("\x1B[104m", "\x1B[49m"),
+      bgMagentaBright: f("\x1B[105m", "\x1B[49m"),
+      bgCyanBright: f("\x1B[106m", "\x1B[49m"),
+      bgWhiteBright: f("\x1B[107m", "\x1B[49m")
+    };
+  };
+  module.exports = createColors();
+  module.exports.createColors = createColors;
+});
+
 // src/typeschema/cache.ts
 import { existsSync, mkdirSync } from "node:fs";
 import { readdir, readFile, stat, unlink, writeFile } from "node:fs/promises";
@@ -1413,219 +1483,114 @@ function translate(structureDefinition, context) {
   }
   return normalizeSchema(stack[0]);
 }
-// src/logger.ts
-var LogLevel;
-((LogLevel2) => {
-  LogLevel2[LogLevel2["DEBUG"] = 0] = "DEBUG";
-  LogLevel2[LogLevel2["INFO"] = 1] = "INFO";
-  LogLevel2[LogLevel2["WARN"] = 2] = "WARN";
-  LogLevel2[LogLevel2["ERROR"] = 3] = "ERROR";
-  LogLevel2[LogLevel2["SILENT"] = 4] = "SILENT";
-})(LogLevel ||= {});
+// src/utils/codegen-logger.ts
+var import_picocolors = __toESM(require_picocolors(), 1);
 
-class ConsoleOutput {
-  useStderr;
-  constructor(useStderr = false) {
-    this.useStderr = useStderr;
+class CodegenLogger {
+  options;
+  constructor(options = {}) {
+    this.options = {
+      timestamp: false,
+      verbose: false,
+      ...options
+    };
   }
-  write(entry, formatted) {
-    const output = this.useStderr || entry.level >= 2 /* WARN */ ? console.error : console.log;
-    output(formatted);
+  formatMessage(level, message, color) {
+    const timestamp = this.options.timestamp ? `${import_picocolors.default.gray(new Date().toLocaleTimeString())} ` : "";
+    const prefix = this.options.prefix ? `${import_picocolors.default.cyan(`[${this.options.prefix}]`)} ` : "";
+    return `${timestamp}${color(level)} ${prefix}${message}`;
   }
-}
-
-class FileOutput {
-  filePath;
-  constructor(filePath) {
-    this.filePath = filePath;
-  }
-  async write(_entry, formatted) {
-    const _file = Bun.file(this.filePath);
-    const content = `${formatted}
-`;
-    try {
-      await Bun.write(this.filePath, content, { createPath: true });
-    } catch (error) {
-      console.error(`Failed to write to log file ${this.filePath}:`, error);
-      console.error(formatted);
-    }
+  success(message) {
+    console.log(this.formatMessage("✅", message, import_picocolors.default.green));
   }
-}
-
-class Logger {
-  config;
-  constructor(config = {}) {
-    this.config = {
-      level: 1 /* INFO */,
-      format: "pretty",
-      includeTimestamp: true,
-      includeContext: true,
-      colorize: true,
-      outputs: [new ConsoleOutput],
-      ...config
-    };
+  error(message, error) {
+    console.error(this.formatMessage("❌", message, import_picocolors.default.red));
+    if (error && this.options.verbose) {
+      console.error(import_picocolors.default.red(`   ${error.message}`));
+      if (error.stack) {
+        console.error(import_picocolors.default.gray(error.stack));
+      }
+    }
   }
-  configure(config) {
-    this.config = { ...this.config, ...config };
+  warn(message) {
+    console.warn(this.formatMessage("⚠️", message, import_picocolors.default.yellow));
   }
-  shouldLog(level) {
-    return level >= this.config.level;
+  info(message) {
+    console.log(this.formatMessage("ℹ️", message, import_picocolors.default.blue));
   }
-  createEntry(level, message, context, error, operation) {
-    const entry = {
-      timestamp: new Date().toISOString(),
-      level,
-      levelName: LogLevel[level],
-      message,
-      component: this.config.component
-    };
-    if (context && this.config.includeContext) {
-      entry.context = context;
-    }
-    if (operation) {
-      entry.operation = operation;
-    }
-    if (error) {
-      entry.error = {
-        name: error.name,
-        message: error.message,
-        stack: error.stack
-      };
+  debug(message) {
+    if (this.options.verbose) {
+      console.log(this.formatMessage("\uD83D\uDC1B", message, import_picocolors.default.magenta));
     }
-    return entry;
   }
-  formatEntry(entry) {
-    switch (this.config.format) {
-      case "json":
-        return JSON.stringify(entry);
-      case "compact":
-        return this.formatCompact(entry);
-      default:
-        return this.formatPretty(entry);
-    }
-  }
-  formatCompact(entry) {
-    const timestamp = this.config.includeTimestamp ? `${entry.timestamp} ` : "";
-    const component = entry.component ? `[${entry.component}] ` : "";
-    const operation = entry.operation ? `(${entry.operation}) ` : "";
-    const level = this.colorizeLevel(entry.levelName, entry.level);
-    return `${timestamp}${level} ${component}${operation}${entry.message}`;
-  }
-  formatPretty(entry) {
-    let formatted = "";
-    const timestamp = this.config.includeTimestamp ? `${entry.timestamp} ` : "";
-    const component = entry.component ? `[${entry.component}] ` : "";
-    const operation = entry.operation ? `(${entry.operation}) ` : "";
-    const level = this.colorizeLevel(entry.levelName.padEnd(5), entry.level);
-    formatted += `${timestamp}${level} ${component}${operation}${entry.message}`;
-    if (entry.context && Object.keys(entry.context).length > 0) {
-      formatted += `
-  Context: ${JSON.stringify(entry.context, null, 2).split(`
-`).join(`
-  `)}`;
-    }
-    if (entry.error) {
-      formatted += `
-  Error: [${entry.error.code || entry.error.name}] ${entry.error.message}`;
-      if (entry.error.context && Object.keys(entry.error.context).length > 0) {
-        formatted += `
-  Error Context: ${JSON.stringify(entry.error.context, null, 2).split(`
-`).join(`
-  `)}`;
-      }
-      if (entry.error.suggestions && entry.error.suggestions.length > 0) {
-        formatted += `
-  Suggestions:
-${entry.error.suggestions.map((s) => `    • ${s}`).join(`
-`)}`;
-      }
-      if (entry.level === 0 /* DEBUG */ && entry.error.stack) {
-        formatted += `
-  Stack: ${entry.error.stack.split(`
-`).join(`
-  `)}`;
-      }
-    }
-    return formatted;
-  }
-  colorizeLevel(levelName, level) {
-    if (!this.config.colorize) {
-      return levelName;
-    }
-    const colors = {
-      [0 /* DEBUG */]: "\x1B[36m",
-      [1 /* INFO */]: "\x1B[32m",
-      [2 /* WARN */]: "\x1B[33m",
-      [3 /* ERROR */]: "\x1B[31m"
-    };
-    const reset = "\x1B[0m";
-    const color = colors[level] || "";
-    return `${color}${levelName}${reset}`;
+  step(message) {
+    console.log(this.formatMessage("\uD83D\uDE80", message, import_picocolors.default.cyan));
   }
-  async writeEntry(entry) {
-    if (!this.shouldLog(entry.level)) {
-      return;
-    }
-    const formatted = this.formatEntry(entry);
-    for (const output of this.config.outputs) {
-      try {
-        await output.write(entry, formatted);
-      } catch (error) {
-        console.error("Logger output failed:", error);
-        console.error(formatted);
-      }
-    }
+  progress(message) {
+    console.log(this.formatMessage("⏳", message, import_picocolors.default.blue));
   }
-  async debug(message, context, operation) {
-    const entry = this.createEntry(0 /* DEBUG */, message, context, undefined, operation);
-    await this.writeEntry(entry);
+  plain(message, color = (s) => s) {
+    const timestamp = this.options.timestamp ? `${import_picocolors.default.gray(new Date().toLocaleTimeString())} ` : "";
+    const prefix = this.options.prefix ? `${import_picocolors.default.cyan(`[${this.options.prefix}]`)} ` : "";
+    console.log(`${timestamp}${prefix}${color(message)}`);
   }
-  async info(message, context, operation) {
-    const entry = this.createEntry(1 /* INFO */, message, context, undefined, operation);
-    await this.writeEntry(entry);
+  dim(message) {
+    this.plain(message, import_picocolors.default.gray);
   }
-  async warn(message, context, operation) {
-    const entry = this.createEntry(2 /* WARN */, message, context, undefined, operation);
-    await this.writeEntry(entry);
+  child(prefix) {
+    return new CodegenLogger({
+      ...this.options,
+      prefix: this.options.prefix ? `${this.options.prefix}:${prefix}` : prefix
+    });
   }
-  async error(message, error, context, operation) {
-    const entry = this.createEntry(3 /* ERROR */, message, context, error, operation);
-    await this.writeEntry(entry);
+  configure(options) {
+    this.options = { ...this.options, ...options };
   }
-  child(component, context) {
-    const childLogger = new Logger({
-      ...this.config,
-      component: this.config.component ? `${this.config.component}.${component}` : component
+}
+var defaultLogger = new CodegenLogger;
+function success(message) {
+  defaultLogger.success(message);
+}
+function error(message, err) {
+  defaultLogger.error(message, err);
+}
+function warn(message) {
+  defaultLogger.warn(message);
+}
+function info(message) {
+  defaultLogger.info(message);
+}
+function step(message) {
+  defaultLogger.step(message);
+}
+function dim(message) {
+  defaultLogger.dim(message);
+}
+function configure(options) {
+  defaultLogger.configure(options);
+}
+function createLogger(options = {}) {
+  return new CodegenLogger(options);
+}
+function header(title) {
+  console.log();
+  console.log(import_picocolors.default.cyan(import_picocolors.default.bold(`━━━ ${title} ━━━`)));
+}
+function complete(message, duration, stats) {
+  let msg = message;
+  if (duration) {
+    msg += ` ${import_picocolors.default.gray(`(${duration}ms)`)}`;
+  }
+  success(msg);
+  if (stats) {
+    Object.entries(stats).forEach(([key, value]) => {
+      dim(`  ${key}: ${value}`);
     });
-    if (context) {
-      const originalMethods = {
-        debug: childLogger.debug.bind(childLogger),
-        info: childLogger.info.bind(childLogger),
-        warn: childLogger.warn.bind(childLogger),
-        error: childLogger.error.bind(childLogger)
-      };
-      childLogger.debug = (message, additionalContext, operation) => originalMethods.debug(message, { ...context, ...additionalContext }, operation);
-      childLogger.info = (message, additionalContext, operation) => originalMethods.info(message, { ...context, ...additionalContext }, operation);
-      childLogger.warn = (message, additionalContext, operation) => originalMethods.warn(message, { ...context, ...additionalContext }, operation);
-      childLogger.error = (message, error, additionalContext, operation) => originalMethods.error(message, error, { ...context, ...additionalContext }, operation);
-    }
-    return childLogger;
   }
 }
-var logger = new Logger;
-function createLoggerFromConfig(config) {
-  const level = config?.debug ? 0 /* DEBUG */ : config?.verbose ? 1 /* INFO */ : config?.logLevel ? LogLevel[config.logLevel.toUpperCase()] ?? 1 /* INFO */ : 1 /* INFO */;
-  const format = config?.logFormat === "json" ? "json" : config?.logFormat === "compact" ? "compact" : "pretty";
-  const outputs = [new ConsoleOutput];
-  if (config?.logFile) {
-    outputs.push(new FileOutput(config.logFile));
-  }
-  return new Logger({
-    level,
-    format,
-    component: config?.component,
-    outputs,
-    colorize: !config?.logFile
+function list(items, bullet = "•") {
+  items.forEach((item) => {
+    console.log(import_picocolors.default.gray(`  ${bullet} ${item}`));
   });
 }
 
@@ -1769,8 +1734,8 @@ async function determineBaseKind(baseUrl, manager) {
       if (baseSchema.kind === "complex-type")
         return "complex-type";
     }
-  } catch (error) {
-    console.warn(`Could not resolve base schema ${baseUrl}:`, error);
+  } catch (error2) {
+    console.warn(`Could not resolve base schema ${baseUrl}:`, error2);
   }
   if (baseUrl.includes("StructureDefinition/") && !baseUrl.startsWith("http://hl7.org/fhir/StructureDefinition/")) {
     return "profile";
@@ -2139,8 +2104,8 @@ async function buildEnum(element, manager) {
       return;
     const codes = concepts.map((c) => c.code).filter((code) => code && typeof code === "string" && code.trim().length > 0);
     return codes.length > 0 && codes.length <= 50 ? codes : undefined;
-  } catch (error) {
-    console.debug(`Failed to extract enum values for ${valueSet}: ${error}`);
+  } catch (error2) {
+    console.debug(`Failed to extract enum values for ${valueSet}: ${error2}`);
     return;
   }
 }
@@ -2364,8 +2329,8 @@ async function transformValueSet(fhirSchema, _manager, packageInfo) {
       }
     }
     return valueSetSchema;
-  } catch (error) {
-    console.warn(`Failed to transform value set ${fhirSchema.name}: ${error}`);
+  } catch (error2) {
+    console.warn(`Failed to transform value set ${fhirSchema.name}: ${error2}`);
     return null;
   }
 }
@@ -2419,8 +2384,8 @@ async function transformExtension(fhirSchema, manager, packageInfo) {
     extensionSchema.dependencies = deduplicateDependencies(extensionSchema.dependencies);
     extensionSchema.dependencies = extensionSchema.dependencies.filter((dep) => dep.url !== identifier.url);
     return extensionSchema;
-  } catch (error) {
-    console.warn(`Failed to transform extension ${fhirSchema.name}: ${error}`);
+  } catch (error2) {
+    console.warn(`Failed to transform extension ${fhirSchema.name}: ${error2}`);
     return null;
   }
 }
@@ -2561,9 +2526,9 @@ class TypeSchemaGenerator {
     };
     this.manager = createCanonicalManager({ packages: [], workingDir: "tmp/fhir" });
     this.cacheConfig = cacheConfig;
-    this.logger = new Logger({
-      component: "TypeSchemaGenerator",
-      level: this.options.verbose ? 0 : 1
+    this.logger = options.logger || createLogger({
+      verbose: this.options.verbose,
+      prefix: "TypeSchema"
     });
   }
   async initializeCache() {
@@ -2578,11 +2543,11 @@ class TypeSchemaGenerator {
     if (this.cache && !forceRegenerate) {
       const cachedSchemas = this.cache.getByPackage(packageName);
       if (cachedSchemas.length > 0) {
-        await this.logger.info(`Using cached TypeSchemas for package: ${packageName}`, { schemasCount: cachedSchemas.length });
+        this.logger.info(`Using cached TypeSchemas for package: ${packageName} (${cachedSchemas.length} schemas)`);
         return cachedSchemas;
       }
     }
-    await this.logger.info(`Loading FHIR package: ${packageName}${packageVersion ? `@${packageVersion}` : ""}`, { packageName, packageVersion: packageVersion || "latest" }, "loadPackage");
+    this.logger.step(`Loading FHIR package: ${packageName}${packageVersion ? `@${packageVersion}` : ""}`);
     this.manager = createCanonicalManager({
       packages: [`${packageName}${packageVersion ? `@${packageVersion}` : ""}`],
       workingDir: "tmp/fhir"
@@ -2591,11 +2556,8 @@ class TypeSchemaGenerator {
     const allResources = await this.manager.search({});
     const structureDefinitions = allResources.filter((resource) => resource.resourceType === "StructureDefinition");
     const valueSets = allResources.filter((resource) => resource.resourceType === "ValueSet");
-    await this.logger.info(`Found resources in package`, {
-      structureDefinitions: structureDefinitions.length,
-      valueSets: valueSets.length
-    }, "scanPackage");
-    await this.logger.info("Converting StructureDefinitions to FHIRSchemas", { total: structureDefinitions.length }, "convertSchemas");
+    this.logger.info(`Found ${structureDefinitions.length} StructureDefinitions and ${valueSets.length} ValueSets in package`);
+    this.logger.progress(`Converting ${structureDefinitions.length} StructureDefinitions to FHIRSchemas`);
     const fhirSchemas = [];
     let convertedCount = 0;
     let failedCount = 0;
@@ -2604,26 +2566,15 @@ class TypeSchemaGenerator {
         const fhirSchema = translate(sd);
         fhirSchemas.push(fhirSchema);
         convertedCount++;
-        await this.logger.debug(`Converted StructureDefinition: ${sd.name || sd.id}`, { resourceType: sd.resourceType, url: sd.url });
-      } catch (error) {
+        this.logger.debug(`Converted StructureDefinition: ${sd.name || sd.id} (${sd.resourceType})`);
+      } catch (error2) {
         failedCount++;
-        await this.logger.warn(`Failed to convert StructureDefinition`, {
-          name: sd.name || sd.id,
-          resourceType: sd.resourceType,
-          error: error instanceof Error ? error.message : String(error)
-        });
+        this.logger.warn(`Failed to convert StructureDefinition ${sd.name || sd.id}: ${error2 instanceof Error ? error2.message : String(error2)}`);
       }
     }
-    await this.logger.info("Schema conversion completed", {
-      converted: convertedCount,
-      failed: failedCount,
-      total: structureDefinitions.length
-    }, "convertSchemas");
+    this.logger.success(`Schema conversion completed: ${convertedCount}/${structureDefinitions.length} successful, ${failedCount} failed`);
     if (valueSets.length > 0) {
-      await this.logger.debug("ValueSets available for enum extraction", {
-        count: valueSets.length,
-        valueSets: valueSets.map((vs) => vs.name || vs.id).slice(0, 10)
-      });
+      this.logger.debug(`${valueSets.length} ValueSets available for enum extraction`);
     }
     const packageInfo = {
       name: packageName,
@@ -2631,26 +2582,20 @@ class TypeSchemaGenerator {
     };
     const schemas = await this.generateFromSchemas(fhirSchemas, packageInfo);
     if (this.cache && schemas.length > 0) {
-      await this.logger.info("Caching generated schemas", { count: schemas.length, packageName }, "cacheSchemas");
+      this.logger.info(`Caching ${schemas.length} generated schemas for package: ${packageName}`);
       for (const schema of schemas) {
         await this.cache.set(schema);
       }
-      await this.logger.info(`Cached TypeSchemas for package: ${packageName}`, {
-        count: schemas.length
-      });
+      this.logger.success(`Cached ${schemas.length} TypeSchemas for package: ${packageName}`);
     }
     return schemas;
   }
   async generateFromSchema(fhirSchema, packageInfo) {
-    await this.logger.info("Transforming FHIR schema to TypeSchema", {
-      url: fhirSchema.url,
-      name: fhirSchema.name || "unnamed",
-      schemaType: fhirSchema.type
-    }, "transformSchema");
-    return await transformFHIRSchema(fhirSchema, this.manager, packageInfo);
+    this.logger.info("Transforming FHIR schema to TypeSchema");
+    return transformFHIRSchema(fhirSchema, this.manager, packageInfo);
   }
   async generateFromSchemas(fhirSchemas, packageInfo) {
-    await this.logger.info(`Transforming multiple FHIR schemas to TypeSchema`, { count: fhirSchemas.length }, "transformSchemas");
+    this.logger.info(`Transforming ${fhirSchemas.length} FHIR schemas to TypeSchema`);
     const baseSchemas = await transformFHIRSchemas(fhirSchemas, this.manager, packageInfo);
     const results = [];
     const groupedSchemas = this.groupTypeSchemas(baseSchemas);
@@ -2658,35 +2603,26 @@ class TypeSchemaGenerator {
     results.push(...groupedSchemas.complexTypes);
     results.push(...groupedSchemas.primitives);
     if (groupedSchemas.profiles.length > 0) {
-      await this.logger.info("Enhancing profiles", { count: groupedSchemas.profiles.length }, "enhanceProfiles");
+      this.logger.info(`Enhancing ${groupedSchemas.profiles.length} profiles`);
       const profileResults = await this.enhanceProfiles(groupedSchemas.profiles);
       results.push(...profileResults);
     }
     if (groupedSchemas.extensions.length > 0) {
-      await this.logger.info("Enhancing extensions", { count: groupedSchemas.extensions.length }, "enhanceExtensions");
+      this.logger.info(`Enhancing ${groupedSchemas.extensions.length} extensions`);
       const extensionResults = await this.enhanceExtensions(groupedSchemas.extensions);
       results.push(...extensionResults);
     }
     if (groupedSchemas.valueSets.length > 0) {
-      await this.logger.info("Enhancing value sets", { count: groupedSchemas.valueSets.length }, "enhanceValueSets");
+      this.logger.info(`Enhancing ${groupedSchemas.valueSets.length} value sets`);
       const valueSetResults = await this.enhanceValueSets(groupedSchemas.valueSets);
       results.push(...valueSetResults);
     }
     if (groupedSchemas.codeSystems.length > 0) {
-      await this.logger.info("Enhancing code systems", { count: groupedSchemas.codeSystems.length }, "enhanceCodeSystems");
+      this.logger.info(`Enhancing ${groupedSchemas.codeSystems.length} code systems`);
       const codeSystemResults = await this.enhanceCodeSystems(groupedSchemas.codeSystems);
       results.push(...codeSystemResults);
     }
-    await this.logger.info("Generated enhanced FHIR type schemas", {
-      totalSchemas: results.length,
-      resources: groupedSchemas.resources.length,
-      complexTypes: groupedSchemas.complexTypes.length,
-      primitives: groupedSchemas.primitives.length,
-      profiles: groupedSchemas.profiles.length,
-      extensions: groupedSchemas.extensions.length,
-      valueSets: groupedSchemas.valueSets.length,
-      codeSystems: groupedSchemas.codeSystems.length
-    });
+    this.logger.success(`Generated ${results.length} enhanced FHIR type schemas: ${groupedSchemas.resources.length} resources, ${groupedSchemas.complexTypes.length} complex types, ${groupedSchemas.primitives.length} primitives`);
     return results;
   }
   groupTypeSchemas(schemas) {
@@ -2894,9 +2830,9 @@ class TypeSchemaParser {
       try {
         const parsed = JSON.parse(line);
         schemas.push(this.parseSchema(parsed));
-      } catch (error) {
+      } catch (error2) {
         if (this.options.strict) {
-          throw new Error(`Failed to parse NDJSON line: ${error}`);
+          throw new Error(`Failed to parse NDJSON line: ${error2}`);
         }
       }
     }
@@ -2910,8 +2846,8 @@ class TypeSchemaParser {
       } else {
         return [this.parseSchema(parsed)];
       }
-    } catch (error) {
-      throw new Error(`Failed to parse JSON: ${error}`);
+    } catch (error2) {
+      throw new Error(`Failed to parse JSON: ${error2}`);
     }
   }
   validateSchemas(schemas) {
@@ -2962,6 +2898,7 @@ class SearchParameterEnhancer {
   resourceSearchParams = new Map;
   autocompleteEnabled;
   valueSetEnumsEnabled;
+  logger;
   availableEnumTypes = new Map;
   static BASE_PARAM_NAMES = [
     "_count",
@@ -2980,7 +2917,8 @@ class SearchParameterEnhancer {
   constructor(options) {
     this.autocompleteEnabled = !!options?.autocomplete;
     this.valueSetEnumsEnabled = !!options?.valueSetEnums;
-    console.log(`[DEBUG] SearchParameterEnhancer initialized: autocomplete=${this.autocompleteEnabled}, valueSetEnums=${this.valueSetEnumsEnabled}`);
+    this.logger = options?.logger || createLogger({ prefix: "SearchParam" });
+    this.logger.debug(`SearchParameterEnhancer initialized: autocomplete=${this.autocompleteEnabled}, valueSetEnums=${this.valueSetEnumsEnabled}`);
   }
   generateSearchParamNameUnions() {
     const baseUnion = SearchParameterEnhancer.BASE_PARAM_NAMES.map((n) => `'${n}'`).join(" | ");
@@ -4311,6 +4249,7 @@ class RestClientGenerator {
   resourceTypes = new Set;
   searchParameterEnhancer;
   validationGenerator;
+  logger;
   constructor(options) {
     this.options = {
       clientName: "FHIRClient",
@@ -4331,10 +4270,12 @@ class RestClientGenerator {
       generateValueSetEnums: true,
       ...options
     };
-    console.log(`[DEBUG] REST client configured with options:`, this.options);
+    this.logger = options.logger || createLogger({ prefix: "REST" });
+    this.logger.debug(`REST client configured: ${this.options.clientName}`);
     this.searchParameterEnhancer = new SearchParameterEnhancer({
       autocomplete: this.options.searchAutocomplete ?? false,
-      valueSetEnums: this.options.generateValueSetEnums ?? false
+      valueSetEnums: this.options.generateValueSetEnums ?? false,
+      logger: this.logger.child("Search")
     });
     this.validationGenerator = new ValidationGenerator;
   }
@@ -5056,7 +4997,7 @@ ${resourceTypesArray.map((type) => `  '${type}': ${type};`).join(`
 }
 
 // src/api/generators/typescript.ts
-import { mkdir as mkdir3, writeFile as writeFile5 } from "node:fs/promises";
+import { access as access2, mkdir as mkdir3, rm, writeFile as writeFile5 } from "node:fs/promises";
 import { dirname as dirname2, join as join11 } from "node:path";
 
 // src/utils.ts
@@ -5098,9 +5039,12 @@ class TypeScriptAPIGenerator {
   resourceTypes = new Set;
   currentSchemaName;
   profileTypes = new Set;
+  profilesByPackage = new Map;
+  packageNameMap = new Map;
   enumTypes = new Map;
   globalEnumTypes = new Map;
   fieldEnumMap = new Map;
+  logger;
   constructor(options) {
     this.options = {
       moduleFormat: "esm",
@@ -5111,6 +5055,7 @@ class TypeScriptAPIGenerator {
       includeProfiles: false,
       ...options
     };
+    this.logger = options.logger || createLogger({ prefix: "TypeScript" });
   }
   async transformSchema(schema) {
     this.currentSchemaName = this.formatTypeName(schema.identifier.name);
@@ -5124,7 +5069,7 @@ class TypeScriptAPIGenerator {
       return;
     }
     if (this.currentSchemaName === "Uri") {
-      console.log(schema);
+      this.logger.debug(`Processing schema: ${schema.identifier.name}`);
     }
     this.imports.clear();
     this.exports.clear();
@@ -5304,6 +5249,7 @@ class TypeScriptAPIGenerator {
     const filteredSchemas = this.filterSchemas(schemas);
     const results = await this.transformSchemas(filteredSchemas);
     const generatedFiles = [];
+    await this.cleanOutputDirectory();
     await mkdir3(this.options.outputDir, { recursive: true });
     if (this.options.includeProfiles) {
       await mkdir3(join11(this.options.outputDir, "profiles"), {
@@ -5525,6 +5471,17 @@ ${result.content}` : result.content;
     const dir = dirname2(filePath);
     await mkdir3(dir, { recursive: true });
   }
+  async cleanOutputDirectory() {
+    try {
+      await access2(this.options.outputDir);
+      this.logger.debug(`Cleaning output directory: ${this.options.outputDir}`);
+      await rm(this.options.outputDir, { recursive: true, force: true });
+    } catch (error2) {
+      if (error2?.code !== "ENOENT") {
+        this.logger.warn(`Failed to clean output directory: ${error2}`);
+      }
+    }
+  }
   filterSchemas(schemas) {
     if (this.options.includeExtensions) {
       return schemas;
@@ -5540,17 +5497,88 @@ ${result.content}` : result.content;
       subfolders.push("profiles");
     }
     for (const subfolder of subfolders) {
-      const subfolderResults = results.filter((r) => r.filename.startsWith(`${subfolder}/`));
-      const indexContent = this.generateSubfolderIndex(subfolderResults, subfolder);
-      const indexPath = join11(this.options.outputDir, subfolder, "index.ts");
-      await writeFile5(indexPath, indexContent, "utf-8");
+      if (subfolder === "profiles") {
+        await this.generateProfileIndexFiles(generatedFiles);
+      } else {
+        const subfolderResults = results.filter((r) => r.filename.startsWith(`${subfolder}/`));
+        const indexContent = this.generateSubfolderIndex(subfolderResults, subfolder);
+        const indexPath = join11(this.options.outputDir, subfolder, "index.ts");
+        await writeFile5(indexPath, indexContent, "utf-8");
+        generatedFiles.push({
+          path: indexPath,
+          filename: `${subfolder}/index.ts`,
+          content: indexContent,
+          exports: subfolderResults.flatMap((r) => r.exports)
+        });
+      }
+    }
+  }
+  async generateProfileIndexFiles(generatedFiles) {
+    for (const [
+      packageName,
+      profileNames
+    ] of this.profilesByPackage.entries()) {
+      const packageIndexContent = this.generatePackageIndex(packageName, profileNames);
+      const packageIndexPath = join11(this.options.outputDir, "profiles", packageName, "index.ts");
+      await writeFile5(packageIndexPath, packageIndexContent, "utf-8");
       generatedFiles.push({
-        path: indexPath,
-        filename: `${subfolder}/index.ts`,
-        content: indexContent,
-        exports: subfolderResults.flatMap((r) => r.exports)
+        path: packageIndexPath,
+        filename: `profiles/${packageName}/index.ts`,
+        content: packageIndexContent,
+        exports: profileNames
       });
     }
+    const mainProfilesIndex = this.generateMainProfilesIndex();
+    const mainIndexPath = join11(this.options.outputDir, "profiles", "index.ts");
+    await writeFile5(mainIndexPath, mainProfilesIndex, "utf-8");
+    generatedFiles.push({
+      path: mainIndexPath,
+      filename: "profiles/index.ts",
+      content: mainProfilesIndex,
+      exports: Array.from(this.profilesByPackage.keys())
+    });
+  }
+  generatePackageIndex(packageName, profileNames) {
+    const lines = [];
+    lines.push("/**");
+    lines.push(` * ${packageName} Profiles Index`);
+    lines.push(" * ");
+    lines.push(" * Auto-generated exports for all profile types in this package.");
+    lines.push(" */");
+    lines.push("");
+    if (profileNames.length === 0) {
+      lines.push("// No profiles in this package");
+      lines.push("export {};");
+      return lines.join(`
+`);
+    }
+    for (const profileName of profileNames) {
+      lines.push(`export type { ${profileName} } from './${profileName}';`);
+    }
+    return lines.join(`
+`);
+  }
+  generateMainProfilesIndex() {
+    const lines = [];
+    lines.push("/**");
+    lines.push(" * Profiles Index");
+    lines.push(" * ");
+    lines.push(" * Auto-generated namespace exports for all profile packages.");
+    lines.push(" */");
+    lines.push("");
+    if (this.profilesByPackage.size === 0) {
+      lines.push("// No profile packages found");
+      lines.push("export {};");
+      return lines.join(`
+`);
+    }
+    for (const sanitizedPackageName of this.profilesByPackage.keys()) {
+      const originalPackageName = this.packageNameMap.get(sanitizedPackageName);
+      const namespaceNameForExport = this.generateNamespaceName(originalPackageName);
+      lines.push(`export * as ${namespaceNameForExport} from './${sanitizedPackageName}';`);
+    }
+    return lines.join(`
+`);
   }
   generateSubfolderIndex(results, subfolder) {
     const lines = [];
@@ -5600,18 +5628,49 @@ ${result.content}` : result.content;
   }
   getBaseInterface(schema) {
     if ((isTypeSchemaForResourceComplexTypeLogical(schema) || schema.identifier.kind === "profile") && schema.base) {
-      return this.getType(schema.base);
+      const baseIdentifier = schema.base;
+      const typeInfo = this.getType(baseIdentifier);
+      return {
+        ...typeInfo,
+        baseIdentifier
+      };
     }
     return null;
   }
   getFilename(identifier) {
     const name = toPascalCase(identifier.name);
     if (identifier.kind === "profile" && this.options.includeProfiles) {
-      const subfolder = "profiles";
+      const originalPackageName = identifier.package;
+      const sanitizedPackageName = this.sanitizePackageName(originalPackageName);
+      const subfolder = `profiles/${sanitizedPackageName}`;
+      if (!this.profilesByPackage.has(sanitizedPackageName)) {
+        this.profilesByPackage.set(sanitizedPackageName, []);
+        this.packageNameMap.set(sanitizedPackageName, originalPackageName);
+      }
+      this.profilesByPackage.get(sanitizedPackageName).push(name);
       return `${subfolder}/${name}.ts`;
     }
     return `${name}.ts`;
   }
+  sanitizePackageName(packageName) {
+    return packageName.replace(/[@/.]/g, "-").replace(/[^a-zA-Z0-9\-_]/g, "").toLowerCase();
+  }
+  generateNamespaceName(originalPackageName) {
+    return originalPackageName.split(".").map((segment) => this.toPascalCase(segment)).join("");
+  }
+  calculateImportPath(currentSchema, baseIdentifier) {
+    if (baseIdentifier.kind === "profile") {
+      const currentPackage = this.sanitizePackageName(currentSchema.identifier.package);
+      const basePackage = this.sanitizePackageName(baseIdentifier.package);
+      if (currentPackage === basePackage) {
+        return `./${this.formatTypeName(baseIdentifier.name)}`;
+      } else {
+        return `../${basePackage}/${this.formatTypeName(baseIdentifier.name)}`;
+      }
+    } else {
+      return `../../${this.formatTypeName(baseIdentifier.name)}`;
+    }
+  }
   async generateProfile(schema) {
     this.imports.clear();
     this.exports.clear();
@@ -5639,9 +5698,9 @@ ${result.content}` : result.content;
     }
     this.exports.add(interfaceName);
     const baseInterface = this.getBaseInterface(schema);
-    if (baseInterface && !baseInterface.isPrimitive) {
-      const importPath = baseInterface.value;
-      this.imports.set(baseInterface.value, `../${importPath}`);
+    if (baseInterface && !baseInterface.isPrimitive && baseInterface.baseIdentifier) {
+      const importPath = this.calculateImportPath(schema, baseInterface.baseIdentifier);
+      this.imports.set(baseInterface.value, importPath);
       lines.push(`export interface ${interfaceName} extends ${baseInterface.value} {`);
     } else {
       lines.push(`export interface ${interfaceName} {`);
@@ -5697,7 +5756,8 @@ ${result.content}` : result.content;
       } else if (field.type) {
         const subType = this.getType(field.type);
         if (!subType.isPrimitive) {
-          this.imports.set(subType.value, `../${subType.value}`);
+          const importPath = this.calculateImportPath(schema, field.type);
+          this.imports.set(subType.value, importPath);
         }
         typeString = subType.value;
       }
@@ -5709,7 +5769,8 @@ ${result.content}` : result.content;
       } else if (field.type) {
         const subType = this.getType(field.type);
         if (!subType.isPrimitive) {
-          this.imports.set(subType.value, `../${subType.value}`);
+          const importPath = this.calculateImportPath(schema, field.type);
+          this.imports.set(subType.value, importPath);
         }
         typeString = subType.value;
       }
@@ -5741,8 +5802,9 @@ ${result.content}` : result.content;
     lines.push("\tconst errors: string[] = [];");
     lines.push("");
     const baseInterface = this.getBaseInterface(schema);
-    if (baseInterface && !baseInterface.isPrimitive) {
-      this.imports.set(`is${baseInterface.value}`, `../${baseInterface.value}`);
+    if (baseInterface && !baseInterface.isPrimitive && baseInterface.baseIdentifier) {
+      const importPath = this.calculateImportPath(schema, baseInterface.baseIdentifier);
+      this.imports.set(`is${baseInterface.value}`, importPath);
       lines.push(`	// Validate base resource`);
       lines.push(`	if (!is${baseInterface.value}(resource)) {`);
       lines.push(`		return { valid: false, errors: ['Not a valid ${baseInterface.value} resource'] };`);
@@ -5779,7 +5841,7 @@ ${result.content}` : result.content;
     lines.push("\t\terrors");
     lines.push("\t};");
     lines.push("}");
-    this.imports.set("ValidationResult", "../types");
+    this.imports.set("ValidationResult", "../../types");
     return lines.join(`
 `);
   }
@@ -5917,8 +5979,9 @@ ${result.content}` : result.content;
     lines.push(" */");
     lines.push(`export function ${guardName}(resource: unknown): resource is ${interfaceName} {`);
     const baseInterface = this.getBaseInterface(schema);
-    if (baseInterface && !baseInterface.isPrimitive) {
-      this.imports.set(`is${baseInterface.value}`, `../${baseInterface.value}`);
+    if (baseInterface && !baseInterface.isPrimitive && baseInterface.baseIdentifier) {
+      const importPath = this.calculateImportPath(schema, baseInterface.baseIdentifier);
+      this.imports.set(`is${baseInterface.value}`, importPath);
       lines.push(`	if (!is${baseInterface.value}(resource)) return false;`);
       lines.push("");
       lines.push(`	const typed = resource as ${baseInterface.value};`);
@@ -5988,28 +6051,28 @@ class APIBuilder {
       typeSchemaConfig: options.typeSchemaConfig
     };
     this.typeSchemaConfig = options.typeSchemaConfig;
-    this.logger = new Logger({
-      component: "APIBuilder",
-      level: this.options.verbose ? 0 : 1
+    this.logger = options.logger || createLogger({
+      verbose: this.options.verbose,
+      prefix: "API"
     });
     if (this.options.cache) {
       this.cache = new TypeSchemaCache(this.typeSchemaConfig);
     }
   }
   fromPackage(packageName, version) {
-    this.logger.info(`Configuring generation from FHIR package`, { packageName, version: version || "latest" }, "fromPackage");
+    this.logger.debug(`Loading from FHIR package: ${packageName}@${version || "latest"}`);
     const operation = this.loadFromPackage(packageName, version);
     this.pendingOperations.push(operation);
     return this;
   }
   fromFiles(...filePaths) {
-    this.logger.info(`Configuring generation from TypeSchema files`, { count: filePaths.length, files: filePaths.slice(0, 5) }, "fromFiles");
+    this.logger.debug(`Loading from ${filePaths.length} TypeSchema files`);
     const operation = this.loadFromFiles(filePaths);
     this.pendingOperations.push(operation);
     return this;
   }
   fromSchemas(schemas) {
-    this.logger.info(`Adding TypeSchemas to generation`, { count: schemas.length }, "fromSchemas");
+    this.logger.debug(`Adding ${schemas.length} TypeSchemas to generation`);
     this.schemas = [...this.schemas, ...schemas];
     return this;
   }
@@ -6022,33 +6085,22 @@ class APIBuilder {
       includeDocuments: options.includeDocuments ?? true,
       namingConvention: options.namingConvention || "PascalCase",
       includeExtensions: options.includeExtensions ?? false,
-      includeProfiles: options.includeProfiles ?? false
+      includeProfiles: options.includeProfiles ?? false,
+      logger: this.logger.child("TS")
     });
     this.generators.set("typescript", generator);
-    this.logger.info("Configured TypeScript generator", {
-      outputDir: typesOutputDir,
-      moduleFormat: options.moduleFormat || "esm",
-      generateValidators: options.generateValidators ?? true,
-      generateGuards: options.generateGuards ?? true,
-      generateBuilders: options.generateBuilders ?? false
-    }, "typescript");
+    this.logger.debug(`Configured TypeScript generator (${options.moduleFormat || "esm"})`);
     return this;
   }
   restClient(options = {}) {
     const clientOutputDir = `${this.options.outputDir}/client`;
     const generator = new RestClientGenerator({
       outputDir: clientOutputDir,
+      logger: this.logger.child("REST"),
       ...options
     });
     this.generators.set("restclient", generator);
-    this.logger.info("Configured REST client generator", {
-      outputDir: clientOutputDir,
-      clientName: options.clientName || "FHIRClient",
-      includeValidation: options.includeValidation ?? false,
-      includeErrorHandling: options.includeErrorHandling ?? true,
-      enhancedSearch: options.enhancedSearch ?? false,
-      useCanonicalManager: options.useCanonicalManager ?? true
-    }, "restclient");
+    this.logger.debug(`Configured REST client generator (${options.clientName || "FHIRClient"})`);
     return this;
   }
   onProgress(callback) {
@@ -6056,7 +6108,7 @@ class APIBuilder {
     return this;
   }
   outputTo(directory) {
-    this.logger.info(`Setting output directory`, { directory, generatorCount: this.generators.size }, "outputTo");
+    this.logger.debug(`Setting output directory: ${directory}`);
     this.options.outputDir = directory;
     for (const generator of this.generators.values()) {
       if (generator.setOutputDir) {
@@ -6077,7 +6129,7 @@ class APIBuilder {
     const hasRestClient = this.generators.has("restclient");
     const hasTypeScript = this.generators.has("typescript");
     if (hasRestClient && !hasTypeScript) {
-      this.logger.info("Automatically adding TypeScript generator for REST client", {}, "ensureTypeScriptForRestClient");
+      this.logger.debug("Automatically adding TypeScript generator for REST client");
       this.typescript({
         moduleFormat: "esm",
         generateIndex: true,
@@ -6097,41 +6149,26 @@ class APIBuilder {
       warnings: [],
       duration: 0
     };
-    await this.logger.info("Starting code generation", {
-      outputDir: this.options.outputDir,
-      pendingOperations: this.pendingOperations.length,
-      generatorTypes: Array.from(this.generators.keys()),
-      validate: this.options.validate,
-      cache: this.options.cache
-    }, "generate");
+    this.logger.debug(`Starting generation with ${this.generators.size} generators`);
     try {
       this.reportProgress("Loading", 0, 4, "Loading TypeSchema data...");
       await this.resolveSchemas();
-      await this.logger.info("Schemas resolved", { schemasCount: this.schemas.length }, "resolveSchemas");
+      this.logger.debug(`Resolved ${this.schemas.length} schemas`);
       this.reportProgress("Validating", 1, 4, "Validating TypeSchema documents...");
       if (this.options.validate) {
-        await this.logger.info("Starting schema validation", {}, "validate");
+        this.logger.debug("Starting schema validation");
         await this.validateSchemas(result);
-        await this.logger.info("Schema validation completed", { warnings: result.warnings.length }, "validate");
+        this.logger.debug("Schema validation completed");
       }
       this.reportProgress("Generating", 2, 4, "Generating code...");
-      await this.logger.info("Starting code generation", { generatorCount: this.generators.size }, "executeGenerators");
+      this.logger.debug(`Executing ${this.generators.size} generators`);
       await this.executeGenerators(result);
       this.reportProgress("Complete", 4, 4, "Generation completed successfully");
       result.success = result.errors.length === 0;
-      await this.logger.info("Code generation completed", {
-        success: result.success,
-        filesGenerated: result.filesGenerated.length,
-        errors: result.errors.length,
-        warnings: result.warnings.length,
-        duration: `${Math.round(result.duration)}ms`
-      }, "generate");
-    } catch (error) {
-      await this.logger.error("Code generation failed", error instanceof Error ? error : new Error(String(error)), {
-        outputDir: this.options.outputDir,
-        schemasCount: this.schemas.length
-      });
-      result.errors.push(error instanceof Error ? error.message : String(error));
+      this.logger.debug(`Generation completed: ${result.filesGenerated.length} files`);
+    } catch (error2) {
+      this.logger.error("Code generation failed", error2 instanceof Error ? error2 : new Error(String(error2)));
+      result.errors.push(error2 instanceof Error ? error2.message : String(error2));
       result.success = false;
     } finally {
       result.duration = performance.now() - startTime;
@@ -6162,7 +6199,8 @@ class APIBuilder {
   }
   async loadFromPackage(packageName, version) {
     const generator = new TypeSchemaGenerator({
-      verbose: this.options.verbose
+      verbose: this.options.verbose,
+      logger: this.logger.child("Schema")
     }, this.typeSchemaConfig);
     this.typeSchemaGenerator = generator;
     const schemas = await generator.generateFromPackage(packageName, version);
@@ -6174,7 +6212,8 @@ class APIBuilder {
   async loadFromFiles(filePaths) {
     if (!this.typeSchemaGenerator) {
       this.typeSchemaGenerator = new TypeSchemaGenerator({
-        verbose: this.options.verbose
+        verbose: this.options.verbose,
+        logger: this.logger.child("Schema")
       }, this.typeSchemaConfig);
     }
     const parser = new TypeSchemaParser({
@@ -6204,8 +6243,8 @@ class APIBuilder {
       try {
         const files = await generator.generate(this.schemas);
         result.filesGenerated.push(...files.map((f) => f.path || f.filename));
-      } catch (error) {
-        result.errors.push(`${type} generator failed: ${error instanceof Error ? error.message : String(error)}`);
+      } catch (error2) {
+        result.errors.push(`${type} generator failed: ${error2 instanceof Error ? error2.message : String(error2)}`);
       }
       current++;
     }
@@ -6215,7 +6254,7 @@ class APIBuilder {
       this.progressCallback(phase, current, total, message);
     }
     if (this.options.verbose && message) {
-      console.log(`[${phase}] ${message}`);
+      this.logger.debug(`[${phase}] ${message}`);
     }
   }
 }
@@ -6368,7 +6407,7 @@ var DEFAULT_CONFIG = {
   },
   packages: [],
   files: [],
-  $schema: "https://atomic-ehr.github.io/codegen/config-schema.json"
+  $schema: ""
 };
 var CONFIG_FILE_NAMES = [
   "atomic-codegen.config.ts",
@@ -6834,11 +6873,11 @@ class ConfigLoader {
 ${errorMessages}`);
       }
       return this.mergeWithDefaults(validation.config);
-    } catch (error) {
-      if (error instanceof Error) {
-        throw new Error(`Failed to load config from ${filePath}: ${error.message}`);
+    } catch (error2) {
+      if (error2 instanceof Error) {
+        throw new Error(`Failed to load config from ${filePath}: ${error2.message}`);
       }
-      throw error;
+      throw error2;
     }
   }
   async findConfigFile(startDir) {
@@ -6875,4 +6914,4 @@ function isConfig(obj) {
   return result.valid;
 }
 
-export { __toESM, __commonJS, __require, TypeSchemaCache, createLoggerFromConfig, TypeSchemaGenerator, TypeSchemaParser, RestClientGenerator, TypeScriptAPIGenerator, APIBuilder, createAPI, createAPIFromConfig, generateTypesFromPackage, generateTypesFromFiles, DEFAULT_CONFIG, CONFIG_FILE_NAMES, ConfigValidator, ConfigLoader, configLoader, loadConfig, isConfig };
+export { __toESM, __commonJS, __require, TypeSchemaCache, require_picocolors, success, error, warn, info, step, configure, createLogger, header, complete, list, TypeSchemaGenerator, TypeSchemaParser, RestClientGenerator, TypeScriptAPIGenerator, APIBuilder, createAPI, createAPIFromConfig, generateTypesFromPackage, generateTypesFromFiles, DEFAULT_CONFIG, CONFIG_FILE_NAMES, ConfigValidator, ConfigLoader, configLoader, loadConfig, isConfig };