@atomic-ehr/codegen 0.0.1-canary.20251007094146.5297616 → 0.0.1-canary.20251007123452.75482df

package/dist/index.js

@@ -1414,7 +1414,7 @@ function isBindingSchema(schema) {
 }
 
 // src/typeschema/register.ts
-var registerFromManager = async (manager, logger) => {
+var registerFromManager = async (manager, logger2) => {
   const packages = await manager.packages();
   const flatRawIndex = {};
   const indexByPackages = [];
@@ -1450,7 +1450,7 @@ var registerFromManager = async (manager, logger) => {
           nameToCanonical[rfs.name] = rfs.url;
           fsSuccess++;
         } catch (error) {
-          logger?.warn(
+          logger2?.warn(
             `Failed to convert StructureDefinition ${sd.name || sd.id}: ${error instanceof Error ? error.message : String(error)}`
           );
           fsFailed++;
@@ -1463,7 +1463,7 @@ var registerFromManager = async (manager, logger) => {
         vsIndex[resource.url] = resource;
       }
     }
-    logger?.success(
+    logger2?.success(
       `FHIR Schema conversion for '${packageMetaToFhir(packageMeta)}' completed: ${fsSuccess} successful, ${fsFailed} failed`
     );
   }
@@ -1596,7 +1596,7 @@ function mkBindingIdentifier(fhirSchema, path, bindingName) {
 }
 
 // src/typeschema/profile/processor.ts
-async function transformProfile(register, fhirSchema) {
+async function transformProfile(register, fhirSchema, logger2) {
   const identifier = mkIdentifier(fhirSchema);
   if (identifier.kind !== "profile") {
     throw new Error(`Expected profile, got ${identifier.kind} for ${fhirSchema.name}`);
@@ -1628,7 +1628,7 @@ async function transformProfile(register, fhirSchema) {
     profileSchema.metadata = metadata;
   }
   if (fhirSchema.elements) {
-    const fields = await mkFields(register, fhirSchema, [], fhirSchema.elements);
+    const fields = await mkFields(register, fhirSchema, [], fhirSchema.elements, logger2);
     if (fields && Object.keys(fields).length > 0) {
       profileSchema.fields = fields;
     }
@@ -1825,13 +1825,13 @@ function buildFieldType(register, fhirSchema, element) {
   }
   return void 0;
 }
-var mkField = (register, fhirSchema, path, element) => {
+var mkField = (register, fhirSchema, path, element, logger2) => {
   let binding;
   let enumValues;
   if (element.binding) {
     binding = mkBindingIdentifier(fhirSchema, path, element.binding.bindingName);
     if (element.binding.strength === "required" && element.type === "code") {
-      enumValues = buildEnum(register, element);
+      enumValues = buildEnum(register, element, logger2);
     }
   }
   return {
@@ -1864,13 +1864,13 @@ function mkNestedField(register, fhirSchema, path, element) {
 }
 
 // src/typeschema/core/binding.ts
-function extractValueSetConceptsByUrl(register, valueSetUrl) {
+function extractValueSetConceptsByUrl(register, valueSetUrl, logger2) {
   const cleanUrl = dropVersionFromUrl(valueSetUrl) || valueSetUrl;
   const valueSet = register.resolveVs(cleanUrl);
   if (!valueSet) return void 0;
   return extractValueSetConcepts(register, valueSet);
 }
-function extractValueSetConcepts(register, valueSet) {
+function extractValueSetConcepts(register, valueSet, _logger) {
   if (valueSet.expansion?.contains) return valueSet.expansion.contains;
   const concepts = [];
   if (valueSet.compose?.include) {
@@ -1909,7 +1909,7 @@ function extractValueSetConcepts(register, valueSet) {
   return concepts.length > 0 ? concepts : void 0;
 }
 var MAX_ENUM_LENGTH = 100;
-function buildEnum(register, element) {
+function buildEnum(register, element, logger2) {
   if (!element.binding) return void 0;
   const strength = element.binding.strength;
   const valueSetUrl = element.binding.valueSet;
@@ -1920,14 +1920,14 @@ function buildEnum(register, element) {
   if (!concepts || concepts.length === 0) return void 0;
   const codes = concepts.map((c) => c.code).filter((code) => code && typeof code === "string" && code.trim().length > 0);
   if (codes.length > MAX_ENUM_LENGTH) {
-    console.warn(
+    logger2?.dry_warn(
       `Value set ${valueSetUrl} has ${codes.length} which is more than ${MAX_ENUM_LENGTH} codes, which may cause issues with code generation.`
     );
     return void 0;
   }
   return codes.length > 0 ? codes : void 0;
 }
-function generateBindingSchema(register, fhirSchema, path, element) {
+function generateBindingSchema(register, fhirSchema, path, element, logger2) {
   if (!element.binding?.valueSet) return void 0;
   const identifier = mkBindingIdentifier(fhirSchema, path, element.binding.bindingName);
   const fieldType = buildFieldType(register, fhirSchema, element);
@@ -1937,7 +1937,7 @@ function generateBindingSchema(register, fhirSchema, path, element) {
     dependencies.push(fieldType);
   }
   dependencies.push(valueSetIdentifier);
-  const enumValues = buildEnum(register, element);
+  const enumValues = buildEnum(register, element, logger2);
   return {
     identifier,
     type: fieldType,
@@ -1947,7 +1947,7 @@ function generateBindingSchema(register, fhirSchema, path, element) {
     dependencies
   };
 }
-function collectBindingSchemas(register, fhirSchema) {
+function collectBindingSchemas(register, fhirSchema, logger2) {
   const processedPaths = /* @__PURE__ */ new Set();
   if (!fhirSchema.elements) return [];
   const bindings = [];
@@ -1958,7 +1958,7 @@ function collectBindingSchemas(register, fhirSchema) {
       if (processedPaths.has(pathKey)) continue;
       processedPaths.add(pathKey);
       if (element.binding) {
-        const binding = generateBindingSchema(register, fhirSchema, path, element);
+        const binding = generateBindingSchema(register, fhirSchema, path, element, logger2);
         if (binding) {
           bindings.push(binding);
         }
@@ -1995,19 +1995,19 @@ function collectNestedElements(fhirSchema, parentPath, elements) {
   }
   return nested;
 }
-function transformNestedElements(fhirSchema, parentPath, elements, register) {
+function transformNestedElements(fhirSchema, parentPath, elements, register, logger2) {
   const fields = {};
   for (const [key, element] of Object.entries(elements)) {
     const path = [...parentPath, key];
     if (isNestedElement(element)) {
       fields[key] = mkNestedField(register, fhirSchema, path, element);
     } else {
-      fields[key] = mkField(register, fhirSchema, path, element);
+      fields[key] = mkField(register, fhirSchema, path, element, logger2);
     }
   }
   return fields;
 }
-function mkNestedTypes(register, fhirSchema) {
+function mkNestedTypes(register, fhirSchema, logger2) {
   if (!fhirSchema.elements) return void 0;
   const nestedElements = collectNestedElements(fhirSchema, [], fhirSchema.elements);
   const actualNested = nestedElements.filter(
@@ -2034,7 +2034,7 @@ function mkNestedTypes(register, fhirSchema) {
         url: `http://hl7.org/fhir/StructureDefinition/${element.type}`
       };
     }
-    const fields = transformNestedElements(fhirSchema, path, element.elements, register);
+    const fields = transformNestedElements(fhirSchema, path, element.elements, register, logger2);
     const nestedType = {
       identifier,
       base,
@@ -2064,7 +2064,7 @@ function extractNestedDependencies(nestedTypes) {
 }
 
 // src/typeschema/core/transformer.ts
-function mkFields(register, fhirSchema, parentPath, elements) {
+function mkFields(register, fhirSchema, parentPath, elements, logger2) {
   if (!elements) return void 0;
   const geneology = register.resolveFsGenealogy(fhirSchema.url);
   const elems = {};
@@ -2089,7 +2089,7 @@ function mkFields(register, fhirSchema, parentPath, elements) {
     if (isNestedElement(elemSnapshot)) {
       fields[key] = mkNestedField(register, fhirSchema, path, elemSnapshot);
     } else {
-      fields[key] = mkField(register, fhirSchema, path, elemSnapshot);
+      fields[key] = mkField(register, fhirSchema, path, elemSnapshot, logger2);
     }
   }
   return fields;
@@ -2134,7 +2134,7 @@ function isExtensionSchema(fhirSchema, _identifier) {
   }
   return false;
 }
-async function transformValueSet(register, valueSet) {
+async function transformValueSet(register, valueSet, logger2) {
   if (!valueSet.url) throw new Error("ValueSet URL is required");
   const identifier = mkValueSetIdentifierByUrl(register, valueSet.url);
   const concept = extractValueSetConceptsByUrl(register, valueSet.url);
@@ -2145,7 +2145,7 @@ async function transformValueSet(register, valueSet) {
     compose: !concept ? valueSet.compose : void 0
   };
 }
-async function transformExtension(fhirSchema, register, _packageInfo) {
+async function transformExtension(fhirSchema, register, logger2) {
   try {
     const identifier = mkIdentifier(fhirSchema);
     let base;
@@ -2182,13 +2182,13 @@ async function transformExtension(fhirSchema, register, _packageInfo) {
       extensionSchema.dependencies.push(base);
     }
     if (fhirSchema.elements) {
-      const fields = mkFields(register, fhirSchema, [], fhirSchema.elements);
+      const fields = mkFields(register, fhirSchema, [], fhirSchema.elements, logger2);
       if (fields && Object.keys(fields).length > 0) {
         extensionSchema.fields = fields;
         extensionSchema.dependencies.push(...extractFieldDependencies(fields));
       }
     }
-    const nestedTypes = mkNestedTypes(register, fhirSchema);
+    const nestedTypes = mkNestedTypes(register, fhirSchema, logger2);
     if (nestedTypes && nestedTypes.length > 0) {
       extensionSchema.nested = nestedTypes;
       extensionSchema.dependencies.push(...extractNestedDependencies(nestedTypes));
@@ -2215,7 +2215,7 @@ function extractDependencies(identifier, base, fields, nestedTypes) {
   const result = Object.values(uniqDeps).filter((e) => !(e.kind === "nested" && localNestedTypeUrls.has(e.url))).sort((a, b) => a.url.localeCompare(b.url));
   return result.length > 0 ? result : void 0;
 }
-function transformFhirSchemaResource(register, fhirSchema) {
+function transformFhirSchemaResource(register, fhirSchema, logger2) {
   const identifier = mkIdentifier(fhirSchema);
   let base;
   if (fhirSchema.base && fhirSchema.type !== "Element") {
@@ -2225,8 +2225,8 @@ function transformFhirSchemaResource(register, fhirSchema) {
     }
     base = mkIdentifier(baseFs);
   }
-  const fields = mkFields(register, fhirSchema, [], fhirSchema.elements);
-  const nested = mkNestedTypes(register, fhirSchema);
+  const fields = mkFields(register, fhirSchema, [], fhirSchema.elements, logger2);
+  const nested = mkNestedTypes(register, fhirSchema, logger2);
   const dependencies = extractDependencies(identifier, base, fields, nested);
   const typeSchema = {
     identifier,
@@ -2236,27 +2236,27 @@ function transformFhirSchemaResource(register, fhirSchema) {
     description: fhirSchema.description,
     dependencies
   };
-  const bindingSchemas = collectBindingSchemas(register, fhirSchema);
+  const bindingSchemas = collectBindingSchemas(register, fhirSchema, logger2);
   return [typeSchema, ...bindingSchemas];
 }
-async function transformFhirSchema(register, fhirSchema) {
+async function transformFhirSchema(register, fhirSchema, logger2) {
   const results = [];
   const identifier = mkIdentifier(fhirSchema);
   if (identifier.kind === "profile") {
-    const profileSchema = await transformProfile(register, fhirSchema);
+    const profileSchema = await transformProfile(register, fhirSchema, logger2);
     results.push(profileSchema);
-    const bindingSchemas = collectBindingSchemas(register, fhirSchema);
+    const bindingSchemas = collectBindingSchemas(register, fhirSchema, logger2);
     results.push(...bindingSchemas);
     return results;
   }
   if (isExtensionSchema(fhirSchema)) {
-    const extensionSchema = await transformExtension(fhirSchema, register, fhirSchema.package_meta);
+    const extensionSchema = await transformExtension(fhirSchema, register, logger2);
     if (extensionSchema) {
       results.push(extensionSchema);
     }
     return results;
   }
-  return transformFhirSchemaResource(register, fhirSchema);
+  return transformFhirSchemaResource(register, fhirSchema, logger2);
 }
 var TypeSchemaCache = class {
   cache = /* @__PURE__ */ new Map();
@@ -2476,8 +2476,227 @@ var TypeSchemaCache = class {
     }
   }
 };
+
+// src/logger.ts
+var LogLevel = /* @__PURE__ */ ((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";
+  return LogLevel2;
+})(LogLevel || {});
+var ConsoleOutput = class {
+  constructor(useStderr = false) {
+    this.useStderr = useStderr;
+  }
+  write(entry, formatted) {
+    const output = this.useStderr || entry.level >= 2 /* WARN */ ? console.error : console.log;
+    output(formatted);
+  }
+};
+var Logger = class _Logger {
+  config;
+  constructor(config = {}) {
+    this.config = {
+      level: 1 /* INFO */,
+      format: "pretty",
+      includeTimestamp: true,
+      includeContext: true,
+      colorize: true,
+      outputs: [new ConsoleOutput()],
+      ...config
+    };
+  }
+  /**
+   * Update logger configuration
+   */
+  configure(config) {
+    this.config = { ...this.config, ...config };
+  }
+  /**
+   * Check if a log level should be output
+   */
+  shouldLog(level) {
+    return level >= this.config.level;
+  }
+  /**
+   * Create a log entry
+   */
+  createEntry(level, message, context, error, operation) {
+    const entry = {
+      timestamp: (/* @__PURE__ */ 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
+      };
+    }
+    return entry;
+  }
+  /**
+   * Format log entry for output
+   */
+  formatEntry(entry) {
+    switch (this.config.format) {
+      case "json":
+        return JSON.stringify(entry);
+      case "compact":
+        return this.formatCompact(entry);
+      default:
+        return this.formatPretty(entry);
+    }
+  }
+  /**
+   * Format entry in compact format
+   */
+  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}`;
+  }
+  /**
+   * Format entry in pretty format
+   */
+  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("\n").join("\n  ")}`;
+    }
+    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("\n").join("\n  ")}`;
+      }
+      if (entry.error.suggestions && entry.error.suggestions.length > 0) {
+        formatted += `
+  Suggestions:
+${entry.error.suggestions.map((s) => `    \u2022 ${s}`).join("\n")}`;
+      }
+      if (entry.level === 0 /* DEBUG */ && entry.error.stack) {
+        formatted += `
+  Stack: ${entry.error.stack.split("\n").join("\n  ")}`;
+      }
+    }
+    return formatted;
+  }
+  /**
+   * Colorize log level if enabled
+   */
+  colorizeLevel(levelName, level) {
+    if (!this.config.colorize) {
+      return levelName;
+    }
+    const colors = {
+      [0 /* DEBUG */]: "\x1B[36m",
+      // Cyan
+      [1 /* INFO */]: "\x1B[32m",
+      // Green
+      [2 /* WARN */]: "\x1B[33m",
+      // Yellow
+      [3 /* ERROR */]: "\x1B[31m"
+      // Red
+    };
+    const reset = "\x1B[0m";
+    const color = colors[level] || "";
+    return `${color}${levelName}${reset}`;
+  }
+  /**
+   * Write log entry to all outputs
+   */
+  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);
+      }
+    }
+  }
+  /**
+   * Log debug message
+   */
+  async debug(message, context, operation) {
+    const entry = this.createEntry(0 /* DEBUG */, message, context, void 0, operation);
+    await this.writeEntry(entry);
+  }
+  /**
+   * Log info message
+   */
+  async info(message, context, operation) {
+    const entry = this.createEntry(1 /* INFO */, message, context, void 0, operation);
+    await this.writeEntry(entry);
+  }
+  /**
+   * Log warning message
+   */
+  async warn(message, context, operation) {
+    const entry = this.createEntry(2 /* WARN */, message, context, void 0, operation);
+    await this.writeEntry(entry);
+  }
+  /**
+   * Log error message
+   */
+  async error(message, error, context, operation) {
+    const entry = this.createEntry(3 /* ERROR */, message, context, error, operation);
+    await this.writeEntry(entry);
+  }
+  /**
+   * Create a child logger with additional context
+   */
+  child(component, context) {
+    const childLogger = new _Logger({
+      ...this.config,
+      component: this.config.component ? `${this.config.component}.${component}` : component
+    });
+    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;
+  }
+};
+new Logger();
+
+// src/utils/codegen-logger.ts
 var CodegenLogger = class _CodegenLogger {
   options;
+  dryWarnSet = /* @__PURE__ */ new Set();
   constructor(options = {}) {
     this.options = {
       timestamp: false,
@@ -2485,22 +2704,39 @@ var CodegenLogger = class _CodegenLogger {
       ...options
     };
   }
+  static consoleLevelsMap = {
+    [1 /* INFO */]: console.log,
+    [2 /* WARN */]: console.warn,
+    [3 /* ERROR */]: console.error,
+    [0 /* DEBUG */]: console.log,
+    [4 /* SILENT */]: () => {
+    }
+  };
   formatMessage(level, message, color) {
     const timestamp = this.options.timestamp ? `${pc.gray((/* @__PURE__ */ new Date()).toLocaleTimeString())} ` : "";
     const prefix = this.options.prefix ? `${pc.cyan(`[${this.options.prefix}]`)} ` : "";
     return `${timestamp}${color(level)} ${prefix}${message}`;
   }
+  isSuppressed(level) {
+    return this.options.suppressLoggingLevel === "all" || this.options.suppressLoggingLevel?.includes(level) || false;
+  }
+  tryWriteToConsole(level, formattedMessage) {
+    if (this.isSuppressed(level)) return;
+    const logFn = _CodegenLogger.consoleLevelsMap[level] || console.log;
+    logFn(formattedMessage);
+  }
   /**
    * Success message with checkmark
    */
   success(message) {
-    console.log(this.formatMessage("\u2705", message, pc.green));
+    this.tryWriteToConsole(1 /* INFO */, this.formatMessage("", message, pc.green));
   }
   /**
    * Error message with X mark
    */
   error(message, error) {
-    console.error(this.formatMessage("\u274C", message, pc.red));
+    if (this.isSuppressed(3 /* ERROR */)) return;
+    console.error(this.formatMessage("", message, pc.red));
     if (error && this.options.verbose) {
       console.error(pc.red(`   ${error.message}`));
       if (error.stack) {
@@ -2512,33 +2748,39 @@ var CodegenLogger = class _CodegenLogger {
    * Warning message with warning sign
    */
   warn(message) {
-    console.warn(this.formatMessage("\u26A0\uFE0F", message, pc.yellow));
+    this.tryWriteToConsole(2 /* WARN */, this.formatMessage("!", message, pc.yellow));
+  }
+  dry_warn(message) {
+    if (!this.dryWarnSet.has(message)) {
+      this.warn(message);
+      this.dryWarnSet.add(message);
+    }
   }
   /**
    * Info message with info icon
    */
   info(message) {
-    console.log(this.formatMessage("\u2139\uFE0F", message, pc.blue));
+    this.tryWriteToConsole(1 /* INFO */, this.formatMessage("i", message, pc.blue));
   }
   /**
    * Debug message (only shows in verbose mode)
    */
   debug(message) {
     if (this.options.verbose) {
-      console.log(this.formatMessage("\u{1F41B}", message, pc.magenta));
+      this.tryWriteToConsole(0 /* DEBUG */, this.formatMessage("\u{1F41B}", message, pc.magenta));
     }
   }
   /**
    * Step message with rocket
    */
   step(message) {
-    console.log(this.formatMessage("\u{1F680}", message, pc.cyan));
+    this.tryWriteToConsole(1 /* INFO */, this.formatMessage("\u{1F680}", message, pc.cyan));
   }
   /**
    * Progress message with clock
    */
   progress(message) {
-    console.log(this.formatMessage("\u23F3", message, pc.blue));
+    this.tryWriteToConsole(1 /* INFO */, this.formatMessage("\u23F3", message, pc.blue));
   }
   /**
    * Plain message (no icon, just colored text)
@@ -2546,7 +2788,7 @@ var CodegenLogger = class _CodegenLogger {
   plain(message, color = (s) => s) {
     const timestamp = this.options.timestamp ? `${pc.gray((/* @__PURE__ */ new Date()).toLocaleTimeString())} ` : "";
     const prefix = this.options.prefix ? `${pc.cyan(`[${this.options.prefix}]`)} ` : "";
-    console.log(`${timestamp}${prefix}${color(message)}`);
+    this.tryWriteToConsole(1 /* INFO */, `${timestamp}${prefix}${color(message)}`);
   }
   /**
    * Dimmed/gray text for less important info
@@ -2599,12 +2841,12 @@ var TypeSchemaGenerator = class {
   }
   async registerFromPackageMetas(packageMetas) {
     const packageNames = packageMetas.map((meta) => `${meta.name}${meta.version}`);
-    this.logger.step(`Loading FHIR packages: ${packageNames.join(", ")}`);
+    this.logger?.step(`Loading FHIR packages: ${packageNames.join(", ")}`);
     await this.manager.init();
     return registerFromManager(this.manager);
   }
   generateFhirSchemas(structureDefinitions) {
-    this.logger.progress(`Converting ${structureDefinitions.length} StructureDefinitions to FHIRSchemas`);
+    this.logger?.progress(`Converting ${structureDefinitions.length} StructureDefinitions to FHIRSchemas`);
     const filteredStructureDefinitions = this.applyStructureDefinitionTreeshaking(structureDefinitions);
     const fhirSchemas = [];
     let convertedCount = 0;
@@ -2614,56 +2856,56 @@ var TypeSchemaGenerator = class {
         const fhirSchema = fhirschema.translate(sd);
         fhirSchemas.push(fhirSchema);
         convertedCount++;
-        this.logger.debug(`Converted StructureDefinition: ${sd.name || sd.id} (${sd.resourceType})`);
+        this.logger?.debug(`Converted StructureDefinition: ${sd.name || sd.id} (${sd.resourceType})`);
       } catch (error) {
         failedCount++;
-        this.logger.warn(
+        this.logger?.warn(
           `Failed to convert StructureDefinition ${sd.name || sd.id}: ${error instanceof Error ? error.message : String(error)}`
         );
       }
     }
-    this.logger.success(
+    this.logger?.success(
       `FHIR Schema conversion completed: ${convertedCount}/${filteredStructureDefinitions.length} successful, ${failedCount} failed`
     );
     return fhirSchemas;
   }
-  async generateValueSetSchemas(valueSets) {
+  async generateValueSetSchemas(valueSets, logger2) {
     if (valueSets.length > 0) {
-      this.logger.debug(`${valueSets.length} ValueSets available for enum extraction`);
+      this.logger?.debug(`${valueSets.length} ValueSets available for enum extraction`);
     }
-    const register = await registerFromManager(this.manager);
+    const register = await registerFromManager(this.manager, logger2);
     const valueSetSchemas = [];
     if (valueSets.length > 0) {
-      this.logger.progress(`Converting ${valueSets.length} ValueSets to TypeSchema`);
+      this.logger?.progress(`Converting ${valueSets.length} ValueSets to TypeSchema`);
       let valueSetConvertedCount = 0;
       let valueSetFailedCount = 0;
       for (const vs of valueSets) {
         try {
-          const valueSetSchema = await transformValueSet(register, vs);
+          const valueSetSchema = await transformValueSet(register, vs, logger2);
           if (valueSetSchema) {
             valueSetSchemas.push(valueSetSchema);
             valueSetConvertedCount++;
-            this.logger.debug(`Converted ValueSet: ${vs.name || vs.id}`);
+            this.logger?.debug(`Converted ValueSet: ${vs.name || vs.id}`);
           }
         } catch (error) {
           valueSetFailedCount++;
-          this.logger.warn(
+          this.logger?.warn(
             `Failed to convert ValueSet ${vs.name || vs.id}: ${error instanceof Error ? error.message : String(error)}`
           );
         }
       }
-      this.logger.success(
+      this.logger?.success(
         `ValueSet conversion completed: ${valueSetConvertedCount}/${valueSets.length} successful, ${valueSetFailedCount} failed`
       );
     }
     return valueSetSchemas;
   }
-  async generateFromPackage(packageName, packageVersion) {
+  async generateFromPackage(packageName, packageVersion, logger2) {
     await this.initializeCache();
     if (this.cache && !(this.cacheConfig?.forceRegenerate ?? false)) {
       const cachedSchemas = this.cache.getByPackage(packageName);
       if (cachedSchemas.length > 0) {
-        this.logger.info(
+        this.logger?.info(
           `Using cached TypeSchemas for package: ${packageName} (${cachedSchemas.length} schemas)`
         );
         return cachedSchemas;
@@ -2674,10 +2916,9 @@ var TypeSchemaGenerator = class {
       version: packageVersion || "latest"
     };
     const register = await this.registerFromPackageMetas([packageInfo]);
-    const valueSets = await this.generateValueSetSchemas(register.allVs());
-    const fhirSchemas = (await Promise.all(register.allFs().map(async (fs2) => await transformFhirSchema(register, fs2)))).flat();
+    const valueSets = await this.generateValueSetSchemas(register.allVs(), logger2);
+    const fhirSchemas = (await Promise.all(register.allFs().map(async (fs2) => await transformFhirSchema(register, fs2, logger2)))).flat();
     const allSchemas = [...fhirSchemas, ...valueSets];
-    console.debug(111);
     if (this.cache) {
       for (const schema of allSchemas) {
         await this.cache.set(schema);
@@ -2694,7 +2935,7 @@ var TypeSchemaGenerator = class {
     if (!treeshakeList || treeshakeList.length === 0) {
       return structureDefinitions;
     }
-    this.logger.info(`Applying treeshaking filter for ResourceTypes: ${treeshakeList.join(", ")}`);
+    this.logger?.info(`Applying treeshaking filter for ResourceTypes: ${treeshakeList.join(", ")}`);
     const allStructureDefinitions = /* @__PURE__ */ new Map();
     const realDependencies = /* @__PURE__ */ new Map();
     const referenceTargets = /* @__PURE__ */ new Map();
@@ -2718,7 +2959,7 @@ var TypeSchemaGenerator = class {
       if (allStructureDefinitions.has(resourceType)) {
         structureDefinitionsToKeep.add(resourceType);
       } else {
-        this.logger.warn(`ResourceType '${resourceType}' not found in structure definitions`);
+        this.logger?.warn(`ResourceType '${resourceType}' not found in structure definitions`);
       }
     }
     const addRealDependenciesRecursively = (name, visited = /* @__PURE__ */ new Set()) => {
@@ -2754,9 +2995,9 @@ var TypeSchemaGenerator = class {
       }
     }
     if (excludedReferenceTargets.size > 0) {
-      this.logger.info(`Excluded reference-only targets: ${Array.from(excludedReferenceTargets).join(", ")}`);
+      this.logger?.info(`Excluded reference-only targets: ${Array.from(excludedReferenceTargets).join(", ")}`);
     }
-    this.logger.success(
+    this.logger?.success(
       `Treeshaking completed: kept ${filteredStructureDefinitions.length}/${structureDefinitions.length} structure definitions`
     );
     return filteredStructureDefinitions;
@@ -3045,10 +3286,10 @@ var TypeSchemaParser = class {
 };
 
 // src/typeschema/index.ts
-var generateTypeSchemas = async (register) => {
+var generateTypeSchemas = async (register, logger2) => {
   const fhirSchemas = [];
   for (const fhirSchema of register.allFs()) {
-    fhirSchemas.push(...await transformFhirSchema(register, fhirSchema));
+    fhirSchemas.push(...await transformFhirSchema(register, fhirSchema, logger2));
   }
   for (const vsSchema of register.allVs()) {
     fhirSchemas.push(await transformValueSet(register, vsSchema));
@@ -3106,45 +3347,45 @@ var ErrorHandler = class {
   handleUnknownError(error, context) {
     this.options.logger.error("Unexpected error occurred:", error);
     if (this.options.verbose) {
-      console.error("\n\u{1F6A8} Unexpected Error Details:");
-      console.error(`   Type: ${error.constructor.name}`);
-      console.error(`   Message: ${error.message}`);
+      this.options.logger.error("\n\u{1F6A8} Unexpected Error Details:");
+      this.options.logger.error(`   Type: ${error.constructor.name}`);
+      this.options.logger.error(`   Message: ${error.message}`);
       if (error.stack) {
-        console.error(`   Stack: ${error.stack}`);
+        this.options.logger.error(`   Stack: ${error.stack}`);
       }
       if (context?.schema) {
-        console.error(`   Schema: ${context.schema.identifier.name}`);
+        this.options.logger.error(`   Schema: ${context.schema.identifier.name}`);
       }
       if (context?.filename) {
-        console.error(`   File: ${context.filename}`);
+        this.options.logger.error(`   File: ${context.filename}`);
       }
     }
-    console.error("\n\u{1F4A1} General troubleshooting suggestions:");
-    console.error("   \u2022 Run with --verbose flag for more details");
-    console.error("   \u2022 Check your input files for corruption");
-    console.error("   \u2022 Update to the latest version of atomic-codegen");
-    console.error("   \u2022 Report this issue at: https://github.com/atomic-ehr/codegen/issues");
+    this.options.logger.error("\n\u{1F4A1} General troubleshooting suggestions:");
+    this.options.logger.error("   \u2022 Run with --verbose flag for more details");
+    this.options.logger.error("   \u2022 Check your input files for corruption");
+    this.options.logger.error("   \u2022 Update to the latest version of atomic-codegen");
+    this.options.logger.error("   \u2022 Report this issue at: https://github.com/atomic-ehr/codegen/issues");
   }
   /**
    * Report error to console with formatting
    */
   reportErrorToConsole(error) {
     if ("getFormattedMessage" in error) {
-      console.error(error.getFormattedMessage());
+      this.options.logger.error(error.getFormattedMessage());
     } else {
-      console.error(`
+      this.options.logger.error(`
 \u274C ${error.constructor.name}: ${error.message}`);
       const suggestions = error.getSuggestions();
       if (suggestions.length > 0) {
-        console.error("\n\u{1F4A1} Suggestions:");
+        this.options.logger.error("\n\u{1F4A1} Suggestions:");
         suggestions.forEach((suggestion) => {
-          console.error(`   \u2022 ${suggestion}`);
+          this.options.logger.error(`   \u2022 ${suggestion}`);
         });
       }
     }
     if (this.options.verbose && error.context) {
-      console.error("\n\u{1F50D} Debug Information:");
-      console.error(JSON.stringify(error.context, null, 2));
+      this.options.logger.error("\n\u{1F50D} Debug Information:");
+      this.options.logger.error(JSON.stringify(error.context, null, 2));
     }
   }
   /**
@@ -3159,7 +3400,7 @@ var ErrorHandler = class {
       suggestions: error.getSuggestions(),
       timestamp: (/* @__PURE__ */ new Date()).toISOString()
     };
-    console.error(JSON.stringify(errorData, null, 2));
+    this.options.logger.error(JSON.stringify(errorData, null, 2));
   }
   /**
    * Report error in structured format
@@ -3175,16 +3416,16 @@ var ErrorHandler = class {
       suggestions: error.getSuggestions(),
       actions: this.getRecoveryActions(error)
     };
-    console.error("---");
-    console.error("Error Report:");
-    console.error(JSON.stringify(structure, null, 2));
-    console.error("---");
+    this.options.logger.error("---");
+    this.options.logger.error("Error Report:");
+    this.options.logger.error(JSON.stringify(structure, null, 2));
+    this.options.logger.error("---");
   }
   /**
    * Report multiple errors efficiently
    */
   reportBatchErrors(errors) {
-    console.error(`
+    this.options.logger.error(`
 \u274C ${errors.length} errors occurred during generation:`);
     const errorGroups = /* @__PURE__ */ new Map();
     errors.forEach((error) => {
@@ -3195,19 +3436,19 @@ var ErrorHandler = class {
       errorGroups.get(type)?.push(error);
     });
     for (const [type, groupErrors] of errorGroups) {
-      console.error(`
+      this.options.logger.error(`
 \u{1F4CB} ${type} (${groupErrors.length} occurrences):`);
       groupErrors.forEach((error, index) => {
-        console.error(`   ${index + 1}. ${error.message}`);
+        this.options.logger.error(`   ${index + 1}. ${error.message}`);
         if (error.context?.schemaName) {
-          console.error(`      Schema: ${error.context.schemaName}`);
+          this.options.logger.error(`      Schema: ${error.context.schemaName}`);
         }
       });
       const commonSuggestions = this.getCommonSuggestions(groupErrors);
       if (commonSuggestions.length > 0) {
-        console.error("\n   \u{1F4A1} Common suggestions:");
+        this.options.logger.error("\n   \u{1F4A1} Common suggestions:");
         commonSuggestions.forEach((suggestion) => {
-          console.error(`      \u2022 ${suggestion}`);
+          this.options.logger.error(`      \u2022 ${suggestion}`);
         });
       }
     }
@@ -3517,7 +3758,7 @@ var BaseGenerator = class {
       logger: this.logger,
       verbose: this.options.verbose || false,
       beginnerMode: this.options.beginnerMode || false,
-      outputFormat: this.options.errorFormat || "console"
+      outputFormat: "this.options.logger"
     });
     this.errorBoundary = new GeneratorErrorBoundary(this.errorHandler);
     this.logger.debug(`${this.getLanguageName()} generator initialized`);
@@ -5094,6 +5335,13 @@ var capitalCase = (s) => {
 var pascalCase = (s) => {
   return words(s).map(capitalCase).join("");
 };
+var uppercaseFirstLetter = (str) => {
+  if (!str || str.length === 0) return str;
+  return str.charAt(0).toUpperCase() + str.slice(1);
+};
+var uppercaseFirstLetterOfEach = (strings) => {
+  return strings.map((str) => uppercaseFirstLetter(str));
+};
 var FileSystemWriter = class {
   opts;
   currentDir;
@@ -5119,7 +5367,7 @@ var FileSystemWriter = class {
     if (fn.includes("/")) throw new Error(`Change file path separatly: ${fn}`);
     const fullFn = `${this.currentDir}/${fn}`;
     try {
-      this.currentFileDescriptor = fs.openSync(fn, "w");
+      this.currentFileDescriptor = fs.openSync(fullFn, "w");
       this.writtenFilesSet.add(fn);
       this.logger()?.debug(`cat > '${fullFn}'`);
       gen();
@@ -5180,6 +5428,17 @@ var Writer = class extends FileSystemWriter {
       this.comment(...tokens);
     }
   }
+  disclaimer() {
+    return [
+      "WARNING: This file is autogenerated by FHIR Schema Codegen.",
+      "https://github.com/fhir-schema/fhir-schema-codegen",
+      "Any manual changes made to this file may be overwritten."
+    ];
+  }
+  generateDisclaimer() {
+    this.disclaimer().forEach((e) => this.comment(e));
+    this.line();
+  }
   curlyBlock(tokens, gencontent, endTokens) {
     this.line(`${tokens.filter(Boolean).join(" ")} {`);
     this.indent();
@@ -5196,9 +5455,7 @@ var Writer = class extends FileSystemWriter {
   }
 };
 
-// src/api/writer-generator/typescript.ts
-var collectComplexTypes = (tss) => tss.filter((t) => t.identifier.kind === "complex-type");
-var collectResources = (tss) => tss.filter((t) => t.identifier.kind === "resource");
+// src/typeschema/utils.ts
 var groupByPackages = (typeSchemas) => {
   const grouped = {};
   for (const ts of typeSchemas) {
@@ -5213,9 +5470,85 @@ var groupByPackages = (typeSchemas) => {
   }
   return grouped;
 };
-var fileNameStem = (id) => {
+var collectComplexTypes = (tss) => tss.filter((t) => t.identifier.kind === "complex-type");
+var collectResources = (tss) => tss.filter((t) => t.identifier.kind === "resource");
+var notChoiceDeclaration = (field) => {
+  if (field.choices) return void 0;
+  if (field.choiceOf) return field;
+  return field;
+};
+var resourceRelatives = (schemas) => {
+  const regularSchemas = collectResources(schemas);
+  const directPairs = [];
+  for (const schema of regularSchemas) {
+    if (schema.base) {
+      directPairs.push({ parent: schema.base, child: schema.identifier });
+    }
+  }
+  const allPairs = [...directPairs];
+  const findTransitiveRelatives = (parentRef) => {
+    const directChildren = directPairs.filter((pair) => pair.parent.name === parentRef.name).map((pair) => pair.child);
+    const transitiveChildren = [];
+    for (const child of directChildren) {
+      transitiveChildren.push(...findTransitiveRelatives(child));
+    }
+    return [...directChildren, ...transitiveChildren];
+  };
+  for (const pair of directPairs) {
+    const transitiveChildren = findTransitiveRelatives(pair.child);
+    for (const transitiveChild of transitiveChildren) {
+      if (!directPairs.some((dp) => dp.parent.name === pair.parent.name && dp.child.name === transitiveChild.name)) {
+        allPairs.push({ parent: pair.parent, child: transitiveChild });
+      }
+    }
+  }
+  return allPairs;
+};
+var resourceChildren = (relatives, id) => {
+  return relatives.filter((relative2) => relative2.parent.name === id.name).map((relative2) => relative2.child);
+};
+
+// src/api/writer-generator/typescript.ts
+var primitiveType2tsType = {
+  boolean: "boolean",
+  instant: "string",
+  time: "string",
+  date: "string",
+  dateTime: "string",
+  decimal: "number",
+  integer: "number",
+  unsignedInt: "number",
+  positiveInt: "number",
+  integer64: "number",
+  base64Binary: "string",
+  uri: "string",
+  url: "string",
+  canonical: "string",
+  oid: "string",
+  uuid: "string",
+  string: "string",
+  code: "string",
+  markdown: "string",
+  id: "string",
+  xhtml: "string"
+};
+var canonicalToName = (canonical, dropFragment = true) => {
+  if (!canonical) return void 0;
+  let localName = canonical.split("/").pop();
+  if (dropFragment && localName?.includes("#")) {
+    localName = localName.split("#")[0];
+  }
+  if (/^\d/.test(localName ?? "")) {
+    localName = `number_${localName}`;
+  }
+  return localName?.replace(/[- ]/g, "_");
+};
+var tsBaseFileName = (id) => {
   return pascalCase(id.name);
 };
+var tsFileName = (id) => {
+  return `${tsBaseFileName(id)}.ts`;
+};
 var normalizeName = (n) => {
   if (n === "extends") {
     return "extends_";
@@ -5225,43 +5558,155 @@ var normalizeName = (n) => {
 var resourceName = (id) => {
   return normalizeName(id.name);
 };
+var deriveNestedSchemaName = (url) => {
+  const path = canonicalToName(url, false);
+  if (!path) {
+    return "";
+  }
+  const [resourceName2, fragment] = path.split("#");
+  const name = uppercaseFirstLetterOfEach((fragment ?? "").split(".")).join("");
+  return [resourceName2, name].join("");
+};
 var TypeScript = class extends Writer {
-  tsImportFrom(tsPackage, ...entities) {
-    this.lineSM(`import { ${entities.join(", ")} } from '${tsPackage}'`);
+  resourceRelatives = [];
+  tsImport(tsPackageName, ...entities) {
+    this.lineSM(`import { ${entities.join(", ")} } from '${tsPackageName}'`);
   }
-  generatePackageIndexFile(schemas) {
+  generateFhirPackageIndexFile(schemas) {
     this.cat("index.ts", () => {
       let exports = schemas.map((schema) => ({
         identifier: schema.identifier,
-        fileName: fileNameStem(schema.identifier),
-        name: resourceName(schema.identifier)
-      })).sort((a, b) => a.name.localeCompare(b.name));
-      exports = Array.from(new Map(exports.map((exp) => [exp.name.toLowerCase(), exp])).values()).sort(
-        (a, b) => a.name.localeCompare(b.name)
+        tsPackageName: tsBaseFileName(schema.identifier),
+        resourceName: resourceName(schema.identifier)
+      })).sort((a, b) => a.resourceName.localeCompare(b.resourceName));
+      exports = Array.from(new Map(exports.map((exp) => [exp.resourceName.toLowerCase(), exp])).values()).sort(
+        (a, b) => a.resourceName.localeCompare(b.resourceName)
       );
       for (const exp of exports) {
         this.debugComment(exp.identifier);
-        this.tsImportFrom(`./${exp.fileName}`, exp.name);
+        this.tsImport(`./${exp.tsPackageName}`, exp.resourceName);
       }
-      this.lineSM(`export { ${exports.map((e) => e.name).join(", ")} }`);
+      this.lineSM(`export { ${exports.map((e) => e.resourceName).join(", ")} }`);
       this.line("");
       this.curlyBlock(["export type ResourceTypeMap = "], () => {
         this.lineSM("User: Record<string, any>");
         exports.forEach((exp) => {
           this.debugComment(exp.identifier);
-          this.lineSM(`${exp.name}: ${exp.name}`);
+          this.lineSM(`${exp.resourceName}: ${exp.resourceName}`);
         });
       });
       this.lineSM("export type ResourceType = keyof ResourceTypeMap");
       this.squareBlock(["export const resourceList: readonly ResourceType[] = "], () => {
         exports.forEach((exp) => {
           this.debugComment(exp.identifier);
-          this.line(`'${exp.name}', `);
+          this.line(`'${exp.resourceName}', `);
         });
       });
     });
   }
+  generateDependenciesImports(schema) {
+    if (schema.dependencies) {
+      const deps = [
+        ...schema.dependencies.filter((dep) => ["complex-type", "resource", "logical"].includes(dep.kind)).map((dep) => ({
+          tsPackage: `../${kebabCase(dep.package)}/${pascalCase(dep.name)}`,
+          name: uppercaseFirstLetter(dep.name)
+        })),
+        ...schema.dependencies.filter((dep) => ["nested"].includes(dep.kind)).map((dep) => ({
+          tsPackage: `../${kebabCase(dep.package)}/${pascalCase(canonicalToName(dep.url) ?? "")}`,
+          name: deriveNestedSchemaName(dep.url)
+        }))
+      ].sort((a, b) => a.name.localeCompare(b.name));
+      for (const dep of deps) {
+        this.tsImport(dep.tsPackage, dep.name);
+      }
+    }
+  }
+  addFieldExtension(fieldName, field) {
+    if (field.type.kind === "primitive-type") {
+      this.lineSM(`_${normalizeName(fieldName)}?: Element`);
+    }
+  }
+  generateType(schema) {
+    var name;
+    if (schema.identifier.name === "Reference") {
+      name = "Reference<T extends string = string>";
+    } else if (schema.identifier.kind === "nested") {
+      name = normalizeName(deriveNestedSchemaName(schema.identifier.url));
+    } else {
+      name = normalizeName(schema.identifier.name);
+    }
+    const parent = canonicalToName(schema.base?.url);
+    const extendsClause = parent && `extends ${parent}`;
+    this.debugComment(schema.identifier);
+    this.curlyBlock(["export", "interface", name, extendsClause], () => {
+      if (!schema.fields) {
+        return;
+      }
+      if (schema.identifier.kind === "resource") {
+        const possibleResourceTypes = [schema.identifier];
+        possibleResourceTypes.push(...resourceChildren(this.resourceRelatives, schema.identifier));
+        this.lineSM(`resourceType: ${possibleResourceTypes.map((e) => `'${e.name}'`).join(" | ")}`);
+        this.line();
+      }
+      const fields = Object.entries(schema.fields).sort((a, b) => a[0].localeCompare(b[0]));
+      for (const [fieldName, anyField] of fields) {
+        const field = notChoiceDeclaration(anyField);
+        if (field === void 0) continue;
+        this.debugComment(fieldName, ":", field);
+        const fieldNameFixed = normalizeName(fieldName);
+        const optionalSymbol = field.required ? "" : "?";
+        const arraySymbol = field.array ? "[]" : "";
+        if (field.type === void 0) {
+          continue;
+        }
+        let type = field.type.name;
+        if (field.type.kind === "nested") {
+          type = deriveNestedSchemaName(field.type.url);
+        }
+        if (field.type.kind === "primitive-type") {
+          type = primitiveType2tsType[field.type.name] ?? "string";
+        }
+        if (schema.identifier.name === "Reference" && fieldNameFixed === "reference") {
+          type = "`${T}/${string}`";
+        }
+        if (field.reference?.length) {
+          const references = field.reference.map((ref) => `'${ref.name}'`).join(" | ");
+          type = `Reference<${references}>`;
+        }
+        if (field.enum) {
+          type = field.enum.map((e) => `'${e}'`).join(" | ");
+        }
+        this.lineSM(`${fieldNameFixed}${optionalSymbol}:`, `${type}${arraySymbol}`);
+        if (["resource", "complex-type"].includes(schema.identifier.kind)) {
+          this.addFieldExtension(fieldName, field);
+        }
+      }
+    });
+    this.line();
+  }
+  generateNestedTypes(schema) {
+    if (schema.nested) {
+      this.line();
+      for (const subtype of schema.nested) {
+        this.generateType(subtype);
+      }
+    }
+  }
+  generateResourceModule(schema) {
+    this.cat(`${tsFileName(schema.identifier)}`, () => {
+      this.generateDisclaimer();
+      if (["complex-type", "resource", "logical", "nested"].includes(schema.identifier.kind)) {
+        this.generateDependenciesImports(schema);
+        this.line();
+        this.generateNestedTypes(schema);
+        this.generateType(schema);
+      } else {
+        throw new Error(`Profile generation not implemented for kind: ${schema.identifier.kind}`);
+      }
+    });
+  }
   generate(schemas) {
+    this.resourceRelatives = resourceRelatives(schemas);
     const typesToGenerate = [
       ...collectComplexTypes(schemas),
       ...collectResources(schemas)
@@ -5273,7 +5718,10 @@ var TypeScript = class extends Writer {
       for (const [packageName, packageSchemas] of Object.entries(grouped)) {
         const tsPackageName = kebabCase(packageName);
         this.cd(tsPackageName, () => {
-          this.generatePackageIndexFile(packageSchemas);
+          for (const schema of packageSchemas) {
+            this.generateResourceModule(schema);
+          }
+          this.generateFhirPackageIndexFile(packageSchemas);
         });
       }
     });
@@ -5383,7 +5831,7 @@ var APIBuilder = class {
     const writerOpts = {
       outputDir: Path2.join(this.options.outputDir, "/types"),
       tabSize: 2,
-      withDebugComment: true,
+      withDebugComment: false,
       commentLinePrefix: "//"
     };
     const effectiveOpts = { logger: this.logger, ...writerOpts, ...opts };
@@ -5440,7 +5888,7 @@ var APIBuilder = class {
       });
       await manager.init();
       const register = await registerFromManager(manager, this.logger);
-      const typeSchemas = await generateTypeSchemas(register);
+      const typeSchemas = await generateTypeSchemas(register, this.logger);
       this.logger.debug(`Executing ${this.generators.size} generators`);
       await this.executeGenerators(result, typeSchemas);
       this.logger.info("Generation completed successfully");