babelfhir-ts 1.0.33 → 1.0.34

package/out/generator/classGenerator.js

@@ -1,3 +1,5 @@
+import { logger } from '../logger.js';
+const log = logger.withTag('classGenerator');
 // FHIR primitive types - these cannot have nested child properties (only _fieldName extensions)
 const FHIR_PRIMITIVE_TYPES = new Set([
     'string', 'boolean', 'integer', 'decimal', 'uri', 'url', 'canonical', 'base64Binary',
@@ -23,6 +25,36 @@ function primitivePlaceholder(type) {
         default: return `randomId()`; // fallback
     }
 }
+/**
+ * Generate a sensible default value for a 'code' type field based on its name.
+ * Common FHIR code fields have known value sets - we pick a valid default.
+ */
+function generateCodeDefault(fieldName) {
+    const name = fieldName.toLowerCase();
+    // Map common field names to sensible defaults
+    if (name === 'language')
+        return `'en'`; // ISO 639-1 language code
+    if (name === 'confidentiality')
+        return `'N'`; // HL7 v3 Confidentiality (Normal)
+    if (name === 'status')
+        return `'active'`;
+    if (name === 'mode')
+        return `'snapshot'`;
+    if (name === 'intent')
+        return `'proposal'`;
+    if (name === 'priority')
+        return `'routine'`;
+    if (name === 'gender')
+        return `'unknown'`;
+    if (name === 'use')
+        return `'usual'`;
+    if (name === 'type')
+        return `'document'`;
+    if (name === 'content')
+        return `'complete'`;
+    // Fallback to a simple code pattern
+    return `'unknown'`;
+}
 const OBSERVATION_CATEGORY_SYSTEM = 'http://terminology.hl7.org/CodeSystem/observation-category';
 const CONDITION_CATEGORY_SYSTEM = 'http://terminology.hl7.org/CodeSystem/condition-category';
 const ROLE_CODE_SYSTEM = 'http://terminology.hl7.org/CodeSystem/v3-RoleCode';
@@ -668,11 +700,22 @@ function generateSliceElement(slice, elementType) {
             }
         }
     }
+    // Handle CodeableConcept slices with binding codes but no patternConstraint
+    // This synthesizes a valid CodeableConcept from the first binding code
+    // Critical for slices like category:us-core which require codes from a ValueSet
+    else if (elementType === 'CodeableConcept' && slice.binding?.codes && slice.binding.codes.length > 0) {
+        const firstCode = slice.binding.codes[0];
+        const system = firstCode.system || 'http://terminology.hl7.org/CodeSystem/v3-NullFlavor';
+        const code = firstCode.code;
+        const display = firstCode.display || code;
+        return JSON.stringify({
+            coding: [{ system, code, display }]
+        });
+    }
     // Handle required children with their constraints
     // Only process direct children (single-segment paths) to avoid complex nested object generation
