babelfhir-ts 1.0.28 → 1.0.29

package/out/generator/importManager.js

@@ -1,5 +1,6 @@
 import fhirInterfaceNames from "./fhirInterfaces.json" with { type: 'json' };
-import { sanitizeIdentifier } from './utils.js';
+import { sanitizeIdentifier, toPascalCase } from './utils.js';
+import { logger } from "../logger.js";
 /**
  * Manages TypeScript import statements for generated FHIR interfaces.
  * Handles three types of imports:
@@ -15,9 +16,17 @@ export class ImportManager {
     localInterfaceNames;
     existingProfiles;
     externalProfiles = new Map();
-    constructor(localInterfaceNames, existingProfiles) {
+    profileIdToName; // Map from profile ID to actual interface name
+    profileUrlToName; // Map from profile URL to actual interface name
+    constructor(localInterfaceNames, existingProfiles, profileIdToName, profileUrlToName) {
         this.localInterfaceNames = localInterfaceNames;
         this.existingProfiles = existingProfiles;
+        this.profileIdToName = profileIdToName;
+        this.profileUrlToName = profileUrlToName;
+        logger.log(`[ImportManager] Initialized with profileUrlToName entries: ${profileUrlToName?.size || 0}`);
+        if (profileUrlToName && profileUrlToName.size > 0) {
+            logger.log(`[ImportManager] Sample URLs in map:`, Array.from(profileUrlToName.entries()).slice(0, 3));
+        }
     }
     /**
      * Adds a type to the appropriate import category.
@@ -30,9 +39,13 @@ export class ImportManager {
     addType(typeName, profileUrl, baseType, isFhirBase = false) {
         if (!typeName)
             return;
+        // If we have a profile URL, check if we know the actual type name for it
+        if (profileUrl && this.profileUrlToName?.has(profileUrl)) {
+            const actualTypeName = this.profileUrlToName.get(profileUrl);
+            typeName = actualTypeName;
+        }
         // Check if it's a nested interface of the current profile (defined locally in this file)
         if (this.localInterfaceNames.has(typeName)) {
-            // Don't add to imports - defined in the same file
             return;
         }
         // Check if it's a known FHIR type from @types/fhir
@@ -40,17 +53,33 @@ export class ImportManager {
             this.fhirImports.add(typeName);
             return;
         }
+        // Normalize to PascalCase for consistency (all generated interfaces use PascalCase)
+        const normalizedTypeName = toPascalCase(sanitizeIdentifier(typeName));
         // Check if it exists in our generated profiles/types
         if (this.existingProfiles?.has(typeName)) {
-            this.customImports.add(typeName);
+            this.customImports.add(normalizedTypeName);
+            return;
+        }
+        else if (this.existingProfiles?.has(normalizedTypeName)) {
+            this.customImports.add(normalizedTypeName);
             return;
         }
         // Check if this is a primitive type that shouldn't be fetched
         if (this.isPrimitiveLikeType(typeName)) {
             return;
         }
-        // Add to custom imports (will be generated or fetched)
-        this.customImports.add(typeName);
+        // Check if we already have an external profile registered with this URL
+        // If so, use the existing name to avoid duplicates
+        if (profileUrl) {
+            for (const [existingName, existingMeta] of this.externalProfiles) {
+                if (existingMeta.profileUrl === profileUrl) {
+                    const existingNormalized = toPascalCase(sanitizeIdentifier(existingName));
+                    this.customImports.add(existingNormalized);
+                    return;
+                }
+            }
+        }
+        this.customImports.add(normalizedTypeName);
         // Track as external profile if we have profile metadata
         if (profileUrl || baseType) {
             this.registerExternalProfile(typeName, profileUrl, baseType, isFhirBase);
@@ -62,14 +91,25 @@ export class ImportManager {
     registerExternalProfile(rawTypeName, profileUrl, baseType, isFhirBase = false) {
         if (!rawTypeName)
             return;
-        const sanitizedTypeName = sanitizeIdentifier(rawTypeName);
+        // Normalize to PascalCase since that's what we use for interface names
+        const normalizedTypeName = toPascalCase(sanitizeIdentifier(rawTypeName));
         const resolvedProfileUrl = profileUrl && profileUrl.length > 0
             ? profileUrl
-            : `http://hl7.org/fhir/StructureDefinition/${sanitizedTypeName}`;
-        let meta = this.externalProfiles.get(sanitizedTypeName);
+            : `http://hl7.org/fhir/StructureDefinition/${normalizedTypeName}`;
+        // Check if we already have an external profile with the same URL
+        // If so, skip to avoid duplicate registrations
+        if (resolvedProfileUrl) {
+            for (const [existingName, existingMeta] of this.externalProfiles) {
+                if (existingMeta.profileUrl === resolvedProfileUrl) {
+                    logger.log(`[importManager.registerExternalProfile] SKIP duplicate URL: ${normalizedTypeName} -> ${resolvedProfileUrl} (already registered as ${existingName})`);
+                    return;
+                }
+            }
+        }
+        let meta = this.externalProfiles.get(normalizedTypeName);
         if (!meta) {
             meta = { profileUrl: resolvedProfileUrl, baseTypes: new Map() };
-            this.externalProfiles.set(sanitizedTypeName, meta);
+            this.externalProfiles.set(normalizedTypeName, meta);
         }
         else if (profileUrl && profileUrl.length > 0 &&
             meta.profileUrl.startsWith('http://hl7.org/fhir/StructureDefinition/')) {
@@ -109,10 +149,22 @@ export class ImportManager {
         for (const [typeName, relativePath] of sortedPathBasedImports) {
             statements.push(`import { ${typeName} } from "${relativePath}";`);
         }
-        // Custom local imports
+        // Custom local imports - deduplicate to avoid duplicate import lines
         const sortedCustomImports = Array.from(this.customImports).sort();
+        logger.log(`[ImportManager.generateImportStatements] customImports size: ${this.customImports.size}`);
+        logger.log(`[ImportManager.generateImportStatements] customImports contents:`, sortedCustomImports.slice(0, 20));
+        const seenTypes = new Set();
         for (const type of sortedCustomImports) {
-            statements.push(`import { ${type} } from "./${type}";`);
+            // Check if this type has been remapped (e.g., "Aufnahmegrund" -> "ExtensionAufnahmegrund")
+            const actualTypeName = this.profileIdToName?.get(type) || type;
+            // Skip if we've already added an import for this actual type name
+            if (seenTypes.has(actualTypeName)) {
+                logger.log(`[ImportManager.generateImportStatements] SKIPPING duplicate: ${type} -> ${actualTypeName}`);
+                continue;
+            }
+            logger.log(`[ImportManager.generateImportStatements] Adding import: ${type} -> ${actualTypeName}`);
+            statements.push(`import { ${actualTypeName} } from "./${actualTypeName}";`);
+            seenTypes.add(actualTypeName);
         }
         return statements.join('\n');
     }

package/out/generator/index.js

@@ -12,6 +12,30 @@ import { generateValueSetTypeScript, generateValueSetRegistry } from './valueSet
 import { logger } from '../logger.js';
 import fhirInterfaceNames from './fhirInterfaces.json' with { type: 'json' };
 import { spawn } from 'child_process';
+// Track failed fetches to provide helpful warnings
+let failedFetchCount = 0;
+const failedFetchProfiles = [];
+export function resetFetchFailureTracking() {
+    failedFetchCount = 0;
+    failedFetchProfiles.length = 0;
+}
+export function getFetchFailureCount() {
+    return failedFetchCount;
+}
+export function getFetchFailureWarning() {
+    if (failedFetchCount === 0)
+        return null;
+    const profileList = failedFetchProfiles.slice(0, 5).map(p => `  - ${p}`).join('\n');
+    const moreMessage = failedFetchProfiles.length > 5 ? `\n  ... and ${failedFetchProfiles.length - 5} more` : '';
+    return `\n⚠️  Warning: ${failedFetchCount} external profiles could not be fetched (timeout or network error):\n${profileList}${moreMessage}\n\n` +
+        `These profiles were generated as Element type aliases, which may cause TypeScript errors.\n` +
+        `This usually happens when external FHIR servers are slow or unavailable.\n\n` +
+        `Recommended actions:\n` +
+        `  1. Run the generation command again (cached profiles will be reused, only missing ones will be retried)\n` +
+        `  2. Check your internet connection\n` +
+        `  3. If the issue persists, the external server may be temporarily down\n\n` +
+        `Note: The .cache folder has been preserved to speed up the next generation attempt.\n`;
+}
 /** Ensure RandomSupport.ts exists in a generation output directory */
 function ensureRandomSupportFile(dir) {
     const filePath = path.join(dir, 'RandomSupport.ts');
@@ -50,7 +74,7 @@ export function skeletonQuantity(): Quantity { return { value: randomInt(1,100),
         }
         catch { /* ignore read errors, will rewrite */ }
         fs.writeFileSync(filePath, content, 'utf-8');
-        console.log(`Updated RandomSupport.ts in ${dir}`);
+        logger.log(`Updated RandomSupport.ts in ${dir}`);
     }
     else {
         fs.writeFileSync(filePath, content, 'utf-8');
@@ -178,9 +202,14 @@ async function generateIndexFile(dir) {
 }
 // Reusable processor for a single StructureDefinition
 async function processStructureDefinition(sd, ctx) {
-    const { outputDir, fhirSourceHint, valueSetCodesMap, valueSets, examplesMap, existingStructureDefinitions, profileIdToName, flags, fhirChildTypeMap } = ctx;
+    const { outputDir, fhirSourceHint, valueSetCodesMap, valueSets, examplesMap, existingStructureDefinitions, profileIdToName, profileUrlToName, flags, fhirChildTypeMap } = ctx;
     const rawInterfaceName = sd.name || sd.id || 'UnnamedInterface';
-    const interfaceName = toPascalCase(rawInterfaceName);
+    let interfaceName = toPascalCase(rawInterfaceName);
+    // Check if the interface name conflicts with a FHIR base type
+    if (fhirInterfaceNames.includes(interfaceName)) {
+        logger.log(`Interface name '${interfaceName}' conflicts with FHIR base type, adding 'Extension' suffix`);
+        interfaceName = `${interfaceName}Extension`;
+    }
     let baseResource = sanitizeIdentifier(getBaseResource(sd.baseDefinition));
     // Check if baseResource is a profile ID that maps to a generated interface name
     if (profileIdToName?.has(baseResource)) {
@@ -194,16 +223,22 @@ async function processStructureDefinition(sd, ctx) {
     const parsed = await parseStructureDefinition(sd, fhirSourceHint, valueSetCodesMap);
     if (!parsed.newFields.length) {
         logger.log(`No new SD fields for ${interfaceName}, skipping.`);
-        return;
+        return interfaceName;
     }
     const aligned = alignFields(parsed.newFields, parsed.oldFields);
-    const interfaceResult = generateInterfaces(interfaceName, aligned.alignedNewFields, baseResource, parsed.oldFields, valueSets, sd.type, existingStructureDefinitions, fhirChildTypeMap);
+    const interfaceResult = generateInterfaces(interfaceName, aligned.alignedNewFields, baseResource, parsed.oldFields, valueSets, sd.type, existingStructureDefinitions, fhirChildTypeMap, profileIdToName, profileUrlToName);
     const interfaceContent = interfaceResult.content;
+    // Debug: Log external profiles
+    if (interfaceResult.referencedExternalProfiles.size > 0) {
+        logger.log(`[index] External profiles for ${interfaceName}:`, Array.from(interfaceResult.referencedExternalProfiles.keys()));
+    }
     // Generate type alias files for external profiled identifiers that don't exist as StructureDefinitions
     for (const [typeName, profileInfo] of interfaceResult.referencedExternalProfiles) {
+        // Normalize to PascalCase since that's what we use for interface names
+        const normalizedTypeName = toPascalCase(sanitizeIdentifier(typeName));
         // Only emit an external alias if this interface actually imports/uses it as a local type
-        const isUsedHere = interfaceContent.includes(`import { ${typeName} } from "./${typeName}"`) ||
-            (interfaceContent.includes(`from "./${typeName}"`) && interfaceContent.includes(`{ ${typeName} }`));
+        const isUsedHere = interfaceContent.includes(`import { ${normalizedTypeName} } from "./${normalizedTypeName}"`) ||
+            (interfaceContent.includes(`from "./${normalizedTypeName}"`) && interfaceContent.includes(`{ ${normalizedTypeName} }`));
         if (!isUsedHere) {
             continue; // Skip unused external references for this interface
         }
@@ -214,7 +249,7 @@ async function processStructureDefinition(sd, ctx) {
         // Try to fetch the external StructureDefinition
         let externalSD = null;
         try {
-            console.log(`Attempting to fetch external profile: ${profileInfo.profileUrl}`);
+            logger.log(`Attempting to fetch external profile: ${profileInfo.profileUrl}`);
             externalSD = await fetchStructureDefinition(profileInfo.profileUrl);
         }
         catch (err) {
@@ -223,26 +258,68 @@ async function processStructureDefinition(sd, ctx) {
         // If we successfully fetched the external SD, process it as a full profile
         if (externalSD) {
             try {
-                console.log(`Processing external profile as StructureDefinition: ${typeName}`);
-                await processStructureDefinition(externalSD, { outputDir, fhirSourceHint: profileInfo.profileUrl, valueSetCodesMap, valueSets, examplesMap, existingStructureDefinitions, profileIdToName, flags });
+                logger.log(`Processing external profile as StructureDefinition: ${normalizedTypeName}`);
+                const actualInterfaceName = await processStructureDefinition(externalSD, { outputDir, fhirSourceHint: profileInfo.profileUrl, valueSetCodesMap, valueSets, examplesMap, existingStructureDefinitions, profileIdToName, profileUrlToName, flags, fhirChildTypeMap });
+                // If the actual generated interface name differs from what we expected,
+                // add a mapping so other profiles can find it
+                if (actualInterfaceName !== normalizedTypeName) {
+                    logger.log(`External profile ${normalizedTypeName} was generated as ${actualInterfaceName}, adding to profileIdToName mapping`);
+                    profileIdToName?.set(normalizedTypeName, actualInterfaceName);
+                    // Also add to URL mapping if we have the SD with a URL
+                    if (externalSD.url) {
+                        profileUrlToName?.set(externalSD.url, actualInterfaceName);
+                    }
+                    // Also add to existingStructureDefinitions so it won't be regenerated
+                    existingStructureDefinitions?.add(normalizedTypeName);
+                }
+                else if (externalSD.url) {
+                    // Even if names match, add URL mapping for future lookups
+                    profileUrlToName?.set(externalSD.url, actualInterfaceName);
+                }
                 continue; // Skip type alias generation since we created a full interface
             }
             catch (err) {
-                console.warn(`Failed to process external profile ${typeName}: ${err.message}, falling back to type alias`);
+                console.warn(`Failed to process external profile ${normalizedTypeName}: ${err.message}, falling back to type alias`);
             }
         }
         // Fallback: generate minimal type alias
+        failedFetchCount++;
+        failedFetchProfiles.push(profileInfo.profileUrl || normalizedTypeName);
         const baseTypeCandidates = Array.from(profileInfo.baseTypes.entries());
         const preferred = baseTypeCandidates.find(([, meta]) => meta.isFhir);
-        const baseType = preferred?.[0] || 'Element';
+        // Smart detection: if the URL or name contains "extension", or baseTypes includes Extension, use Extension as base type
+        let baseType = preferred?.[0] || 'Element';
+        const urlLower = (profileInfo.profileUrl || '').toLowerCase();
+        const nameLower = normalizedTypeName.toLowerCase();
+        const hasExtensionInBaseTypes = baseTypeCandidates.some(([type]) => type === 'Extension');
+        if (urlLower.includes('extension') || nameLower.includes('extension') || hasExtensionInBaseTypes) {
+            baseType = 'Extension';
+        }
         const importLine = `import type { ${baseType} } from "fhir/r4";\n\n`;
-        const typeAliasContent = `${importLine}// Type alias for external profile\n// Profile: ${profileInfo.profileUrl}\n// Note: Full StructureDefinition could not be fetched; using type alias based on ${baseType}\nexport type ${typeName} = ${baseType};\n`;
-        writeToFile(path.join(outputDir, `${typeName}.ts`), typeAliasContent);
-        console.log(`Generated type alias for external profile: ${typeName} (fetch failed, using ${baseType} alias)`);
+        const typeAliasContent = `${importLine}// Type alias for external profile\n// Profile: ${profileInfo.profileUrl}\n// Note: Full StructureDefinition could not be fetched; using type alias based on ${baseType}\nexport type ${normalizedTypeName} = ${baseType};\n`;
+        writeToFile(path.join(outputDir, `${normalizedTypeName}.ts`), typeAliasContent);
+        logger.log(`Generated type alias for external profile: ${normalizedTypeName} (fetch failed, using ${baseType} alias)`);
+    }
+    // Post-process: Fix up interface content to use correct import names for external profiles
+    // that were remapped during processing
+    let finalInterfaceContent = interfaceContent;
+    for (const [originalName, actualName] of profileIdToName?.entries() || []) {
+        if (originalName !== actualName) {
+            // Replace imports
+            const oldImport = `import { ${originalName} } from "./${originalName}"`;
+            const newImport = `import { ${actualName} } from "./${actualName}"`;
+            finalInterfaceContent = finalInterfaceContent.replace(oldImport, newImport);
+            // Also replace type usage in the interface
+            // We need to be careful to only replace type annotations, not field names
+            // This regex matches: type references after `: ` or `Array<` or `| ` or `& `
+            const typeUsageRegex = new RegExp(`(:\\s+|Array<|\\|\\s+|&\\s+)${originalName}(\\s*[;,>\\|&\\)\\n])`, 'g');
+            finalInterfaceContent = finalInterfaceContent.replace(typeUsageRegex, `$1${actualName}$2`);
+        }
     }
-    const merged = mergeFields(parsed.newFields, parsed.oldFields);
+    // Use aligned fields for validation to ensure consistency with interface generation
+    const merged = mergeFields(aligned.alignedNewFields, parsed.oldFields);
     const validateFn = generateValidateProfileFunction(interfaceName, merged);
-    const candidateRequiredFields = [...parsed.newFields, ...parsed.oldFields];
+    const candidateRequiredFields = [...aligned.alignedNewFields, ...parsed.oldFields];
     let requiredFields = candidateRequiredFields
         // only take direct children of the root path: `${sd.id}.${child}` or `${baseResource}.${child}`
         .filter(f => {
@@ -278,7 +355,7 @@ async function processStructureDefinition(sd, ctx) {
     }
     const classContent = generateClass(`${interfaceName}Class`, interfaceName, baseResource, requiredFields, sd.url);
     ensureRandomSupportFile(outputDir);
-    writeInterfaceAndValidatorToFile(outputDir, interfaceName, interfaceContent, validateFn);
+    writeInterfaceAndValidatorToFile(outputDir, interfaceName, finalInterfaceContent, validateFn);
     // Only generate class files if --no-classes flag is not set
     if (!flags?.noClasses) {
         writeToFile(path.join(outputDir, `${interfaceName}Class.ts`), classContent);
@@ -288,9 +365,10 @@ async function processStructureDefinition(sd, ctx) {
         }
     }
     console.log(`Generated artifacts for ${interfaceName}`);
+    return interfaceName;
 }
 export async function generate(fhirSource, outputDir, flags) {
-    console.log(`Fetching StructureDefinitions from: ${fhirSource}`);
+    logger.log(`Fetching StructureDefinitions from: ${fhirSource}`);
     let structureDefinitions = [];
     let localPath = fhirSource;
     try {
@@ -311,7 +389,7 @@ export async function generate(fhirSource, outputDir, flags) {
             structureDefinitions = readStructureDefinitionsFromDir(extracted);
             valueSetCodesMap = readValueSetCodesFromDir(extracted);
             valueSets = readValueSetsFromDir(extracted);
-            console.log(`Loaded ${valueSets.size} ValueSets (${Array.from(valueSets.values()).filter(vs => vs.isSmall).length} suitable for union types)`);
+            logger.log(`Loaded ${valueSets.size} ValueSets (${Array.from(valueSets.values()).filter(vs => vs.isSmall).length} suitable for union types)`);
         }
         finally {
             try {
@@ -323,7 +401,7 @@ export async function generate(fhirSource, outputDir, flags) {
     else {
         structureDefinitions = await fetchStructureDefinitions(fhirSource);
     }
-    console.log(`Fetched ${structureDefinitions.length} StructureDefinitions.`);
+    logger.log(`Fetched ${structureDefinitions.length} StructureDefinitions.`);
     ensureDirectoryExists(outputDir);
     // Precompute child type map for common core datatypes (best effort; silent on failures)
     let fhirChildTypeMap = new Map();
@@ -335,8 +413,17 @@ export async function generate(fhirSource, outputDir, flags) {
     // Build set of existing StructureDefinition names to avoid generating type aliases for them
     const existingStructureDefinitions = new Set();
     const profileIdToName = new Map(); // Map from profile ID to interface name
+    const profileUrlToName = new Map(); // Map from profile URL to interface name
+    // First pass: Pre-populate ALL mappings before any interface generation
+    // This ensures the maps are complete when generating interfaces (even on first run without cache)
+    logger.log(`Pre-populating profile registries with ${structureDefinitions.length} StructureDefinitions...`);
     for (const sd of structureDefinitions) {
-        const name = toPascalCase(sd.name || sd.id || '');
+        const rawInterfaceName = sd.name || sd.id || 'UnnamedInterface';
+        let name = toPascalCase(rawInterfaceName);
+        // Check if the interface name conflicts with a FHIR base type (same logic as processStructureDefinition)
+        if (fhirInterfaceNames.includes(name)) {
+            name = `${name}Extension`;
+        }
         if (name) {
             existingStructureDefinitions.add(name);
             // Also map the profile ID to the name for base profile lookups
@@ -344,11 +431,17 @@ export async function generate(fhirSource, outputDir, flags) {
                 const profileId = sanitizeIdentifier(sd.id);
                 profileIdToName.set(profileId, name);
             }
+            // Also map the profile URL to the name for extension resolution
+            if (sd.url) {
+                profileUrlToName.set(sd.url, name);
+                logger.log(`[Pre-Registry] ${sd.url} -> ${name}`);
+            }
         }
     }
+    logger.log(`Profile registries pre-populated: ${profileUrlToName.size} URLs, ${profileIdToName.size} IDs`);
     const examples = loadExamplesFromPackage(fhirSource);
     for (const sd of structureDefinitions) {
-        await processStructureDefinition(sd, { outputDir, fhirSourceHint: fhirSource, valueSetCodesMap, valueSets, examplesMap: examples, existingStructureDefinitions, profileIdToName, flags, fhirChildTypeMap });
+        await processStructureDefinition(sd, { outputDir, fhirSourceHint: fhirSource, valueSetCodesMap, valueSets, examplesMap: examples, existingStructureDefinitions, profileIdToName, profileUrlToName, flags, fhirChildTypeMap });
     }
 }
 /**
@@ -365,7 +458,7 @@ export async function generateIntoPackage(packageArchivePath, outArchivePath, fl
         const structureDefinitions = readStructureDefinitionsFromDir(extractedRoot);
         const valueSetCodesMap = readValueSetCodesFromDir(extractedRoot);
         const valueSets = readValueSetsFromDir(extractedRoot);
-        console.log(`Package contains ${structureDefinitions.length} StructureDefinitions.`);
+        logger.log(`Package contains ${structureDefinitions.length} StructureDefinitions.`);
         const outputDir = path.join(extractedRoot, 'generated');
         ensureDirectoryExists(outputDir);
         // Generate TypeScript files for ValueSets inside the embedded package
@@ -395,12 +488,12 @@ export async function generateIntoPackage(packageArchivePath, outArchivePath, fl
             if (generatedValueSetCount > 0) {
                 const registryContent = generateValueSetRegistry(valueSets);
                 fs.writeFileSync(path.join(valueSetOutputDir, 'index.ts'), registryContent, 'utf-8');
-                console.log(`Generated ${generatedValueSetCount} ValueSet files (skipped ${skippedEmptyCount} empty ValueSets) in ${valueSetOutputDir}`);
+                logger.log(`Generated ${generatedValueSetCount} ValueSet files (skipped ${skippedEmptyCount} empty ValueSets) in ${valueSetOutputDir}`);
                 didGenerateValueSets = true;
             }
             else {
                 if (skippedEmptyCount > 0) {
-                    console.log(`Skipped ${skippedEmptyCount} empty ValueSets (no files generated)`);
+                    logger.log(`Skipped ${skippedEmptyCount} empty ValueSets (no files generated)`);
                 }
             }
         }
@@ -424,21 +517,34 @@ export async function generateIntoPackage(packageArchivePath, outArchivePath, fl
         // Build set of existing StructureDefinition names
         const existingStructureDefinitions = new Set();
         const profileIdToName = new Map();
+        const profileUrlToName = new Map();
+        // First pass: Pre-populate mappings from all StructureDefinitions
+        logger.log(`Pre-populating profile registries with ${structureDefinitions.length} StructureDefinitions...`);
         for (const sd of structureDefinitions) {
-            const name = toPascalCase(sd.name || sd.id || '');
+            const rawInterfaceName = sd.name || sd.id || 'UnnamedInterface';
+            let name = toPascalCase(rawInterfaceName);
+            // Check if the interface name conflicts with a FHIR base type (same logic as processStructureDefinition)
+            if (fhirInterfaceNames.includes(name)) {
+                name = `${name}Extension`;
+            }
             if (name) {
                 existingStructureDefinitions.add(name);
                 if (sd.id) {
                     const profileId = sanitizeIdentifier(sd.id);
                     profileIdToName.set(profileId, name);
                 }
+                if (sd.url) {
+                    profileUrlToName.set(sd.url, name);
+                    logger.log(`[Pre-Registry] ${sd.url} -> ${name}`);
+                }
             }
         }
+        logger.log(`Profile registries pre-populated: ${profileUrlToName.size} URLs, ${profileIdToName.size} IDs`);
         // Register all local StructureDefinitions for resolution before HTTP fetches
         registerLocalStructureDefinitions(structureDefinitions);
         const examples = loadExamplesFromPackage(extractedRoot);
         for (const sd of structureDefinitions) {
-            await processStructureDefinition(sd, { outputDir, fhirSourceHint: '', valueSetCodesMap, valueSets, examplesMap: examples, existingStructureDefinitions, profileIdToName, flags });
+            await processStructureDefinition(sd, { outputDir, fhirSourceHint: '', valueSetCodesMap, valueSets, examplesMap: examples, existingStructureDefinitions, profileIdToName, profileUrlToName, flags });
         }
         // Create package.json in generated folder
         const originalPackageJsonPath = path.join(extractedRoot, 'package', 'package.json');
@@ -470,23 +576,23 @@ export async function generateIntoPackage(packageArchivePath, outArchivePath, fl
         };
         const generatedPackageJsonPath = path.join(outputDir, 'package.json');
         fs.writeFileSync(generatedPackageJsonPath, JSON.stringify(generatedPackageJson, null, 2));
-        console.log(`Created package.json in generated folder: ${packageName}-generated@${packageVersion}`);
+        logger.log(`Created package.json in generated folder: ${packageName}-generated@${packageVersion}`);
         // Copy fhir-r4.d.ts ambient module declaration to support fhir/r4 imports
         // The file is at out/fhir-r4.d.ts (root of compiled output)
         const fhirR4DtsSource = path.join(path.dirname(path.dirname(fileURLToPath(import.meta.url))), 'fhir-r4.d.ts');
         const fhirR4DtsDest = path.join(outputDir, 'fhir-r4.d.ts');
         if (fs.existsSync(fhirR4DtsSource)) {
             fs.copyFileSync(fhirR4DtsSource, fhirR4DtsDest);
-            console.log('Copied fhir-r4.d.ts ambient module declaration');
+            logger.log('Copied fhir-r4.d.ts ambient module declaration');
         }
         else {
             console.warn('Warning: fhir-r4.d.ts not found. Run: npm run generate:fhir-module');
         }
         // Generate index.ts that exports all interfaces
-        console.log('Generating index.ts exports...');
+        logger.log('Generating index.ts exports...');
         await generateIndexFile(outputDir);
         // Compile TypeScript to JavaScript
-        console.log('Compiling TypeScript to JavaScript...');
+        logger.log('Compiling TypeScript to JavaScript...');
         await compileTypeScriptToJS(outputDir);
         const finalArchive = outArchivePath || deriveOutputArchiveName(packageArchivePath);
         await createPackageFromDir(extractedRoot, finalArchive);
@@ -519,7 +625,7 @@ export async function generateForDirectory(inputDir, outputDir, flags) {
     // Load ValueSets from the directory
     const valueSets = readValueSetsFromDir(inputDir);
     const valueSetCodesMap = readValueSetCodesFromDir(inputDir);
-    console.log(`Loaded ${valueSets.size} ValueSets from ${inputDir} (${Array.from(valueSets.values()).filter(vs => vs.isSmall).length} suitable for union types)`);
+    logger.log(`Loaded ${valueSets.size} ValueSets from ${inputDir} (${Array.from(valueSets.values()).filter(vs => vs.isSmall).length} suitable for union types)`);
     // Generate TypeScript files for ValueSets
     const valueSetOutputDir = path.join(outputDir, 'valuesets');
     let generatedValueSetCount = 0;
@@ -549,11 +655,11 @@ export async function generateForDirectory(inputDir, outputDir, flags) {
         const registryContent = generateValueSetRegistry(valueSets);
         const registryPath = path.join(valueSetOutputDir, 'index.ts');
         fs.writeFileSync(registryPath, registryContent, 'utf-8');
-        console.log(`Generated ${generatedValueSetCount} ValueSet files (skipped ${skippedEmptyCount} empty ValueSets) in ${valueSetOutputDir}`);
+        logger.log(`Generated ${generatedValueSetCount} ValueSet files (skipped ${skippedEmptyCount} empty ValueSets) in ${valueSetOutputDir}`);
     }
     else {
         if (skippedEmptyCount > 0) {
-            console.log(`Skipped ${skippedEmptyCount} empty ValueSets (no files generated)`);
+            logger.log(`Skipped ${skippedEmptyCount} empty ValueSets (no files generated)`);
         }
         // Remove any stale valuesets directory from previous runs
         try {
@@ -580,35 +686,49 @@ export async function generateForDirectory(inputDir, outputDir, flags) {
     // Build set of existing StructureDefinition names from JSON files
     const existingStructureDefinitions = new Set();
     const profileIdToName = new Map();
+    const profileUrlToName = new Map(); // Map from profile URL to interface name
     const localStructureDefinitions = [];
+    // First pass: Pre-populate mappings from all JSON StructureDefinitions
+    logger.log(`Pre-populating profile registries from ${jsonFiles.length} JSON files...`);
     for (const jf of jsonFiles) {
         try {
             const raw = JSON.parse(fs.readFileSync(path.join(inputDir, jf), 'utf-8'));
             if (typeof raw === 'object' && raw !== null && raw.resourceType === 'StructureDefinition') {
                 const sd = raw;
                 localStructureDefinitions.push(sd); // Collect for local resolution
-                const name = toPascalCase(sd.name || sd.id || '');
+                const rawInterfaceName = sd.name || sd.id || 'UnnamedInterface';
+                let name = toPascalCase(rawInterfaceName);
+                // Check if the interface name conflicts with a FHIR base type (same logic as processStructureDefinition)
+                if (fhirInterfaceNames.includes(name)) {
+                    name = `${name}Extension`;
+                }
                 if (name) {
                     existingStructureDefinitions.add(name);
                     if (sd.id) {
                         const profileId = sanitizeIdentifier(sd.id);
                         profileIdToName.set(profileId, name);
                     }
+                    // Also map profile URL to name for extension resolution
+                    if (sd.url) {
+                        profileUrlToName.set(sd.url, name);
+                        logger.log(`[Pre-Registry] ${sd.url} -> ${name}`);
+                    }
                 }
             }
         }
         catch { /* ignore parse errors in pre-scan */ }
     }
+    logger.log(`Profile registries pre-populated: ${profileUrlToName.size} URLs, ${profileIdToName.size} IDs`);
     // Register all local StructureDefinitions for resolution before HTTP fetches
     registerLocalStructureDefinitions(localStructureDefinitions);
     for (const file of archives) {
         const fullPath = path.join(inputDir, file);
-        console.log(`Processing package: ${file}`);
+        logger.log(`Processing package: ${file}`);
         try {
             const outName = file.replace(/(\.tgz|\.zip)$/i, '.with-generated$1');
             const outArchive = path.join(outputDir, outName);
             await generateIntoPackage(fullPath, outArchive);
-            console.log(`→ Wrote ${outArchive}`);
+            logger.log(`→ Wrote ${outArchive}`);
         }
         catch (err) {
             console.error(`Failed processing ${file}:`, err);
@@ -618,7 +738,7 @@ export async function generateForDirectory(inputDir, outputDir, flags) {
         const full = path.join(inputDir, jf);
         try {
             const raw = JSON.parse(fs.readFileSync(full, 'utf-8'));
-            await processStructureDefinition(raw, { outputDir, fhirSourceHint: full, valueSetCodesMap, valueSets, existingStructureDefinitions, profileIdToName, flags });
+            await processStructureDefinition(raw, { outputDir, fhirSourceHint: full, valueSetCodesMap, valueSets, existingStructureDefinitions, profileIdToName, profileUrlToName, flags });
         }
         catch (err) {
             console.error(`Failed processing JSON ${jf}:`, err);