babelfhir-ts 1.6.0 → 1.6.2

package/out/src/generator/core/constants.js

@@ -6,6 +6,7 @@
  * maintenance trivial.
  */
 import { createRequire } from 'module';
+import { stripVersionFromCanonicalUrl } from './utils.js';
 import { fileURLToPath } from 'url';
 import path from 'path';
 const require = createRequire(import.meta.url);
@@ -244,7 +245,7 @@ export const VALUESET_DEFAULTS = {
  */
 export function resolveValueSetDefault(bindingUri) {
     // Strip version suffix: "http://...ValueSet/foo|4.0.1" → "http://...ValueSet/foo"
-    const bare = bindingUri.split('|')[0];
+    const bare = stripVersionFromCanonicalUrl(bindingUri);
     return VALUESET_DEFAULTS[bare];
 }
 export const FALLBACK_CODES = {

package/out/src/generator/core/extensionSdReader.js

@@ -70,6 +70,8 @@ export function collectSubExtensionSlices(els) {
         if (!match)
             continue;
         const sliceName = el.sliceName ?? match[1];
+        if (!sliceName)
+            continue;
         const urlEl = byId.get(`Extension.extension:${sliceName}.url`);
         const url = typeof urlEl?.fixedUri === 'string' ? urlEl.fixedUri : undefined;
         if (!url)

package/out/src/generator/core/utils.js

@@ -28,6 +28,16 @@ export function stripSliceSuffix(path) {
     const colonIndex = path.indexOf(':');
     return colonIndex >= 0 ? path.substring(0, colonIndex) : path;
 }
+/**
+ * The slice name after the colon: `extension:Stadtteil` -> `Stadtteil`.
+ *
+ * Undefined when the segment carries no slice, which is the distinction callers
+ * act on — the counterpart to {@link stripSliceSuffix}, which returns the base.
+ */
+export function sliceSuffix(segment) {
+    const colonIndex = segment.indexOf(':');
+    return colonIndex >= 0 ? segment.substring(colonIndex + 1) : undefined;
+}
 /**
  * The first dot-separated segment of a path: `code.coding.system` -> `code`.
  *
@@ -123,7 +133,9 @@ export function getResourceTypes(options) {
         const exportRegex = /export\s+(?:\*|{[^}]+})\s+from\s+['"]\.\/([\w-]+)\.js['"]/g;
         let match;
         while ((match = exportRegex.exec(indexContent)) !== null) {
-            exportedTypes.add(match[1]);
+            const moduleName = match[1];
+            if (moduleName)
+                exportedTypes.add(moduleName);
         }
     }
     for (const file of files) {
@@ -136,9 +148,9 @@ export function getResourceTypes(options) {
                 if (actualFile) {
                     const content = fs.readFileSync(actualFile, "utf-8");
                     // Check if it has resourceType property (base resource)
-                    const resourceTypeMatch = content.match(/resourceType:\s*["'](\w+)["']/);
-                    if (resourceTypeMatch) {
-                        resourceTypes.set(profileName, resourceTypeMatch[1]);
+                    const declaredResourceType = content.match(/resourceType:\s*["'](\w+)["']/)?.[1];
+                    if (declaredResourceType) {
+                        resourceTypes.set(profileName, declaredResourceType);
                         continue;
                     }
                     // Check if it extends a FHIR resource (handles both `extends Foo` and `extends Omit<Foo, ...>`)
@@ -163,15 +175,16 @@ export function getBaseResourceType(profileName, outputDir) {
     }
     const content = fs.readFileSync(actualFile, "utf-8");
     // Check for explicit resourceType property
-    const resourceTypeMatch = content.match(/resourceType:\s*["'](\w+)["']/);
-    if (resourceTypeMatch) {
-        return resourceTypeMatch[1];
+    const declaredResourceType = content.match(/resourceType:\s*["'](\w+)["']/)?.[1];
+    if (declaredResourceType) {
+        return declaredResourceType;
     }
     // Check for extends clause (handles both `extends Foo` and `extends Omit<Foo, ...>`)
     const baseTypes = extractBaseTypes(content);
-    if (baseTypes.length > 0) {
+    const [firstBase] = baseTypes;
+    if (firstBase) {
         // Prefer a known resource type, fall back to the first candidate
-        return baseTypes.find(bt => ctx().resourceNames.includes(bt)) ?? baseTypes[0];
+        return baseTypes.find(bt => ctx().resourceNames.includes(bt)) ?? firstBase;
     }
     return profileName; // fallback
 }

package/out/src/generator/emitters/class/classGenerator.js

@@ -1,4 +1,5 @@
 import { ctx } from '../../fhir/versionContext.js';
+import { stripVersionFromCanonicalUrl } from '../../core/utils.js';
 import { TS, } from '../../core/constants.js';
 import { primitivePlaceholder, generateCodeDefault, makeCodeableConcept, chooseChoiceVariant, applyRequiredFieldHeuristic, deriveIdentifierConfig, } from './classHeuristics.js';
 import { generateSliceElement, buildNestedRequirementsObject } from './sliceElementGenerator.js';
@@ -187,7 +188,11 @@ export function generateClass(className, interfaceName, baseResource, requiredFi
                 .filter((s) => typeof s === 'string' && s.length > 0);
             const uniqueSystems = Array.from(new Set(systems));
             const singleSystem = uniqueSystems.length === 1 ? JSON.stringify(uniqueSystems[0]) : undefined;
+            // bindingCodes is non-empty per the guard above, but indexing does not say
+            // so; without a code there is no skeleton value to emit.
             const primary = rf.bindingCodes[0];
+            if (!primary)
+                continue;
             if (rf.type === 'CodeableConcept') {
                 const expr = singleSystem
                     ? `skeletonCodeableConcept(${singleSystem}, ${codesArray})`
@@ -349,8 +354,8 @@ export function generateClass(className, interfaceName, baseResource, requiredFi
                     }
                 }
                 // Check profile URLs for known coding profiles
-                if (slice.profileUrls && slice.profileUrls.length > 0) {
-                    const profileUrl = slice.profileUrls[0];
+                const profileUrl = slice.profileUrls?.[0];
+                if (profileUrl) {
                     const profileUrlLower = profileUrl.toLowerCase();
                     // ISiK SNOMED-CT coding profile
                     if (profileUrlLower.includes('snomedctcoding') || profileUrlLower.includes('snomed')) {
@@ -376,7 +381,7 @@ export function generateClass(className, interfaceName, baseResource, requiredFi
                 // code from a different context and should be deferred to runtime resolution.
                 const sliceHasOwnBinding = !!(slice.binding?.uri && slice.binding.uri.length > 0);
                 const sliceBindingMatchesParent = !rf.bindingUri ||
-                    (sliceHasOwnBinding && slice.binding.uri.split('|')[0] === rf.bindingUri.split('|')[0]);
+                    (sliceHasOwnBinding && stripVersionFromCanonicalUrl(slice.binding.uri) === stripVersionFromCanonicalUrl(rf.bindingUri));
                 if (sliceBindingMatchesParent && slice.binding?.sampleCode) {
                     if (slice.binding.sampleCode.system) {
                         system = slice.binding.sampleCode.system;
@@ -384,7 +389,7 @@ export function generateClass(className, interfaceName, baseResource, requiredFi
                     code = JSON.stringify(slice.binding.sampleCode.code);
                     codeResolved = true;
                 }
-                else if (sliceBindingMatchesParent && slice.binding?.codes && slice.binding.codes.length > 0) {
+                else if (sliceBindingMatchesParent && slice.binding?.codes?.[0]) {
                     // Fallback to first code from the binding's codes array
                     const firstCode = slice.binding.codes[0];
                     if (firstCode.system) {
@@ -458,8 +463,8 @@ export function generateClass(className, interfaceName, baseResource, requiredFi
         // Handle CodeableConcept with pattern constraint - use the pattern instead of skeleton
         if (rf.type === 'CodeableConcept' && rf.patternConstraint && typeof rf.patternConstraint === 'object') {
             const pc = rf.patternConstraint;
-            if (pc.coding && Array.isArray(pc.coding) && pc.coding.length > 0) {
-                const firstCoding = pc.coding[0];
+            const firstCoding = Array.isArray(pc.coding) ? pc.coding[0] : undefined;
+            if (firstCoding) {
                 const systemStr = JSON.stringify(firstCoding.system || TS.NULL_FLAVOR);
                 const codeStr = JSON.stringify(firstCoding.code || 'UNK');
                 const displayStr = firstCoding.display ? `, ${JSON.stringify(firstCoding.display)}` : '';
@@ -522,8 +527,9 @@ export function generateClass(className, interfaceName, baseResource, requiredFi
         }
         // Complex type skeletons (also check baseType for profiled types like CodeableConcept-uv-ips)
         const skeletonType = COMPLEX_SKELETON_MAP[rf.type] ? rf.type : (rf.baseType && COMPLEX_SKELETON_MAP[rf.baseType] ? rf.baseType : undefined);
-        if (skeletonType) {
-            const expr = COMPLEX_SKELETON_MAP[skeletonType];
+        const skeletonExpr = skeletonType ? COMPLEX_SKELETON_MAP[skeletonType] : undefined;
+        if (skeletonType && skeletonExpr) {
+            const expr = skeletonExpr;
             const initExpr = buildValueExpression(rf, expr);
             requiredInits.push(`${propKey(rf.name)}: ${initExpr}`);
             continue;

package/out/src/generator/emitters/class/classGeneratorHelpers.js

@@ -61,15 +61,14 @@ export function buildValueExpression(rf, expr, opts) {
 export function buildCrossReferencedEntryArray(sliceElements) {
     const compositionIdx = [];
     const resourceEntries = [];
-    for (let i = 0; i < sliceElements.length; i++) {
-        const expr = sliceElements[i];
+    for (const [i, expr] of sliceElements.entries()) {
         if (/resourceType:\s*'Composition'/.test(expr)) {
             compositionIdx.push(i);
         }
         else {
-            const m = expr.match(/resourceType:\s*'(\w+)'/);
-            if (m)
-                resourceEntries.push({ idx: i, type: m[1] });
+            const type = expr.match(/resourceType:\s*'(\w+)'/)?.[1];
+            if (type)
+                resourceEntries.push({ idx: i, type });
         }
     }
     if (compositionIdx.length === 0 || resourceEntries.length === 0)
@@ -79,10 +78,16 @@ export function buildCrossReferencedEntryArray(sliceElements) {
     for (const { idx, type } of resourceEntries) {
         const varName = `_${type.charAt(0).toLowerCase() + type.slice(1)}Url`;
         decls.push(`const ${varName} = 'urn:uuid:' + crypto.randomUUID();`);
-        rewritten[idx] = rewritten[idx].replace(/fullUrl:\s*'urn:uuid:'\s*\+\s*crypto\.randomUUID\(\)/, `fullUrl: ${varName}`);
+        const entry = rewritten[idx];
+        if (entry !== undefined) {
+            rewritten[idx] = entry.replace(/fullUrl:\s*'urn:uuid:'\s*\+\s*crypto\.randomUUID\(\)/, `fullUrl: ${varName}`);
+        }
         for (const ci of compositionIdx) {
             const refPattern = new RegExp(`reference:\\s*'${type}/\\s*'\\s*\\+\\s*randomId\\(\\)`);
-            rewritten[ci] = rewritten[ci].replace(refPattern, `reference: ${varName}`);
+            const composition = rewritten[ci];
+            if (composition !== undefined) {
+                rewritten[ci] = composition.replace(refPattern, `reference: ${varName}`);
+            }
         }
     }
     return `(() => { ${decls.join(' ')} return [${rewritten.join(', ')}]; })()`;

package/out/src/generator/emitters/class/classHeuristics.js

@@ -91,6 +91,8 @@ export function chooseChoiceVariant(rf) {
         return null;
     }
     let chosen = options[0];
+    if (chosen === undefined)
+        return null;
     if (lowerBase === 'value' && preferCodeableConcept) {
         chosen = 'CodeableConcept';
     }
@@ -210,8 +212,8 @@ export function applyRequiredFieldHeuristic(rf, ctx) {
                 return { expr: makeCoding(system, picked.code), isObjectLiteral: true };
             }
         }
-        if (isCodeableConcept) {
-            const first = rf.bindingCodes[0];
+        const [first] = rf.bindingCodes;
+        if (isCodeableConcept && first) {
             const system = first.system || TS.SNOMED;
             return { expr: `skeletonCodeableConcept('${system}', ['${first.code}'])` };
         }

package/out/src/generator/emitters/class/fieldPatternExtractor.js

@@ -1,4 +1,5 @@
 import { fetchStructureDefinition } from '../../parser/sdParser.js';
+import { stripSliceSuffix, sliceSuffix } from '../../core/utils.js';
 export async function extractFieldPatternsAndMetadata(patternSources, baseResource, sd, requiredFields, candidateRequiredFields, nestedRequirementsMap, resolvedProfilePatterns) {
     const patternMap = new Map();
     for (const src of patternSources) {
@@ -7,7 +8,7 @@ export async function extractFieldPatternsAndMetadata(patternSources, baseResour
                 continue;
             // Extract the field path parts
             const parts = f.name.split('.');
-            const lastPart = (parts.pop() || f.name).split(':')[0]; // base field name without slice
+            const lastPart = stripSliceSuffix(parts.pop() ?? f.name); // base field name without slice
             // For patterns on '.coding' elements, associate with the parent CodeableConcept field
             // e.g., for "Coverage.type.coding:VersicherungsArtDeBasis", use "type" as key
             let key = lastPart;
@@ -15,7 +16,7 @@ export async function extractFieldPatternsAndMetadata(patternSources, baseResour
                 // This is a coding inside a CodeableConcept - use the parent field name
                 const parentPart = parts.pop();
                 if (parentPart) {
-                    key = parentPart.split(':')[0];
+                    key = stripSliceSuffix(parentPart);
                 }
             }
             // For nested fields (children of children, e.g., identifier.type vs top-level type),
@@ -28,8 +29,9 @@ export async function extractFieldPatternsAndMetadata(patternSources, baseResour
                     idParts.shift(); // remove resource type prefix
                     const nestedParts = [];
                     for (const part of idParts) {
-                        if (part.includes(':')) {
-                            nestedParts.push(part.split(':')[1]); // use slice name
+                        const partSliceName = sliceSuffix(part);
+                        if (partSliceName !== undefined) {
+                            nestedParts.push(partSliceName); // use slice name
                         }
                         else if (!part.includes('[x]')) {
                             nestedParts.push(part);
@@ -204,9 +206,10 @@ export async function extractFieldPatternsAndMetadata(patternSources, baseResour
                     // e.g., "value[x]:valueQuantity.unit" -> "valueQuantity.unit"
                     const nestedParts = [];
                     for (const part of idParts) {
-                        if (part.includes(':')) {
-                            // Extract slice name (e.g., "value[x]:valueQuantity" -> "valueQuantity")
-                            nestedParts.push(part.split(':')[1]);
+                        // Slice name, e.g. "value[x]:valueQuantity" -> "valueQuantity"
+                        const partSliceName = sliceSuffix(part);
+                        if (partSliceName !== undefined) {
+                            nestedParts.push(partSliceName);
                         }
                         else if (!part.includes('[x]')) {
                             nestedParts.push(part);
@@ -235,8 +238,9 @@ export async function extractFieldPatternsAndMetadata(patternSources, baseResour
                     // Build nested key, extracting slice names where present
                     const nestedParts = [];
                     for (const part of idParts) {
-                        if (part.includes(':')) {
-                            nestedParts.push(part.split(':')[1]);
+                        const partSliceName = sliceSuffix(part);
+                        if (partSliceName !== undefined) {
+                            nestedParts.push(partSliceName);
                         }
                         else if (!part.includes('[x]')) {
                             nestedParts.push(part);
@@ -252,7 +256,7 @@ export async function extractFieldPatternsAndMetadata(patternSources, baseResour
                 }
             }
             // 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) {
+            else if (!patternMap.has(key) && f.sliceName && f.binding?.codes?.[0]) {
                 // Create a CodeableConcept pattern from the first binding code
                 const firstCode = f.binding.codes[0];
                 const synthesizedPattern = {
@@ -363,9 +367,9 @@ export async function extractFieldPatternsAndMetadata(patternSources, baseResour
                     const [basePart, sliceName] = p.split(':', 2);
                     // For choice types (e.g., value[x]:valueQuantity), use the slice name
                     // as the actual JS property name
-                    if (basePart.includes('[x]') && sliceName)
+                    if (basePart?.includes('[x]') && sliceName)
                         return sliceName;
-                    return basePart; // strip slice qualifier for non-choice types
+                    return basePart ?? p; // strip slice qualifier for non-choice types
                 }
                 return p;
             });
@@ -413,7 +417,7 @@ export async function extractFieldPatternsAndMetadata(patternSources, baseResour
         const parts = elemId.split('.');
         if (parts.length !== 2)
             continue;
-        const fieldName = (parts[1] || '').split(':')[0]; // Strip slice names
+        const fieldName = stripSliceSuffix(parts[1] || '');
         if (fieldName && !seenFieldNames.has(fieldName)) {
             seenFieldNames.add(fieldName);
             fieldOrder.push(fieldName);

package/out/src/generator/emitters/class/sliceElementDefaults.js

@@ -399,11 +399,17 @@ export function getTypePlaceholder(fhirType) {
             return '"https://babelfhir.dev"';
         case 'code':
             return '"code"';
+        // Dates are emitted as a call, not a value. This function returns code that
+        // lands in a generated class, so interpolating new Date() here froze the
+        // generation-time wall clock into the source: every regeneration produced a
+        // different file, and every consumer got the same instant forever. The
+        // sibling getDefaultValueForType already defers to randomDate() through its
+        // __DATE_EXPR__ placeholder; this now agrees with it.
         case 'dateTime':
         case 'instant':
-            return '"' + new Date().toISOString() + '"';
+            return 'randomDate()';
         case 'date':
-            return '"' + new Date().toISOString().split('T')[0] + '"';
+            return 'randomDate().slice(0, 10)';
         case 'time':
             return '"12:00:00"';
         case 'Reference':
@@ -423,7 +429,7 @@ export function getTypePlaceholder(fhirType) {
         case 'ContactPoint':
             return '{ system: "phone", value: "555-1234" }';
         case 'Period':
-            return '{ start: "' + new Date().toISOString() + '" }';
+            return '{ start: randomDate() }';
         case 'Attachment':
             return '{ contentType: "text/plain" }';
         case 'Narrative':
@@ -447,9 +453,9 @@ export function getTypePlaceholder(fhirType) {
         case 'Annotation':
             return '{ text: "Note" }';
         case 'Signature':
-            return `{ type: [{ system: "urn:iso-astm:E1762-95:2013", code: "1.2.840.10065.1.12.1.1" }], when: "${new Date().toISOString()}", who: { reference: "Practitioner/example" } }`;
+            return `{ type: [{ system: "urn:iso-astm:E1762-95:2013", code: "1.2.840.10065.1.12.1.1" }], when: randomDate(), who: { reference: "Practitioner/example" } }`;
         case 'Meta':
-            return '{ lastUpdated: "' + new Date().toISOString() + '" }';
+            return '{ lastUpdated: randomDate() }';
         case 'ContactDetail':
             return '{ name: "Contact" }';
         case 'UsageContext':

package/out/src/generator/emitters/class/sliceElementGenerator.js

@@ -102,8 +102,8 @@ export function generateSliceElement(slice, elementType) {
             // Detect already-resolved choice type variants
             if (!wasResolvedFromChoiceNotation) {
                 const choiceMatch = childPath.match(/^([a-z]+)(Boolean|Integer|Decimal|DateTime|Date|Time|Instant|String|Uri|Url|Canonical|Base64Binary|Code|Oid|Id|Uuid|Markdown|UnsignedInt|PositiveInt|Coding|CodeableConcept|Quantity|Range|Period|Ratio|SampledData|Attachment|Duration|Distance|Count|Money|Age|Annotation|Signature|HumanName|Address|ContactPoint|Timing|Reference|Identifier|Meta|Dosage|Narrative|Expression|TriggerDefinition|DataRequirement|ParameterDefinition|RelatedArtifact|ContactDetail|UsageContext)$/);
-                if (choiceMatch) {
-                    const baseName = choiceMatch[1];
+                const baseName = choiceMatch?.[1];
+                if (baseName) {
                     if (resolvedChoiceBases.has(baseName)) {
                         continue;
                     }
@@ -169,7 +169,7 @@ export function generateSliceElement(slice, elementType) {
                     else if (profileUrl) {
                         const profileName = profileUrl.split('/').pop() || '';
                         if (profileName.includes('-')) {
-                            resourceType = capitalise(profileName.split('-')[0]);
+                            resourceType = capitalise(profileName.split('-')[0] ?? profileName);
                         }
                         else {
                             resourceType = capitalise(profileName);

package/out/src/generator/emitters/interface/backboneSliceTyping.js

@@ -18,7 +18,7 @@
  * }
  * ```
  */
-import { capitalize, choicePropertyName, narrowedChoiceType, sanitizeIdentifier } from '../../core/utils.js';
+import { capitalize, choicePropertyName, narrowedChoiceType, sanitizeIdentifier, firstSegment } from '../../core/utils.js';
 import { getRules } from '../../fhir/versionContext.js';
 import { logger } from '../../../logger.js';
 const log = logger.withTag('backbone-slices');
@@ -35,7 +35,11 @@ export function generateBackboneSliceTypes(ctx) {
         return;
     for (const group of sliceGroups) {
         const { parentField, sliceFields, childFields, slicingRules } = group;
-        const fieldName = parentField.name.split('.').pop();
+        const fieldName = parentField.name.split('.').at(-1);
+        // A grouped parent always has a dotted path, so this is unreachable; skipping
+        // is right if it ever is not, and it replaces a non-null assertion.
+        if (!fieldName)
+            continue;
         // Determine the base backbone type for this field
         let backboneType = inferBackboneType(baseResource, fieldName);
         if (!backboneType) {
@@ -100,8 +104,9 @@ export function generateBackboneSliceTypes(ctx) {
         if (isOpen) {
             unionMembers.push(backboneType);
         }
-        const unionType = unionMembers.length === 1
-            ? `${unionMembers[0]}[]`
+        const [soleMember] = unionMembers;
+        const unionType = unionMembers.length === 1 && soleMember
+            ? `${soleMember}[]`
             : `(${unionMembers.join(' | ')})[]`;
         // Find and update the field in the root interface
         updateRootInterfaceField(interfaces, interfaceName, fieldName, parentField.isOptional, unionType, baseResource);
@@ -181,7 +186,7 @@ function isEligibleBackbonePath(baseType, path, baseResource) {
     const parts = path.split('.');
     if (parts.length !== 2)
         return false;
-    if (baseResource && parts[0] !== baseResource)
+    if (baseResource && firstSegment(path) !== baseResource)
         return false;
     return true;
 }
@@ -224,9 +229,10 @@ function buildSliceInterfaceBody(sliceField, sliceChildren, sliceElementId, _bac
         const childId = child.elementId || child.name;
         const relativePath = childId.substring(sliceElementId.length + 1);
         const match = choiceSlicePattern.exec(relativePath);
-        if (match) {
+        const choiceParent = match?.[1]; // e.g. "value[x]"
+        if (choiceParent) {
             choiceTypeSlices.push(child);
-            choiceTypeParents.add(match[1]); // e.g. "value[x]"
+            choiceTypeParents.add(choiceParent);
         }
     }
     // Collect deeply nested fixed values for object literal synthesis.
@@ -240,7 +246,9 @@ function buildSliceInterfaceBody(sliceField, sliceChildren, sliceElementId, _bac
         if (relativePath.includes('.')) {
             if (child.fixedValue !== undefined) {
                 const segments = relativePath.split('.');
-                const rawPropName = segments[0];
+                // firstSegment is segments[0] without the possibly-undefined read; segments
+                // is still needed for the tail below.
+                const rawPropName = firstSegment(relativePath);
                 const propName = rawPropName.replace(/\[x\]$/, '');
                 // Skip nested values under:
                 // - choice-type elements ([x]) — handled by direct child or sub-slices
@@ -425,8 +433,8 @@ function updateRootInterfaceField(interfaces, interfaceName, fieldName, isOption
     const newFieldLine = `    ${fieldName}${optMark}: ${unionType};`;
     // Try to find an existing interface declaration
     const rootIdx = interfaces.findIndex(i => i.startsWith(`export interface ${interfaceName} `) || i.startsWith(`export interface ${interfaceName}<`));
-    if (rootIdx >= 0) {
-        const iface = interfaces[rootIdx];
+    const iface = rootIdx >= 0 ? interfaces[rootIdx] : undefined;
+    if (iface !== undefined) {
         const fieldPattern = new RegExp(`^(\\s+)${fieldName}[?]?:\\s*.+;`, 'm');
         if (fieldPattern.test(iface)) {
             // Replace existing field line
@@ -443,10 +451,10 @@ function updateRootInterfaceField(interfaces, interfaceName, fieldName, isOption
     }
     // Try to find a type alias (e.g., "export type BloodPressure = Observation;")
     const aliasIdx = interfaces.findIndex(i => i.startsWith(`export type ${interfaceName} =`));
-    if (aliasIdx >= 0) {
+    const alias = aliasIdx >= 0 ? interfaces[aliasIdx] : undefined;
+    if (alias !== undefined) {
         // Convert type alias to interface with the field
-        const aliasMatch = interfaces[aliasIdx].match(/export type \S+ = (\S+);/);
-        const baseType = aliasMatch ? aliasMatch[1] : baseResource || '';
+        const baseType = alias.match(/export type \S+ = (\S+);/)?.[1] ?? baseResource ?? '';
         interfaces[aliasIdx] = `export interface ${interfaceName} extends ${baseType} {\n${newFieldLine}\n}`;
     }
 }

package/out/src/generator/emitters/interface/importManager.js

@@ -263,7 +263,7 @@ export class ImportManager {
         const allFhirTypes = [];
         let match;
         while ((match = fhirImportRegex.exec(output)) !== null) {
-            const types = match[1].split(',').map(t => t.trim()).filter(Boolean);
+            const types = (match[1] ?? '').split(',').map(t => t.trim()).filter(Boolean);
             allFhirTypes.push(...types);
         }
         if (allFhirTypes.length === 0) {

package/out/src/generator/emitters/interface/interfaceGenerator.js

@@ -61,7 +61,9 @@ export function generateInterfaces(interfaceName, newFields, baseResource, baseF
     const baseFieldAnyArray = new Map();
     for (const bf of baseFields) {
         const parts = bf.name.split('.');
-        const seg = parts[parts.length - 1];
+        const seg = parts.at(-1);
+        if (!seg)
+            continue;
         if (!baseFieldByLastSegment.has(seg))
             baseFieldByLastSegment.set(seg, bf);
         // Track the widest array flag across direct children only (not nested duplicates)
@@ -83,10 +85,11 @@ export function generateInterfaces(interfaceName, newFields, baseResource, baseF
                 f.sliceName &&
                 f.binding?.uri);
             // Use the first slice binding if available (slices typically have more specific constraints)
-            if (slicesForThisField.length > 0 && slicesForThisField[0].binding) {
-                binding = slicesForThisField[0].binding;
+            const firstSlice = slicesForThisField[0];
+            if (firstSlice?.binding) {
+                binding = firstSlice.binding;
                 isSlicedField = true;
-                debug(`Using binding from slice ${slicesForThisField[0].sliceName} for ${field.name}`);
+                debug(`Using binding from slice ${firstSlice.sliceName} for ${field.name}`);
             }
         }
         if (!binding) {
@@ -196,6 +199,8 @@ export function generateInterfaces(interfaceName, newFields, baseResource, baseF
     // This must run after all interfaces + extension unions are assembled.
     for (let i = 0; i < interfaces.length; i++) {
         const iface = interfaces[i];
+        if (!iface)
+            continue;
         // Match "export interface Foo extends Bar {" or "export interface Foo extends Omit<Bar, ...> {"
         const extendsMatch = iface.match(/^export interface (\S+) extends (Omit<)?(\S+?)([,>])? \{/);
         if (!extendsMatch)
@@ -203,16 +208,16 @@ export function generateInterfaces(interfaceName, newFields, baseResource, baseF
         const alreadyOmit = !!extendsMatch[2];
         const baseType = extendsMatch[3];
         // Only wrap FHIR base types (not local profile interfaces)
-        if (!isFhirType(baseType))
+        if (!baseType || !isFhirType(baseType))
             continue;
         // Extract all declared property names from the interface body
         const bodyStart = iface.indexOf('{');
         const body = iface.slice(bodyStart + 1);
         const propNames = [];
         for (const line of body.split('\n')) {
-            const m = line.match(/^\s+(\w+)[?:]/);
-            if (m && m[1] !== 'resourceType')
-                propNames.push(m[1]);
+            const propName = line.match(/^\s+(\w+)[?:]/)?.[1];
+            if (propName && propName !== 'resourceType')
+                propNames.push(propName);
         }
         if (propNames.length === 0)
             continue;
@@ -266,7 +271,7 @@ export function generateInterfaces(interfaceName, newFields, baseResource, baseF
         logger.debug('[DEBUG FINAL INTERFACES]', {
             interfaceName,
             interfaceCount: interfaces.length,
-            interfaceNames: interfaces.map(i => i.split('\n')[0]).filter(n => n.includes('ConditionDeBasis02'))
+            interfaceNames: interfaces.map(i => i.split('\n')[0] ?? '').filter(n => n.includes('ConditionDeBasis02'))
         });
     }
     return {

package/out/src/generator/emitters/interface/postProcessExtensions.js

@@ -122,18 +122,22 @@ export function postProcessExtensions(params) {
             }
             idx = findInterfaceIndex(name);
         }
-        if (idx >= 0 && !interfaces[idx].includes(line.trim())) {
+        // Hoisted once: the block below reads the same entry five times, and
+        // indexing it each time reads as possibly-undefined even after the bound
+        // check. Reads go through `target`, writes still go to interfaces[idx].
+        const target = idx >= 0 ? interfaces[idx] : undefined;
+        if (target !== undefined && !target.includes(line.trim())) {
             // Also check if a property with the same name already exists to avoid duplicates
-            const propName = line.trim().split(/[?:]/)[0].trim();
+            const propName = (line.trim().split(/[?:]/)[0] ?? '').trim();
             const propPattern = new RegExp(`^\\s*${propName}[?:]`, 'm');
-            if (interfaces[idx].match(propPattern)) {
+            if (target.match(propPattern)) {
                 // For extension properties, REPLACE the existing declaration with the new union
                 // This handles both union `(Extension | Type)[]` and plain `Type[]` formats
                 if (propName === 'extension' && line.includes('extension?:')) {
                     const existingExtPattern = /\s*extension\?\s*:\s*[^;\n]+;/;
-                    if (existingExtPattern.test(interfaces[idx])) {
+                    if (existingExtPattern.test(target)) {
                         const newExtLine = line.trim();
-                        interfaces[idx] = interfaces[idx].replace(existingExtPattern, `\n    ${newExtLine}`);
+                        interfaces[idx] = target.replace(existingExtPattern, `\n    ${newExtLine}`);
                         logger.debug('[DEBUG replaced extension property]', { propName, line: newExtLine });
                         return;
                     }
@@ -142,9 +146,9 @@ export function postProcessExtensions(params) {
                 return;
             }
             if (name === 'USCoreQuestionnaireResponseProfileItem' && line.includes('answer')) {
-                logger.debug('[DEBUG appendToInterface Item answer]', { name, line, currentInterface: interfaces[idx] });
+                logger.debug('[DEBUG appendToInterface Item answer]', { name, line, currentInterface: target });
             }
-            interfaces[idx] = interfaces[idx].replace(/}\s*$/, `\n    ${line}\n}`);
+            interfaces[idx] = target.replace(/}\s*$/, `\n    ${line}\n}`);
         }
     };
     // Ensure root interface exists and track its name
@@ -174,7 +178,9 @@ export function postProcessExtensions(params) {
             continue;
         }
         if (segs.length === 1) {
-            const seg = segs[0].replace(/\[x\]/g, '');
+            const seg = (segs[0] ?? '').replace(/\[x\]/g, '');
+            if (!seg)
+                continue;
             const nestedName = `${rootName}${capitalize(seg)}`;
             // Create alias types and union
             const aliases = [];
@@ -204,8 +210,9 @@ export function postProcessExtensions(params) {
                 const optionalLine = `_${seg}?: ${elementIface};`;
                 // Replace any required with optional first
                 const idx = findInterfaceIndex(rootName);
-                if (idx >= 0) {
-                    interfaces[idx] = interfaces[idx].replace(requiredLine, optionalLine);
+                const existing = idx >= 0 ? interfaces[idx] : undefined;
+                if (existing !== undefined) {
+                    interfaces[idx] = existing.replace(requiredLine, optionalLine);
                 }
                 appendToInterface(rootName, `_${seg}${opt}: ${elementIface};`);
             }
@@ -265,6 +272,8 @@ export function postProcessExtensions(params) {
         }
         else if (segs.length === 2) {
             const [seg1Raw, seg2Raw] = segs;
+            if (!seg1Raw || !seg2Raw)
+                continue;
             const seg1 = seg1Raw.replace(/\[x\]/g, '');
             const seg2 = seg2Raw.replace(/\[x\]/g, '');
             // Ensure first-level container exists
@@ -389,14 +398,15 @@ export function safetyNetRootExtensions(params) {
         importManager.addFhirType('Extension');
         const union = ['Extension', ...aliases].join(' | ');
         const idx = findInterfaceIndex(interfaceName);
-        if (idx >= 0) {
+        const target = idx >= 0 ? interfaces[idx] : undefined;
+        if (target !== undefined) {
             // Replace any existing extension property (union or plain type) with the new union
             const existingExtPattern = /\s*extension\?\s*:\s*[^;\n]+;/;
-            if (existingExtPattern.test(interfaces[idx])) {
-                interfaces[idx] = interfaces[idx].replace(existingExtPattern, `\n    extension?: (${union})[];`);
+            if (existingExtPattern.test(target)) {
+                interfaces[idx] = target.replace(existingExtPattern, `\n    extension?: (${union})[];`);
             }
             else {
-                interfaces[idx] = interfaces[idx].replace(/}\s*$/, `\n    extension?: (${union})[];\n}`);
+                interfaces[idx] = target.replace(/}\s*$/, `\n    extension?: (${union})[];\n}`);
             }
         }
     }