-    // DEBUG: Log requiredChildren for document bundle slices
-    if (process.env.DEBUG_FHIR_GEN === 'true' && slice.name?.toLowerCase().includes('composition')) {
-        console.log(`[generateSliceElement] Composition slice requiredChildren: ${JSON.stringify(slice.requiredChildren?.map(c => ({ path: c.path, isRequired: c.isRequired, profileUrls: c.profileUrls })))}`);
+    if (slice.name?.toLowerCase().includes('composition')) {
+        log.debug(`Composition slice requiredChildren: ${JSON.stringify(slice.requiredChildren?.map(c => ({ path: c.path, isRequired: c.isRequired, profileUrls: c.profileUrls })))}`);
     }
     if (slice.requiredChildren && slice.requiredChildren.length > 0) {
         for (const child of slice.requiredChildren) {
@@ -713,10 +756,7 @@ function generateSliceElement(slice, elementType) {
                     const sliceName = slice.name?.toLowerCase() || '';
                     const profileUrls = child.profileUrls || [];
                     const profileUrl = profileUrls[0]; // Primary profile URL
-                    // DEBUG: Log profile detection for document bundles
-                    if (process.env.DEBUG_FHIR_GEN === 'true') {
-                        console.log(`[generateSliceElement] Resource child - sliceName: ${sliceName}, profileUrls: ${JSON.stringify(profileUrls)}, profileUrl: ${profileUrl}`);
-                    }
+                    log.debug(`Resource child - sliceName: ${sliceName}, profileUrls: ${JSON.stringify(profileUrls)}, profileUrl: ${profileUrl}`);
                     const metaProfile = profileUrl ? `, meta: { profile: ['${profileUrl}'] }` : '';
                     // Extract resource type from profile URL if available (e.g., Composition-uv-ips -> Composition)
                     // Also check child.type which may contain the base resource type
@@ -830,9 +870,8 @@ function generateSliceElement(slice, elementType) {
     const sliceProfileUrls = slice.profileUrls || resourceChild?.profileUrls || [];
     const primaryProfileUrl = sliceProfileUrls[0];
     const metaProfileExpr = primaryProfileUrl ? `, meta: { profile: ['${primaryProfileUrl}'] }` : '';
-    // DEBUG: Log slice info for document bundles
-    if (process.env.DEBUG_FHIR_GEN === 'true' && (sliceName.includes('composition') || sliceName.includes('document'))) {
-        console.log(`[generateSliceElement] Composition slice - name: ${slice.name}, profileUrls: ${JSON.stringify(slice.profileUrls)}, resourceChild?.profileUrls: ${JSON.stringify(resourceChild?.profileUrls)}, primaryProfileUrl: ${primaryProfileUrl}`);
+    if (sliceName.includes('composition') || sliceName.includes('document')) {
+        log.debug(`Composition slice - name: ${slice.name}, profileUrls: ${JSON.stringify(slice.profileUrls)}, resourceChild?.profileUrls: ${JSON.stringify(resourceChild?.profileUrls)}, primaryProfileUrl: ${primaryProfileUrl}`);
     }
     if (sliceName.includes('composition') || sliceName.includes('document')) {
         // Composition slice - requires: text (narrative), identifier, author.display
@@ -883,6 +922,21 @@ function generateSliceElement(slice, elementType) {
         // Device slice
         return `{ fullUrl: 'urn:uuid:' + crypto.randomUUID(), resource: { resourceType: 'Device', id: randomId()${metaProfileExpr}, type: { coding: [{ system: 'http://snomed.info/sct', code: '49062001', display: 'Device' }] } } }`;
     }
+    // Handle non-Bundle element types - don't return fullUrl structure for simple types
+    if (elementType === 'CodeableConcept') {
+        // For CodeableConcept slices (like category:us-core), return a valid CodeableConcept
+        // The binding/pattern should ideally provide the code, but fallback to a generic structure
+        return `{ coding: [{ system: 'http://terminology.hl7.org/CodeSystem/data-absent-reason', code: 'unknown', display: 'Unknown' }] }`;
+    }
+    if (elementType === 'Coding') {
+        return `{ system: 'http://terminology.hl7.org/CodeSystem/data-absent-reason', code: 'unknown', display: 'Unknown' }`;
+    }
+    if (elementType === 'Identifier') {
+        return `{ system: 'http://example.org/ids', value: randomId() }`;
+    }
+    if (elementType === 'Reference') {
+        return `{ reference: 'Resource/' + randomId() }`;
+    }
     // For BackboneElement without specific type, return a minimal placeholder
     return `{ fullUrl: 'urn:uuid:' + randomId() }`;
 }
@@ -1232,8 +1286,9 @@ export function generateClass(className, interfaceName, baseResource, requiredFi
             requiredInits.push(`${key(rf.name)}: ${initExpr}`);
             continue;
         }
-        if (['string', 'number', 'boolean'].includes(rf.type)) {
-            const expr = primitivePlaceholder(rf.type);
+        if (['string', 'number', 'boolean', 'code'].includes(rf.type)) {
+            // For 'code' type without binding, generate based on field name to pick a sensible default
+            const expr = rf.type === 'code' ? generateCodeDefault(rf.name) : primitivePlaceholder(rf.type);
             const initExpr = buildValueExpression(rf, expr);
             requiredInits.push(`${key(rf.name)}: ${initExpr}`);
             continue;
@@ -1310,6 +1365,35 @@ export function generateClass(className, interfaceName, baseResource, requiredFi
                         code = JSON.stringify(parentBindingCode.code);
                     }
                 }
+                // Check requiredChildren from type profile for required fields like 'version' and 'system'
+                // This handles cases like CodingOPS which requires version field
+                // and CodingAlphaID which has a fixed system value
+                if (slice.requiredChildren && slice.requiredChildren.length > 0) {
+                    for (const child of slice.requiredChildren) {
+                        if (child.path === 'version' && !version) {
+                            // Check for fixed or pattern value first
+                            if (child.fixedValue && typeof child.fixedValue === 'string') {
+                                version = child.fixedValue;
+                            }
+                            else if (child.patternConstraint && typeof child.patternConstraint === 'string') {
+                                version = child.patternConstraint;
+                            }
+                            else if (child.isRequired) {
+                                // Version is required by type profile but not set - use current year
+                                version = new Date().getFullYear().toString();
+                            }
+                        }
+                        if (child.path === 'system') {
+                            // Check for fixed or pattern value for system
+                            if (child.fixedValue && typeof child.fixedValue === 'string') {
+                                system = child.fixedValue;
+                            }
+                            else if (child.patternConstraint && typeof child.patternConstraint === 'string') {
+                                system = child.patternConstraint;
+                            }
+                        }
+                    }
+                }
                 codingProps.push(`system: ${JSON.stringify(system)}`);
                 if (version) {
                     codingProps.push(`version: ${JSON.stringify(version)}`);

package/out/generator/importManager.js

@@ -75,12 +75,16 @@ export class ImportManager {
             return;
         }
         // Check if we already have an external profile registered with this URL
-        // If so, use the existing name to avoid duplicates
+        // If so, use the existing name to avoid duplicates, but still register baseType info
         if (profileUrl) {
             for (const [existingName, existingMeta] of this.externalProfiles) {
                 if (existingMeta.profileUrl === profileUrl) {
                     const existingNormalized = toPascalCase(sanitizeIdentifier(existingName));
                     this.customImports.add(existingNormalized);
+                    // Still register baseType info even for duplicates (important for extension detection)
+                    if (baseType) {
+                        this.registerExternalProfile(typeName, profileUrl, baseType, isFhirBase);
+                    }
                     return;
                 }
             }
@@ -139,9 +143,11 @@ export class ImportManager {
             const existing = meta.baseTypes.get(sanitizedBase);
             if (!existing) {
                 meta.baseTypes.set(sanitizedBase, { isFhir: isFhirBase });
+                logger.debug(`[ImportManager] Registered baseType '${sanitizedBase}' (isFhir=${isFhirBase}) for external profile '${normalizedTypeName}' (URL: ${resolvedProfileUrl})`);
             }
             else if (isFhirBase && !existing.isFhir) {
                 existing.isFhir = true;
+                logger.debug(`[ImportManager] Updated baseType '${sanitizedBase}' to isFhir=true for '${normalizedTypeName}'`);
             }
         }
     }

package/out/generator/index.js

@@ -4,7 +4,7 @@ import { fileURLToPath } from 'url';
 import { generateClass } from './classGenerator.js';
 import { generateInterfaces } from './interfaceGenerator.js';
 import { extractPackage, readStructureDefinitionsFromDir, createPackageFromDir, readValueSetCodesFromDir, readValueSetCodesWithDependencies, readValueSetsFromDir } from './packageParser.js';
-import { fetchStructureDefinitions, parseStructureDefinition, fetchStructureDefinition, registerLocalStructureDefinitions } from './sdParser.js';
+import { fetchStructureDefinitions, parseStructureDefinition, fetchStructureDefinition, registerLocalStructureDefinitions, clearLocalStructureDefinitions } from './sdParser.js';
 import { writeInterfaceAndValidatorToFile, mergeFields, alignFields, ensureDirectoryExists, writeToFile, getBaseResource, downloadFile, sanitizeIdentifier, toPascalCase, capitalize } from './utils.js';
 import { generateValidateProfileFunction } from './validatorGenerator.js';
 import { generateValueSetTypeScript, generateValueSetRegistry } from './valueSetGenerator.js';
@@ -294,14 +294,35 @@ async function processStructureDefinition(sd, ctx) {
         failedFetchProfiles.push(profileInfo.profileUrl || normalizedTypeName);
         const baseTypeCandidates = Array.from(profileInfo.baseTypes.entries());
         const preferred = baseTypeCandidates.find(([, meta]) => meta.isFhir);
+        // Log detailed info about the external profile for debugging
+        log.info(`[ExternalProfile] ${normalizedTypeName}:`);
+        log.info(`  - URL: ${profileInfo.profileUrl || 'N/A'}`);
+        log.info(`  - baseTypes: ${baseTypeCandidates.map(([t, m]) => `${t}(isFhir=${m.isFhir})`).join(', ') || 'none'}`);
+        log.info(`  - isExtensionProfile: ${profileInfo.isExtensionProfile ?? 'undefined'}`);
         // Smart detection: if the URL or name contains "extension", or baseTypes includes Extension, use Extension as base type
+        // Also check if the profile is used in an extension context (isExtensionProfile flag from interfaceGenerator)
         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) {
+        const isUsedAsExtension = profileInfo.isExtensionProfile === true;
+        log.info(`  - Initial baseType: ${baseType}`);
+        log.info(`  - urlLower.includes('extension'): ${urlLower.includes('extension')}`);
+        log.info(`  - nameLower.includes('extension'): ${nameLower.includes('extension')}`);
+        log.info(`  - hasExtensionInBaseTypes: ${hasExtensionInBaseTypes}`);
+        log.info(`  - isUsedAsExtension: ${isUsedAsExtension}`);
+        if (urlLower.includes('extension') || nameLower.includes('extension') || hasExtensionInBaseTypes || isUsedAsExtension) {
             baseType = 'Extension';
+            log.info(`  - Overriding baseType to Extension`);
         }
+        // Safety: NEVER use 'Element' as base type for extension profiles - it causes TypeScript errors
+        // when the generated type is used in extension?: Extension[] arrays
+        if (baseType === 'Element') {
+            log.warn(`[ExternalProfile] Type alias for ${normalizedTypeName} is using 'Element' as base type. ` +
+                `If this type is used in extension arrays, it may cause TypeScript compilation errors. ` +
+                `URL: ${profileInfo.profileUrl || 'N/A'}, baseTypes: ${baseTypeCandidates.map(([t]) => t).join(', ') || 'none'}`);
+        }
+        log.info(`  - Final baseType: ${baseType}`);
         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 ${normalizedTypeName} = ${baseType};\n`;
         writeToFile(path.join(outputDir, `${normalizedTypeName}.ts`), typeAliasContent);
@@ -690,6 +711,75 @@ async function processStructureDefinition(sd, ctx) {
                     key = parentPart.split(':')[0];
                 }
             }
+            // For coding slices with profile URLs, resolve the profile to get required fields like 'version'
+            // This handles cases like coding:ICD-10-GM -> ISiKICD10GMCoding -> CodingICD10GM where version is required
+            if (lastPart === 'coding' && f.sliceName && f.profileUrls && f.profileUrls.length > 0) {
+                for (const profileUrl of f.profileUrls) {
+                    // Check if already resolved
+                    let resolved = resolvedProfilePatterns.get(profileUrl);
+                    if (!resolved) {
+                        try {
+                            const profileSd = await fetchStructureDefinition(profileUrl);
+                            if (profileSd) {
+                                const patternData = {};
+                                // Track required fields from this profile and its base
+                                const requiredFields = [];
+                                // Check elements for required fields
+                                const checkElements = (elements) => {
+                                    if (!elements)
+                                        return;
+                                    for (const elem of elements) {
+                                        // Check for required version field (min >= 1)
+                                        if (elem.path?.endsWith('.version') && elem.min && elem.min >= 1) {
+                                            requiredFields.push('version');
+                                        }
+                                        // Check for fixedUri on system
+                                        if (elem.path?.endsWith('.system') && elem.fixedUri) {
+                                            patternData.system = elem.fixedUri;
+                                        }
+                                    }
+                                };
+                                // Check this profile's elements
+                                checkElements(profileSd.snapshot?.element);
+                                checkElements(profileSd.differential?.element);
+                                // Also check the base profile if there is one (e.g., CodingICD10GM requires version)
+                                if (profileSd.baseDefinition) {
+                                    try {
+                                        const baseSd = await fetchStructureDefinition(profileSd.baseDefinition);
+                                        if (baseSd) {
+                                            checkElements(baseSd.snapshot?.element);
+                                            checkElements(baseSd.differential?.element);
+                                        }
+                                    }
+                                    catch {
+                                        // Base profile resolution failed
+                                    }
+                                }
+                                // If version is required, add it to the pattern
+                                if (requiredFields.includes('version')) {
+                                    // Use the current year as the default version (common for ICD-10 codes)
+                                    patternData.version = new Date().getFullYear().toString();
+                                }
+                                if (Object.keys(patternData).length > 0) {
+                                    resolvedProfilePatterns.set(profileUrl, patternData);
+                                    resolved = patternData;
+                                }
+                            }
+                        }
+                        catch {
+                            // Profile resolution failed
+                        }
+                    }
+                    // Merge resolved profile pattern with existing patternConstraint
+                    if (resolved && typeof resolved === 'object') {
+                        const existingPattern = (f.patternConstraint && typeof f.patternConstraint === 'object')
+                            ? f.patternConstraint
+                            : {};
+                        // Merge: existing pattern takes precedence for system, resolved adds version
+                        f.patternConstraint = { ...resolved, ...existingPattern };
+                    }
+                }
+            }
             // For identifier slices with profile URLs, resolve the profile to get system constraint
             // This handles cases like identifier:Arztnummer -> identifier-lanr where the system
             // is defined in the referenced profile, not in the slicing profile itself
@@ -777,6 +867,35 @@ async function processStructureDefinition(sd, ctx) {
                     }
                 }
             }
+            // Also extract binding sample codes for nested primitive paths (like valueQuantity.code)
+            // This handles cases where the binding is on a nested field, not a slice
+            // IMPORTANT: Only apply to truly nested paths (2+ parts after removing resource type)
+            // Top-level slices like category:us-core should NOT be handled here - they're handled below
+            else if (f.binding?.sampleCode && typeof f.binding.sampleCode === 'object') {
+                const elementId = f.elementId || f.name;
+                const idParts = elementId.split('.');
+                // Remove the resource type prefix (first part)
+                if (idParts.length > 2) { // Changed from > 1 to > 2: need at least 3 parts (Resource.field.nested)
+                    idParts.shift();
+                    // Build nested key, extracting slice names where present
+                    const nestedParts = [];
+                    for (const part of idParts) {
+                        if (part.includes(':')) {
+                            nestedParts.push(part.split(':')[1]);
+                        }
+                        else if (!part.includes('[x]')) {
+                            nestedParts.push(part);
+                        }
+                    }
+                    if (nestedParts.length > 1) { // Changed from > 0 to > 1: need at least 2 nested parts for truly nested path
+                        const nestedKey = nestedParts.join('.');
+                        // Only add if we don't already have this key
+                        if (!patternMap.has(nestedKey)) {
+                            patternMap.set(nestedKey, f.binding.sampleCode.code);
+                        }
+                    }
+                }
+            }
             // Otherwise, if this is a slice with binding codes, synthesize a pattern
             else if (!patternMap.has(key) && f.sliceName && f.binding && f.binding.codes && f.binding.codes.length > 0) {
                 // Create a CodeableConcept pattern from the first binding code
@@ -802,13 +921,38 @@ async function processStructureDefinition(sd, ctx) {
         const refReqKey = `_refReq_${parentFieldName}`;
         if (!patternMap.has(refReqKey)) {
             // Store as an object with the nested requirements paths
+            // For extension fields, store profile URL so enrichResource can generate correct extension
             const reqPaths = {};
             for (const req of requirements) {
-                reqPaths[req.path] = true; // Mark each required path
+                if (req.path === 'extension' && req.profileUrl) {
+                    // Store extension profile URL for primitive element extension generation
+                    reqPaths[req.path] = { profile: req.profileUrl };
+                }
+                else {
+                    reqPaths[req.path] = true; // Mark each required path
+                }
             }
             patternMap.set(refReqKey, reqPaths);
         }
     }
+    // Add type option markers for choice elements (like value[x]) constrained to specific types
+    // This enables enrichResource to use the correct value[x] variant (e.g., valueCodeableConcept instead of valueQuantity)
+    // IMPORTANT: Check candidateRequiredFields (all fields), not just requiredFields, because value[x] is typically optional (min=0)
+    for (const f of candidateRequiredFields) {
+        // Only consider choice type fields (ending with [x]) that have type constraints
+        if (f.name.endsWith('[x]') && f.typeOptions && f.typeOptions.length > 0) {
+            // Extract the field name from the path (e.g., "Observation.value[x]" -> "value[x]")
+            const parts = f.name.split('.');
+            if (parts.length === 2) {
+                const fieldName = parts[1];
+                const typeMarkerKey = `_choiceType_${fieldName}`;
+                if (!patternMap.has(typeMarkerKey)) {
+                    // Store the allowed types so enrichResource can pick the right variant
+                    patternMap.set(typeMarkerKey, f.typeOptions.map(t => t.code));
+                }
+            }
+        }
+    }
     const fieldPatterns = Array.from(patternMap.entries()).map(([fieldName, pattern]) => ({ fieldName, pattern }));
     // Merge patterns from fieldPatterns into requiredFields so applyRequiredFieldHeuristic can use them
     // IMPORTANT: Don't add patternConstraint if the field has requiredSlices - those contain the correct pattern info
@@ -846,6 +990,11 @@ async function processStructureDefinition(sd, ctx) {
     return interfaceName;
 }
 export async function generate(fhirSource, outputDir, flags) {
+    // Initialize logger at the start of generation
+    const logDest = flags?.logDestination || flags?.logLevel || 'console';
+    logger.setLevel(logDest, outputDir, flags?.logVerbosity || 'info');
+    // Clear local StructureDefinitions from any previous generation
+    clearLocalStructureDefinitions();
     logger.log(`Fetching StructureDefinitions from: ${fhirSource}`);
     let structureDefinitions = [];
     let localPath = fhirSource;
@@ -929,12 +1078,23 @@ export async function generate(fhirSource, outputDir, flags) {
  * folder, then repackage to the specified output archive (or alongside original).
  */
 export async function generateIntoPackage(packageArchivePath, outArchivePath, flags) {
+    // Initialize logger at the start of generation
+    const logDest = flags?.logDestination || flags?.logLevel || 'console';
+    logger.setLevel(logDest, path.dirname(outArchivePath || packageArchivePath), flags?.logVerbosity || 'info');
+    // Clear local StructureDefinitions from any previous generation
+    clearLocalStructureDefinitions();
     if (!packageArchivePath.endsWith('.tgz') && !packageArchivePath.endsWith('.zip'))
         throw new Error('Only .tgz or .zip supported.');
     const extractResult = await extractPackage(packageArchivePath);
     const extractedRoot = extractResult.path;
     const shouldCleanup = !extractResult.isCached; // Only cleanup temp directories, not cache
     try {
+        // Load dependencies from package.json BEFORE reading StructureDefinitions
+        // This ensures base profiles (like coverage-de-basis) are available for resolution
+        const { getPackageManager } = await import('./packageManager.js');
+        const packageManager = getPackageManager();
+        packageManager.loadDependenciesFromExtractedPackage(extractedRoot);
+        logger.log(`Loaded package dependencies (${packageManager.getTotalStructureDefinitionCount()} total SDs available)`);
         const structureDefinitions = readStructureDefinitionsFromDir(extractedRoot);
         // Load ValueSets from package AND its dependencies (for binding resolution)
         const valueSetCodesMap = readValueSetCodesWithDependencies(extractedRoot);
@@ -985,15 +1145,11 @@ export async function generateIntoPackage(packageArchivePath, outArchivePath, fl
             try {
                 if (fs.existsSync(vdir)) {
                     fs.rmSync(vdir, { recursive: true, force: true });
-                    if (process.env.DEBUG_FHIR_GEN === 'true') {
-                        log.debug(`Removed stale ValueSets directory: ${vdir}`);
-                    }
+                    log.debug(`Removed stale ValueSets directory: ${vdir}`);
                 }
             }
             catch (e) {
-                if (process.env.DEBUG_FHIR_GEN === 'true') {
-                    log.warn(`Failed to remove stale ValueSets directory ${vdir}: ${e.message}`);
-                }
+                log.debug(`Failed to remove stale ValueSets directory ${vdir}: ${e.message}`);
             }
         }
         // Build set of existing StructureDefinition names
@@ -1099,8 +1255,7 @@ export async function generateIntoPackage(packageArchivePath, outArchivePath, fl
                 fs.rmSync(extractedRoot, { recursive: true, force: true });
             }
             catch (err) {
-                if (process.env.DEBUG_FHIR_GEN === 'true')
-                    log.warn(`Cleanup failed: ${err.message}`);
+                log.debug(`Cleanup failed: ${err.message}`);
             }
         }
     }
@@ -1114,7 +1269,10 @@ function deriveOutputArchiveName(input) {
  */
 export async function generateForDirectory(inputDir, outputDir, flags) {
     // Initialize logger
-    logger.setLevel(flags?.logLevel || 'none', outputDir);
+    const logDest = flags?.logDestination || flags?.logLevel || 'console';
+    logger.setLevel(logDest, outputDir, flags?.logVerbosity || 'info');
+    // Clear local StructureDefinitions from any previous generation
+    clearLocalStructureDefinitions();
     if (!fs.existsSync(inputDir))
         throw new Error(`Input directory not found: ${inputDir}`);
     if (!fs.existsSync(outputDir))
@@ -1162,15 +1320,11 @@ export async function generateForDirectory(inputDir, outputDir, flags) {
         try {
             if (fs.existsSync(valueSetOutputDir)) {
                 fs.rmSync(valueSetOutputDir, { recursive: true, force: true });
-                if (process.env.DEBUG_FHIR_GEN === 'true') {
-                    log.debug(`Removed stale ValueSets directory: ${valueSetOutputDir}`);
-                }
+                log.debug(`Removed stale ValueSets directory: ${valueSetOutputDir}`);
             }
         }
         catch (e) {
-            if (process.env.DEBUG_FHIR_GEN === 'true') {
-                log.warn(`Failed to remove stale ValueSets directory ${valueSetOutputDir}: ${e.message}`);
-            }
+            log.debug(`Failed to remove stale ValueSets directory ${valueSetOutputDir}: ${e.message}`);
         }
     }
     const entries = fs.readdirSync(inputDir);
@@ -1259,6 +1413,8 @@ export async function generateForDirectory(inputDir, outputDir, flags) {
     }
 }
 export async function generateFromJsonFile(jsonFilePath, outputDir, flags) {
+    // Clear local StructureDefinitions from any previous generation
+    clearLocalStructureDefinitions();
     if (!fs.existsSync(jsonFilePath))
         throw new Error(`File not found: ${jsonFilePath}`);
     const raw = JSON.parse(fs.readFileSync(jsonFilePath, 'utf-8'));
@@ -1274,6 +1430,8 @@ export async function generateFromJsonFile(jsonFilePath, outputDir, flags) {
  * @param flags - Generation options
  */
 export async function generateFromProfileUrl(profileUrl, outputDir, flags) {
+    // Clear local StructureDefinitions from any previous generation
+    clearLocalStructureDefinitions();
     log.info(`Fetching profile: ${profileUrl}`);
     // Load all cached packages to make profile resolution work
     const { getPackageManager } = await import('./packageManager.js');

package/out/generator/interfaceGenerator.js

@@ -7,8 +7,7 @@ import { r4Rules } from './fhirR4Rules.js';
 import { postProcessExtensions, safetyNetRootExtensions } from './postProcessExtensions.js';
 const log = logger.withTag('interfaces');
 export function generateInterfaces(interfaceName, newFields, baseResource, baseFields = [], valueSets, resourceType, existingProfiles, fhirChildTypeMap, profileIdToName, profileUrlToName) {
-    const debug = (...args) => { if (process.env.DEBUG_FHIR_GEN === 'true')
-        log.debug(...args); };
+    const debug = (...args) => log.debug(...args);
     const interfaces = [];
     const localInterfaceNames = new Set();
     const writtenLines = new Set();
@@ -25,6 +24,18 @@ export function generateInterfaces(interfaceName, newFields, baseResource, baseF
         }
         importManager.addType(typeName, profileUrl, baseType, isFhirBase);
     };
+    // Helper to determine if a field is an extension field and get the correct base type
+    // Extension fields should always use 'Extension' as base type for proper fallback aliases
+    const getBaseTypeForField = (fieldName, fallbackBaseType) => {
+        const fieldNameLower = fieldName.toLowerCase();
+        const isExtensionField = fieldNameLower.endsWith('.extension') ||
+            fieldNameLower.endsWith('.modifierextension') ||
+            fieldNameLower.includes('extension:') ||
+            fieldNameLower.includes('modifierextension:');
+        const baseTypeName = isExtensionField ? 'Extension' : fallbackBaseType;
+        const baseIsFhir = isExtensionField || (baseTypeName ? isFhirType(baseTypeName) : false);
+        return { baseTypeName, baseIsFhir };
+    };
     // Helper to find exact interface block index (avoid prefix collisions like Foo and FooBar)
     const findInterfaceIndex = (name) => {
         const re = new RegExp(`^export interface ${name}(?:[\n\r\t ]|extends)`);
@@ -171,16 +182,8 @@ export function generateInterfaces(interfaceName, newFields, baseResource, baseF
                 if (typeName && !isFhirType(typeName) && !isPrimitiveType(typeName)) {
                     // We don't have baseFld yet, so get it from the base fields
                     const baseFldForProfile = baseFields.find(bf => bf.name === field.name);
-                    // If this is an extension field (field name ends with .extension or .modifierExtension,
-                    // or contains extension: slice notation), use Extension as the base type 
-                    // so fallback aliases are compatible with extension arrays
-                    const fieldNameLower = field.name.toLowerCase();
-                    const isExtensionField = fieldNameLower.endsWith('.extension') ||
-                        fieldNameLower.endsWith('.modifierextension') ||
-                        fieldNameLower.includes('extension:') ||
-                        fieldNameLower.includes('modifierextension:');
-                    const baseTypeName = isExtensionField ? 'Extension' : (baseFldForProfile?.type || field.type);
-                    const baseIsFhir = isExtensionField || (baseTypeName ? isFhirType(baseTypeName) : false);
+                    // Use helper to determine base type - extension fields get 'Extension' as base type
+                    const { baseTypeName, baseIsFhir } = getBaseTypeForField(field.name, baseFldForProfile?.type || field.type);
                     addTypeImport(typeName, profileUrl, baseTypeName, baseIsFhir);
                 }
             }
@@ -917,8 +920,8 @@ export function generateInterfaces(interfaceName, newFields, baseResource, baseF
                 const line = `${fieldName}${field.isOptional ? '?' : ''}: ${resolvedType}${isArrayFinal ? '[]' : ''};`;
                 if (field.isProfiled && field.profileUrls?.[0] && field.type && !isPrimitiveType(field.type) && !isFhirType(field.type)) {
                     const profileUrl = field.profileUrls[0];
-                    const baseTypeName = baseFld?.type;
-                    const baseIsFhir = baseTypeName ? isFhirType(baseTypeName) : false;
+                    // Use helper to determine base type - extension fields get 'Extension' as base type
+                    const { baseTypeName, baseIsFhir } = getBaseTypeForField(field.name, baseFld?.type);
                     addTypeImport(field.type, profileUrl, baseTypeName, baseIsFhir);
                 }
                 // Register external profiles for any field with profile URLs, regardless of nesting
@@ -927,8 +930,8 @@ export function generateInterfaces(interfaceName, newFields, baseResource, baseF
                     const profileUrl = field.profileUrls[0];
                     // Strip version suffix from canonical URL before extracting name
                     const strippedUrl = stripVersionFromCanonicalUrl(profileUrl);
-                    const baseTypeName = baseFld?.type;
-                    const baseIsFhir = baseTypeName ? isFhirType(baseTypeName) : false;
+                    // Use helper to determine base type - extension fields get 'Extension' as base type
+                    const { baseTypeName, baseIsFhir } = getBaseTypeForField(field.name, baseFld?.type);
                     // Use profileUrlToName to get the actual interface name, fallback to URL-derived name
                     const typeName = profileUrlToName?.get(strippedUrl) || profileUrlToName?.get(profileUrl) || toPascalCase(sanitizeIdentifier(strippedUrl.split('/').pop() || resolvedType));
                     // Only register if it's not a primitive and not already a FHIR type
@@ -942,8 +945,8 @@ export function generateInterfaces(interfaceName, newFields, baseResource, baseF
                     !isFhirType(resolvedType) &&
                     !localInterfaceNames.has(resolvedType)) {
                     const profileUrl = field.profileUrls?.[0] || (field.type && field.type.includes('http') ? field.type : undefined);
-                    const baseTypeName = baseFld?.type;
-                    const baseIsFhir = baseTypeName ? isFhirType(baseTypeName) : false;
+                    // Use helper to determine base type - extension fields get 'Extension' as base type
+                    const { baseTypeName, baseIsFhir } = getBaseTypeForField(field.name, baseFld?.type);
                     addTypeImport(resolvedType, profileUrl, baseTypeName, baseIsFhir);
                 }
                 if (!isPrimitiveType(resolvedType)) {
@@ -983,8 +986,8 @@ export function generateInterfaces(interfaceName, newFields, baseResource, baseF
                             else {
                                 // Pass profile metadata if available
                                 const profileUrl = field.profileUrls?.[0];
-                                const baseTypeName = baseFld?.type;
-                                const baseIsFhir = baseTypeName ? isFhirType(baseTypeName) : false;
+                                // Use helper to determine base type - extension fields get 'Extension' as base type
+                                const { baseTypeName, baseIsFhir } = getBaseTypeForField(field.name, baseFld?.type);
                                 if (profileUrl || baseTypeName) {
                                     addTypeImport(sanitizeIdentifier(resolvedType), profileUrl, baseTypeName, baseIsFhir);
                                 }