babelfhir-ts 1.5.20 → 1.6.0

package/README.md

@@ -61,9 +61,9 @@ Every push to `develop` and `main` runs the parity pipeline, which validates gen
 4. Generates `empty()` and `random()` test resources for every profile
 5. Validates those resources against two independent external FHIR validators
 
-### Validated Implementation Guides (30)
+### Validated Implementation Guides (31)
 
-Every parity run validates **30 real-world IGs** (28 R4, 2 R5). The list is not duplicated here — it is generated from the parity suite's own source of truth into [`parity-matrix.json`](./parity-matrix.json).
+Every parity run validates **31 real-world IGs** (29 R4, 2 R5). The list is not duplicated here — it is generated from the parity suite's own source of truth into [`parity-matrix.json`](./parity-matrix.json).
 
 Each validated IG is also published as a ready-to-install package — `@max-health-inc/fhir-<name>` — so you do not have to generate it yourself:
 
@@ -111,6 +111,7 @@ The `firely` job validates generated resources using the [Firely SDK Validator](
 ![AU Core (Australia)](https://img.shields.io/endpoint?url=https://max-health-inc.github.io/BabelFHIR-TS/badges/badge-au-core.json)
 ![PIXm](https://img.shields.io/endpoint?url=https://max-health-inc.github.io/BabelFHIR-TS/badges/badge-pixm.json)
 ![MHD](https://img.shields.io/endpoint?url=https://max-health-inc.github.io/BabelFHIR-TS/badges/badge-mhd.json)
+![vitals](https://img.shields.io/endpoint?url=https://max-health-inc.github.io/BabelFHIR-TS/badges/badge-vitals.json)
 
 </details>
 
@@ -148,10 +149,11 @@ The `hl7` job validates the same artifacts using the [official HL7 FHIR Validato
 ![AU Core (Australia)](https://img.shields.io/endpoint?url=https://max-health-inc.github.io/BabelFHIR-TS/badges/badge-hl7-au-core.json)
 ![PIXm](https://img.shields.io/endpoint?url=https://max-health-inc.github.io/BabelFHIR-TS/badges/badge-hl7-pixm.json)
 ![MHD](https://img.shields.io/endpoint?url=https://max-health-inc.github.io/BabelFHIR-TS/badges/badge-hl7-mhd.json)
+![vitals](https://img.shields.io/endpoint?url=https://max-health-inc.github.io/BabelFHIR-TS/badges/badge-hl7-vitals.json)
 
 </details>
 
-> External-validator badges cover the 28 R4/R4B IGs. R5 packages are generated and typechecked, but neither external validator publishes R5 badges yet.
+> External-validator badges cover the 29 R4/R4B IGs. R5 packages are generated and typechecked, but neither external validator publishes R5 badges yet.
 
 > Terminology validation requires a tx server. The pipeline uses `--tx-server https://tx.fhir.org/{r4|r5}` (matching the package's FHIR version) during generation to expand ValueSets and produce valid codes.
 
@@ -223,6 +225,7 @@ Options:
   --no-classes             Only generate interfaces and types (skip class generation)
   --no-client              Skip FHIR client generation (client generated by default)
   --schema <format>        Generate schema files alongside outputs (supported: zod)
+  --zod-invariants         Emit FHIRPath invariants into Zod schemas (fuller checking, slower parse)
   --dicomweb               Generate DICOMweb helpers typed to ImagingStudy profiles in the IG
   --prefab                 Generate Prefab UI render functions per profile (@maxhealth.tech/prefab)
   --prefab-styles <path>   Path to styles module (.ts/.js) copied into the generated prefab/ folder

package/out/src/cli/updateCommand.js

@@ -114,21 +114,28 @@ async function promptInstallRedirect(packageFilter, confirm) {
         return { redirectInstall: packageFilter };
     return {};
 }
-/** Default Y/N prompt reading from stdin. */
-function defaultConfirm(question) {
-    return new Promise((resolve) => {
-        process.stdout.write(question);
-        const rl = (async () => {
-            const { createInterface } = await import('readline');
-            return createInterface({ input: process.stdin, output: process.stdout });
-        })();
-        rl.then(r => {
-            r.question('', (answer) => {
-                r.close();
+/**
+ * Default Y/N prompt reading from stdin.
+ *
+ * The readline import is awaited rather than `.then`-ed inside a `new Promise`:
+ * that form dropped a rejection on the floor, and since nothing ever called
+ * `resolve`, a failed import left the caller awaiting a promise that could not
+ * settle. Declining is the safe answer when the prompt cannot be shown.
+ */
+async function defaultConfirm(question) {
+    process.stdout.write(question);
+    const { createInterface } = await import('readline');
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        return await new Promise((resolve) => {
+            rl.question('', (answer) => {
                 resolve(!answer || answer.toLowerCase().startsWith('y'));
             });
         });
-    });
+    }
+    finally {
+        rl.close();
+    }
 }
 // ── Discovery ───────────────────────────────────────────────────────────────
 /** Find all lib/ directories starting from startDir. Non-recursive returns only startDir/lib. */

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

@@ -0,0 +1,100 @@
+/**
+ * Reading what an Extension StructureDefinition declares about its own contents.
+ *
+ * A complex extension carries its requirements in its own SD. A profile that
+ * references one re-declares the sub-extension paths as mustSupport markers but
+ * copies none of the constraints, so anything read only from the profile's field
+ * model misses them entirely — KBV_PR_ERP_PracticeSupply's
+ * `extension:Kostentraeger.extension:Kostentraegertyp.value[x]:valueCoding` has no
+ * binding, while KBV_EX_ERP_PracticeSupply_Payor binds it required to
+ * KBV_VS_FOR_Payor_type.
+ */
+import { stripVersionFromCanonicalUrl } from './utils.js';
+/** `Extension.extension:<name>` with no further path below it. */
+const SUB_SLICE_ID = /^Extension\.extension:([^.:]+)$/;
+/**
+ * The elements to read constraints from.
+ *
+ * Prefer the snapshot, but fall back to the differential: several published
+ * extension SDs ship without one (KBV_EX_ERP_PracticeSupply_Payor among them), and
+ * requiring a snapshot meant they resolved to no metadata at all.
+ */
+export function extensionElements(sd) {
+    const els = sd?.snapshot?.element ?? sd?.differential?.element;
+    return els?.length ? els : undefined;
+}
+/** Read a binding off an element, normalising the ValueSet reference to a bare uri. */
+export function readBinding(el) {
+    const binding = el?.binding;
+    if (!binding?.strength || !binding.valueSet)
+        return undefined;
+    const raw = typeof binding.valueSet === 'string'
+        ? binding.valueSet
+        : binding.valueSet?.reference;
+    if (!raw)
+        return undefined;
+    return { strength: binding.strength, uri: stripVersionFromCanonicalUrl(raw) };
+}
+/** Type codes declared on an element. */
+function typeCodes(el) {
+    return (el?.type ?? []).map(t => t.code).filter((c) => !!c);
+}
+/**
+ * `min` on the unsliced `Extension.extension` element.
+ *
+ * This is what HL7 reports as "Extension.extension: minimum required = N", and it is
+ * not the sum of the slice minimums — the SD states it directly.
+ */
+export function readSubExtensionMin(els) {
+    const el = els.find(e => (e.id ?? e.path) === 'Extension.extension' && !e.sliceName);
+    return typeof el?.min === 'number' ? el.min : undefined;
+}
+/**
+ * Collect the sub-extension slices a complex extension declares.
+ *
+ * A slice with no resolvable `url` is dropped rather than reported under its slice
+ * name: the url is how a member is recognised at runtime, and without it any check
+ * would be guessing which member to apply itself to.
+ */
+export function collectSubExtensionSlices(els) {
+    const byId = new Map();
+    for (const el of els) {
+        const id = el.id ?? el.path;
+        if (id)
+            byId.set(id, el);
+    }
+    const out = [];
+    for (const el of els) {
+        const id = el.id ?? el.path;
+        const match = id ? SUB_SLICE_ID.exec(id) : null;
+        if (!match)
+            continue;
+        const sliceName = el.sliceName ?? match[1];
+        const urlEl = byId.get(`Extension.extension:${sliceName}.url`);
+        const url = typeof urlEl?.fixedUri === 'string' ? urlEl.fixedUri : undefined;
+        if (!url)
+            continue;
+        const valueEl = byId.get(`Extension.extension:${sliceName}.value[x]`);
+        let valueTypes = typeCodes(valueEl);
+        let binding = readBinding(valueEl);
+        // The binding usually sits on the typed slice (…value[x]:valueCoding) rather than
+        // on value[x] itself, which is where the Payor extension puts it.
+        for (const code of valueTypes.length ? valueTypes : ['']) {
+            const suffix = code ? code.charAt(0).toUpperCase() + code.slice(1) : '';
+            const typedEl = suffix ? byId.get(`Extension.extension:${sliceName}.value[x]:value${suffix}`) : undefined;
+            if (!typedEl)
+                continue;
+            binding = binding ?? readBinding(typedEl);
+            if (valueTypes.length === 0)
+                valueTypes = typeCodes(typedEl);
+        }
+        out.push({
+            sliceName,
+            url,
+            min: typeof el.min === 'number' ? el.min : 0,
+            valueTypes,
+            binding,
+        });
+    }
+    return out;
+}

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

@@ -14,6 +14,33 @@ export function stripVersionFromCanonicalUrl(url) {
     const pipeIndex = url.indexOf('|');
     return pipeIndex >= 0 ? url.substring(0, pipeIndex) : url;
 }
+/**
+ * An element path with any slice suffix removed: `identifier:NPI` -> `identifier`.
+ *
+ * FHIR element ids name the slice after a colon, and most path comparisons want
+ * the unsliced form. Written with indexOf rather than `split(':')[0]` so it
+ * returns a string: the split form is an indexing expression, which is only
+ * `string | undefined` to the compiler even though it can never be empty.
+ */
+export function stripSliceSuffix(path) {
+    if (!path)
+        return path;
+    const colonIndex = path.indexOf(':');
+    return colonIndex >= 0 ? path.substring(0, colonIndex) : path;
+}
+/**
+ * The first dot-separated segment of a path: `code.coding.system` -> `code`.
+ *
+ * indexOf rather than `split('.')[0]`, for the same reason as
+ * {@link stripSliceSuffix}: the split form is an indexing expression and reads as
+ * possibly-undefined even when it cannot be.
+ */
+export function firstSegment(path) {
+    if (!path)
+        return path;
+    const dotIndex = path.indexOf('.');
+    return dotIndex >= 0 ? path.substring(0, dotIndex) : path;
+}
 export function writeInterfaceAndValidatorToFile(outputDir, interfaceName, interfaceContent, validateFunctionContent) {
     const filePath = path.join(outputDir, `${interfaceName}.ts`);
     const content = `${interfaceContent}\n\n${validateFunctionContent}`;
@@ -181,6 +208,48 @@ export function alignFields(newFields, oldFields) {
     // Return the original oldFields and the aligned newFields
     return { alignedNewFields, oldFields };
 }
+/** A type the parser could not pin down from the element itself. */
+function isUnstatedType(type) {
+    return !type || type === 'any';
+}
+/**
+ * Carry forward what a differential element left unstated.
+ *
+ * A differential says only what it changes, so an element that constrains
+ * cardinality alone carries no `type` and an element that constrains `min` alone
+ * carries no `max`. Both are inherited rather than defaulted away.
+ */
+function inheritUnstatedFromBase(field, base) {
+    if (!base)
+        return field;
+    const merged = { ...field };
+    if (isUnstatedType(merged.type) && !isUnstatedType(base.type)) {
+        merged.type = base.type;
+    }
+    if (!merged.baseTypeCode && base.baseTypeCode) {
+        merged.baseTypeCode = base.baseTypeCode;
+    }
+    // `max` absent means the differential did not narrow the upper bound, so the
+    // base's bound — and with it whether the element repeats — still holds.
+    if (merged.max === undefined && base.max !== undefined) {
+        merged.max = base.max;
+        merged.isArray = base.isArray;
+    }
+    if (!merged.typeOptions?.length && base.typeOptions?.length) {
+        merged.typeOptions = base.typeOptions;
+    }
+    // An extension slice is recognised at runtime by the canonical its profile
+    // names. A derived profile that only tightens cardinality does not restate it —
+    // KBV_PR_ERP_Medication_PZN redeclares extension:Kategorie and extension:Normgroesse
+    // with no type.profile, while KBV_PR_Base_Medication gives them
+    // KBV_EX_Base_Medication_Type and .../normgroesse. Dropping the base's left two
+    // of four slices unidentifiable, so the closed-slicing check on
+    // Medication.extension could not build its allowed set and stayed silent.
+    if (!merged.profileUrls?.length && base.profileUrls?.length) {
+        merged.profileUrls = base.profileUrls;
+    }
+    return merged;
+}
 export function mergeFields(newFields, oldFields) {
     const fieldMap = new Map();
     // Create unique key for field - use elementId if available (includes slice names for child elements)
@@ -208,9 +277,22 @@ export function mergeFields(newFields, oldFields) {
         }
         fieldMap.set(key, field);
     }
-    // Overwrite or add newFields to the map
+    // Overwrite or add newFields to the map.
+    //
+    // A differential element states only what it *changes*. Replacing the base
+    // field wholesale therefore threw away everything it stayed silent about:
+    // KBV constrains Medication.amount.numerator.value to max=0 and says nothing
+    // about its type, so the merged field read `any` and every type-aware check
+    // skipped it — HL7 reported "The value 'Example value' is not a valid decimal"
+    // where we said nothing. The same silence on `max` left Medication.ingredient
+    // with isArray=false despite being 0..* in the base, so paths beneath it were
+    // never walked.
+    //
+    // Only genuinely absent properties are filled in; anything the differential
+    // states still wins.
     for (const field of newFields) {
-        fieldMap.set(getFieldKey(field), field);
+        const key = getFieldKey(field);
+        fieldMap.set(key, inheritUnstatedFromBase(field, fieldMap.get(key)));
     }
     // Return the merged fields as an array
     return Array.from(fieldMap.values());
@@ -276,6 +358,48 @@ export function sanitizeIdentifier(name) {
         cleaned = `_${cleaned}`;
     return cleaned;
 }
+/**
+ * Turn a FHIR resource name into a PascalCase TypeScript identifier.
+ *
+ * Shared by the ValueSet and NamingSystem emitters, which previously carried
+ * the same split-and-capitalize loop with only the digit prefix differing.
+ * {@link toPascalCase} alone is not enough: it drops the underscore that
+ * {@link sanitizeIdentifier} adds, so a name starting with a digit comes back
+ * as an invalid identifier.
+ */
+export function pascalCaseIdentifier(name, opts) {
+    const stripped = opts.stripPrefix ? name.replace(opts.stripPrefix, '') : name;
+    const pascal = toPascalCase(stripped);
+    if (!pascal)
+        return opts.fallback;
+    return /^[0-9]/.test(pascal) ? `${opts.digitPrefix}${pascal}` : pascal;
+}
+/**
+ * Lower-case a name's first character, keeping a leading acronym run intact.
+ *
+ *   "CHCorePatient" → "chCorePatient"   (the acronym lowers wholesale, but the
+ *                                        last capital starts the next word)
+ *   "Patient"       → "patient"
+ *   "HumanName"     → "humanName"
+ *
+ * Shared by the prefab renderer and the MCP view registry, which each carried a
+ * byte-identical copy — the second one commented "Mirrors the same logic in
+ * prefabRenderer.ts", which is the drift warning rather than a defence.
+ *
+ * charAt() is deliberate over indexing: it yields '' past the end, so the
+ * acronym run terminates at the boundary without an index assertion.
+ */
+export function lowerFirstPreservingAcronym(name) {
+    if (!name)
+        return name;
+    let i = 0;
+    while (i < name.length && name.charAt(i) >= 'A' && name.charAt(i) <= 'Z')
+        i++;
+    if (i <= 1)
+        return name.charAt(0).toLowerCase() + name.slice(1);
+    const acronymEnd = i === name.length ? i : i - 1;
+    return name.slice(0, acronymEnd).toLowerCase() + name.slice(acronymEnd);
+}
 export function toPascalCase(name) {
     if (!name)
         return name;

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

@@ -95,8 +95,16 @@ export function generatePatternMetadata(fieldPatterns, forbiddenFields, valueSet
     }
     const hasBindings = Object.keys(valueSetBindings).length > 0;
     return `
-  /** Pattern constraints for profile fields (used by random() generator) */
-  protected static readonly _fieldPatterns = ${JSON.stringify(patternMap, null, 2)};
+  /**
+   * Pattern constraints this profile fixes on its fields, keyed by field path
+   * (e.g. \`"shlSession.system": "https://example.org/fhir/shl-session"\`).
+   *
+   * Public alongside \`valueSetBindings\`: a consumer that needs a fixed value —
+   * an identifier system, a fixed code — would otherwise hand-write the literal
+   * the profile already declares, which is the duplication this package exists
+   * to remove. Read by the random() generator too.
+   */
+  static readonly _fieldPatterns = ${JSON.stringify(patternMap, null, 2)};
 
   /** Fields that are forbidden (max=0) in this profile - must not be generated */
   protected static readonly _forbiddenFields: string[] = ${JSON.stringify(forbiddenFields)};

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

@@ -26,7 +26,7 @@ export function renderClassTemplate(params) {
     const helperImportList = Array.from(helperImports).join(', ');
     const hasVsBindings = Object.keys(valueSetBindings).length > 0;
     return `
-import { validate${interfaceName}, ${interfaceName} } from "./${interfaceName}.js";
+import { validate${interfaceName}, type ${interfaceName} } from "./${interfaceName}.js";
 import type { ValidatorOptions } from "./ValidatorOptions.js";
 // Only import helpers actually referenced below (dynamic based on required fields)
 import { ${helperImportList} } from "./random/index.js";
@@ -55,7 +55,13 @@ function safeClone<T>(value: T): T {
 
 export class ${className} {
 ${generatePatternMetadata(fieldPatterns, forbiddenFields, valueSetBindings, fieldOrder, codeableConceptBindings)}
-  constructor(private resource: ${interfaceName}) {
+  private resource: ${interfaceName};
+
+  // Declared and assigned rather than written as a parameter property, which
+  // erasableSyntaxOnly bans: it emits real assignment code from what reads as a
+  // type annotation. Generated output is held to the same strictness as src/.
+  constructor(resource: ${interfaceName}) {
+    this.resource = resource;
     ${constructorMetaProfile}
   }
   /** Validate current resource instance. */

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

@@ -252,6 +252,13 @@ export function buildNestedRequirementsObject(nestedRequirements) {
         // Navigate/create nested objects for all but the last part
         for (let i = 0; i < parts.length - 1; i++) {
             const part = parts[i];
+            // The loop bound guarantees a segment here; if one is ever missing the
+            // requirement is abandoned rather than navigated halfway, which is the same
+            // course the non-object branch below takes.
+            if (part === undefined) {
+                skipThis = true;
+                break;
+            }
             const isArraySegment = allArraySegments.has(parts.slice(0, i + 1).join('.'));
             if (!(part in current)) {
                 // Create either an array with one object or a plain object
@@ -290,7 +297,9 @@ export function buildNestedRequirementsObject(nestedRequirements) {
             continue;
         }
         // Set the final value
-        const lastPart = parts[parts.length - 1];
+        const lastPart = parts.at(-1);
+        if (lastPart === undefined)
+            continue;
         // If this property already exists and is an object with properties, merge instead of overwrite
         const existingValue = current[lastPart];
         const hasExplicitConstraint = req.patternConstraint !== undefined || req.fixedValue !== undefined;

package/out/src/generator/emitters/client/clientGenerator.js

@@ -176,11 +176,16 @@ export type FetchFn = typeof globalThis.fetch;
 export class FhirResourceReader<T, S extends SearchParams = SearchParams> implements FhirResourceSearcher<T, S> {
   private readonly fetchFn: FetchFn;
 
+  public readonly baseUrl: string;
+  public readonly resourceType: string;
+
   constructor(
-    public readonly baseUrl: string,
-    public readonly resourceType: string,
+    baseUrl: string,
+    resourceType: string,
     fetchFn?: FetchFn,
   ) {
+    this.baseUrl = baseUrl;
+    this.resourceType = resourceType;
     this.fetchFn = fetchFn ?? globalThis.fetch.bind(globalThis);
   }
 
@@ -321,11 +326,16 @@ import type { FetchFn } from "./resource-reader.js";
 export class FhirResourceWriterImpl<T> implements FhirResourceWriter<T> {
   private readonly fetchFn: FetchFn;
 
+  public readonly baseUrl: string;
+  public readonly resourceType: string;
+
   constructor(
-    public readonly baseUrl: string,
-    public readonly resourceType: string,
+    baseUrl: string,
+    resourceType: string,
     fetchFn?: FetchFn,
   ) {
+    this.baseUrl = baseUrl;
+    this.resourceType = resourceType;
     this.fetchFn = fetchFn ?? globalThis.fetch.bind(globalThis);
   }
 
@@ -451,7 +461,11 @@ export type BundleEntry<T extends FhirResource = FhirResource> = {
  * FHIR Bundle Parser - provides type-safe parsing and filtering of FHIR Bundles
  */
 export class BundleParser {
-  constructor(private readonly bundle: Bundle<FhirResource>) {}
+  private readonly bundle: Bundle<FhirResource>;
+
+  constructor(bundle: Bundle<FhirResource>) {
+    this.bundle = bundle;
+  }
 
   /**
    * Get all resources from the bundle
@@ -659,11 +673,13 @@ ${writerMethods}
 export class FhirClient {
   private readonly readClient: FhirReadClient;
   private readonly writeClient: FhirWriteClient;
+  public readonly baseUrl: string;
 
   constructor(
-    public readonly baseUrl: string,
+    baseUrl: string,
     fetchFn?: FetchFn,
   ) {
+    this.baseUrl = baseUrl;
     this.readClient = new FhirReadClient(baseUrl, fetchFn);
     this.writeClient = new FhirWriteClient(baseUrl, fetchFn);
   }

package/out/src/generator/emitters/client/smartAuthGenerator.js

@@ -167,7 +167,10 @@ export class SmartAuth {
   private readonly storage: Storage;
   private readonly keys: ReturnType<typeof storageKeys>;
 
-  constructor(public readonly config: SmartConfig) {
+  public readonly config: SmartConfig;
+
+  constructor(config: SmartConfig) {
+    this.config = config;
     this.storage = config.storage ?? sessionStorage;
     this.keys = storageKeys(config.storagePrefix ?? "smart_");
   }

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

@@ -135,7 +135,7 @@ function collectSliceGroups(fields, baseFields, baseResource) {
         if (!isEligibleBackbonePath(field.baseTypeCode || field.type || '', path, baseResource))
             continue;
         const childFields = gatherChildFields(fields, path);
-        const slicingRules = field.slicingRules || 'open';
+        const slicingRules = field.slicingRules ?? 'open';
         seenPaths.add(path);
         groups.push({ parentField: field, sliceFields, childFields, slicingRules });
     }
@@ -160,7 +160,7 @@ function collectSliceGroups(fields, baseFields, baseResource) {
         if (sliceFields.length === 0)
             continue;
         const childFields = gatherChildFields(fields, path);
-        const slicingRules = parentField.slicingRules || 'open';
+        const slicingRules = parentField.slicingRules ?? 'open';
         seenPaths.add(path);
         groups.push({ parentField, sliceFields, childFields, slicingRules });
     }

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

@@ -1,4 +1,4 @@
-import { capitalize, choicePropertyName, narrowedChoiceType, sanitizeIdentifier, toPascalCase, stripVersionFromCanonicalUrl } from '../../core/utils.js';
+import { capitalize, choicePropertyName, narrowedChoiceType, sanitizeIdentifier, toPascalCase, stripVersionFromCanonicalUrl, stripSliceSuffix } from '../../core/utils.js';
 import { sanitizeValueSetName } from '../valueset/valueSetGenerator.js';
 import { logger } from '../../../logger.js';
 import { getRules } from '../../fhir/versionContext.js';
@@ -45,8 +45,8 @@ export function processFields(ctx, fields, parentInterfaceName, parentFieldType,
         }
         // Register external profiles for FHIR datatype profiles (like SimpleQuantity) early
         // This must happen before any returns to ensure the profile is registered
-        if (field.isProfiled && field.profileUrls && field.profileUrls.length > 0) {
-            const profileUrl = field.profileUrls[0];
+        const profileUrl = field.isProfiled ? field.profileUrls?.[0] : undefined;
+        if (profileUrl) {
             // Use profileUrlToName to get the actual interface name, fallback to URL-derived name
             // Strip version suffix from canonical URL (e.g., |5.3.0-ballot-tc1) before extracting name
             const strippedUrl = stripVersionFromCanonicalUrl(profileUrl);
@@ -61,13 +61,9 @@ export function processFields(ctx, fields, parentInterfaceName, parentFieldType,
             }
         }
         const fieldParts = field.name.split(".");
-        let fieldName = fieldParts[fieldParts.length - 1];
-        // Remove slice notation (e.g., "extension:Stadtteil" -> "extension") for property names
-        // The slice name is preserved in field.sliceName for semantic purposes
-        const colonIndex = fieldName.indexOf(':');
-        if (colonIndex !== -1) {
-            fieldName = fieldName.substring(0, colonIndex);
-        }
+        // Slice notation is dropped for the property name ("extension:Stadtteil"
+        // -> "extension"); field.sliceName keeps it for semantic purposes.
+        let fieldName = stripSliceSuffix(fieldParts.at(-1) ?? field.name);
         const isRootInterface = parentInterfaceName === interfaceName;
         const isNested = isRootInterface ? fieldParts.length > 1 : fieldParts.length >= 1;
         // When generating a slice-specific interface, only include direct children
@@ -126,7 +122,7 @@ export function processFields(ctx, fields, parentInterfaceName, parentFieldType,
         // (2 segments: Identifier.system) and skip nested paths (4+ segments: Identifier.assigner.identifier.system)
         if (isNested && fieldParts.length >= 2) {
             const baseTypeName = fieldParts[0]; // e.g., "Identifier" from "Identifier.assigner.identifier.system"
-            const isExtendingBaseType = baseResource && baseTypeName.toLowerCase() === baseResource.toLowerCase();
+            const isExtendingBaseType = !!baseResource && baseTypeName?.toLowerCase() === baseResource.toLowerCase();
             // Check if this field will create a nested interface (has children in fields)
             const hasChildren = fields.some((f) => f.name.startsWith(field.name + '.'));
             const shouldKeepForNested = field.mustSupport && hasChildren;
@@ -173,7 +169,8 @@ export function processFields(ctx, fields, parentInterfaceName, parentFieldType,
             }
             else if (!isLogicalModel) {
                 // For other profiles, use the original logic
-                if (!parentInterfaceName.toLowerCase().includes(fieldParts[fieldParts.length - 2].toLowerCase())) {
+                const parentSegment = fieldParts.at(-2);
+                if (!parentSegment || !parentInterfaceName.toLowerCase().includes(parentSegment.toLowerCase())) {
                     return; // Skip nested fields that don't match the parent interface name
                 }
             }
@@ -529,7 +526,13 @@ export function processFields(ctx, fields, parentInterfaceName, parentFieldType,
                 deduped.push(line); // JSDoc or other non-field lines
                 continue;
             }
+            // Group 1 is present whenever the regex matched, but the type does not
+            // say so; a line without it is passed through rather than deduped.
             const name = fieldMatch[1];
+            if (!name) {
+                deduped.push(line);
+                continue;
+            }
             if (seenFieldNames.has(name)) {
                 continue; // Skip duplicate — keep the first (more specific) version
             }

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

@@ -26,11 +26,14 @@ export function canonicalToTypeName(name, profileUrlToName) {
                 matches.add(generatedName);
             }
         }
-        if (matches.size === 1)
-            return [...matches][0];
+        if (matches.size === 1) {
+            const [only] = [...matches];
+            if (only)
+                return only;
+        }
     }
     // if already a valid identifier with capitalization, return as-is
-    if (/^[A-Za-z_][A-Za-z0-9_]*$/.test(t) && /[A-Z]/.test(t[0]))
+    if (/^[A-Za-z_][A-Za-z0-9_]*$/.test(t) && /^[A-Z]/.test(t))
         return t;
     const parts = t.split(/[^A-Za-z0-9]+/).filter(Boolean);
     let pascal = parts.map(p => p.charAt(0).toUpperCase() + p.slice(1)).join('');

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

@@ -4,6 +4,7 @@
  */
 import { capitalize, sanitizeIdentifier, toPascalCase, stripVersionFromCanonicalUrl } from '../../core/utils.js';
 import { logger } from '../../../logger.js';
+import {} from './importManager.js';
 import { getRules } from '../../fhir/versionContext.js';
 export function postProcessExtensions(params) {
     const { interfaces, interfaceName, baseResource, newFields, baseFieldByLastSegment, importManager, existingProfiles, profileUrlToName, generatedAliasTypes, findInterfaceIndex, inferBackboneType, addTypeImport } = params;
@@ -299,9 +300,15 @@ export function postProcessExtensions(params) {
             });
             const baseFld2 = baseFieldByLastSegment.get(seg2);
             let extendT2 = actualField2?.type || baseFld2?.type;
-            // Fallback to specific mappings if needed
+            // A generic BackboneElement carries none of the base backbone's own properties, so
+            // resolve it against the level-1 backbone already resolved above
+            // (QuestionnaireResponseItem + 'answer' -> QuestionnaireResponseItemAnswer).
             if (!extendT2 || extendT2 === 'any' || extendT2 === 'BackboneElement') {
-                if (baseResource === 'Encounter' && seg1 === 'hospitalization' && seg2 === 'dischargeDisposition') {
+                const inferred2 = extendT1 ? inferBackboneType(extendT1, seg2) : undefined;
+                if (inferred2) {
+                    extendT2 = inferred2;
+                }
+                else if (baseResource === 'Encounter' && seg1 === 'hospitalization' && seg2 === 'dischargeDisposition') {
                     extendT2 = 'CodeableConcept';
                 }
             }

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

@@ -175,12 +175,10 @@ export function handleNestedField(args) {
         }
         else {
             // No nested interface existed; create a minimal one extending the base/inferred type to host the extension union
-            let parentT = baseFieldByLastSegment.get(fieldName)?.type || field.type;
-            if (!parentT || parentT === 'any') {
-                const inferred = inferBackboneType(baseResource, fieldName);
-                if (inferred)
-                    parentT = inferred;
-            }
+            // Reuse the type resolved above rather than recomputing it: the local
+            // recomputation used to stop at a generic BackboneElement, which drops the
+            // base backbone's own properties (e.g. QuestionnaireResponseItem.linkId).
+            let parentT = baseFieldType;
             if (parentT && !isPrimitiveType(parentT)) {
                 parentT = canonicalToTypeName(parentT);
                 const sanitized = sanitizeIdentifier(parentT);