babelfhir-ts 1.5.19 → 1.5.21

package/out/src/generator/sdProcessor.js

@@ -10,7 +10,8 @@ import path from 'path';
 import { generateClass } from './emitters/class/classGenerator.js';
 import { generateInterfaces } from './emitters/interface/interfaceGenerator.js';
 import { fetchStructureDefinition, parseStructureDefinition } from './parser/sdParser.js';
-import { writeInterfaceAndValidatorToFile, mergeFields, alignFields, writeToFile, getBaseResource, sanitizeIdentifier, toPascalCase, capitalize, stripVersionFromCanonicalUrl } from './core/utils.js';
+import { writeInterfaceAndValidatorToFile, mergeFields, alignFields, writeToFile, getBaseResource, sanitizeIdentifier, toPascalCase, stripVersionFromCanonicalUrl } from './core/utils.js';
+import { extensionElements, collectSubExtensionSlices, readSubExtensionMin, readBinding } from './core/extensionSdReader.js';
 import { generateValidateProfileFunction } from './emitters/validator/validatorGenerator.js';
 import { generateZodSchema } from './emitters/zod/zodSchemaGenerator.js';
 import { extractFieldPatternsAndMetadata } from './emitters/class/fieldPatternExtractor.js';
@@ -18,14 +19,176 @@ import { logger } from '../logger.js';
 import { ctx as versionCtx, fhirModuleSpecifier } from './fhir/versionContext.js';
 import { registerProfile, addDiagnostic } from './core/sdDiagnostics.js';
 import { resetFetchFailureTracking, getFetchFailureCount, getFetchFailureWarning, recordFetchFailure, resolveComplexTypeChildType, ensureRandomSupportFile, ensureValidatorOptionsFile, } from './sdProcessorHelpers.js';
-import { extractAndDeduplicateRequiredFields } from './sdProcessorRequiredFields.js';
+import { extractAndDeduplicateRequiredFields, resolveChoiceSegments } from './sdProcessorRequiredFields.js';
 // Re-export public API consumed by index.ts / generationHelpers.ts
 export { resetFetchFailureTracking, getFetchFailureCount, getFetchFailureWarning };
 const log = logger.withTag('generator');
+/**
+ * Fill in what a profile's differential never states, from the base resource.
+ *
+ * A differential element says only what it *changes*. 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 were silent. The same
+ * silence on `max` left `Medication.ingredient` non-repeating despite being 0..* in
+ * the base, so nothing beneath it was ever walked.
+ *
+ * The base resource snapshot supplies the top of each path (`Medication.amount` is a
+ * Ratio); below that it stops, because a resource never expands its datatypes'
+ * children. Those come from the datatype tables — `Ratio.numerator` is a Quantity,
+ * `Quantity.value` a decimal — walked down from the deepest ancestor whose type is
+ * already known. An unresolvable hop leaves the field alone rather than guessing.
+ *
+ * Only unstated properties are filled; anything the differential declares still wins.
+ */
+async function fillUnstatedFromBaseResource(fields, resourceType) {
+    if (!resourceType)
+        return;
+    let baseSd;
+    try {
+        baseSd = await fetchStructureDefinition(`http://hl7.org/fhir/StructureDefinition/${resourceType}`);
+    }
+    catch {
+        return;
+    }
+    const baseElements = baseSd?.snapshot?.element;
+    if (!baseElements?.length)
+        return;
+    const baseByPath = new Map();
+    for (const el of baseElements) {
+        const id = el.id ?? el.path;
+        if (!id)
+            continue;
+        const rel = id.replace(/^[^.]+\./, '');
+        if (!rel || rel === id || rel.includes(':'))
+            continue;
+        baseByPath.set(rel, { type: el.type?.[0]?.code, max: el.max });
+    }
+    // Container types name no datatype to walk into, so they seed nothing.
+    const knownType = new Map();
+    for (const [rel, meta] of baseByPath) {
+        if (meta.type && meta.type !== 'BackboneElement' && meta.type !== 'Element') {
+            knownType.set(rel, meta.type);
+        }
+    }
+    const unstated = (type) => !type || type === 'any';
+    // Shallow paths first, so a deeper one can walk down from an ancestor this pass
+    // has just resolved.
+    const ordered = [...fields].sort((a, b) => (a.name || '').split('.').length - (b.name || '').split('.').length);
+    for (const field of ordered) {
+        const rel = (field.name || '').replace(/^[^.]+\./, '');
+        if (!rel)
+            continue;
+        const base = baseByPath.get(rel);
+        if (base) {
+            if (unstated(field.type) && base.type)
+                field.type = base.type;
+            if (field.max === undefined && base.max !== undefined) {
+                const unbounded = base.max === '*';
+                const parsed = unbounded ? Infinity : Number.parseInt(base.max, 10);
+                if (unbounded || Number.isFinite(parsed)) {
+                    field.max = parsed;
+                    field.isArray = unbounded || parsed > 1;
+                }
+            }
+            if (!unstated(field.type))
+                knownType.set(rel, field.type);
+            continue;
+        }
+        if (!unstated(field.type)) {
+            knownType.set(rel, field.type);
+            continue;
+        }
+        const segments = rel.split('.');
+        let current;
+        let next = 0;
+        for (let depth = segments.length - 1; depth >= 1; depth--) {
+            const ancestorType = knownType.get(segments.slice(0, depth).join('.'));
+            if (ancestorType) {
+                current = ancestorType;
+                next = depth;
+                break;
+            }
+        }
+        if (!current)
+            continue;
+        for (let i = next; i < segments.length && current; i++) {
+            current = resolveComplexTypeChildType(current, segments[i]);
+        }
+        if (current) {
+            field.type = current;
+            knownType.set(rel, current);
+        }
+    }
+}
+/**
+ * Fill in extension-slice canonicals a derived profile does not restate.
+ *
+ * An extension slice is recognised at runtime by the canonical its `type.profile`
+ * names. A derived profile that only tightens cardinality omits it:
+ * KBV_PR_ERP_Medication_PZN redeclares `extension:Kategorie` and
+ * `extension:Normgroesse` with no profile, while its base KBV_PR_Base_Medication
+ * gives them KBV_EX_Base_Medication_Type and .../normgroesse. Two of four slices
+ * were therefore unidentifiable, and the closed-slicing check on
+ * `Medication.extension` could not build an allowed set — so it stayed silent where
+ * HL7 reports "does not match any known slice … and slicing is CLOSED".
+ *
+ * Walks the baseDefinition chain, nearest ancestor first, and stops at the first
+ * that names a canonical. Depth-bounded: a malformed chain must not loop.
+ */
+async function fillSliceProfileUrlsFromBaseProfiles(fields, baseDefinition) {
+    const needing = fields.filter(f => f.sliceName && !f.profileUrls?.length && f.elementId);
+    if (needing.length === 0)
+        return;
+    const seen = new Set();
+    let canonical = baseDefinition;
+    for (let depth = 0; depth < 5 && canonical; depth++) {
+        const key = stripVersionFromCanonicalUrl(canonical);
+        if (seen.has(key))
+            break;
+        seen.add(key);
+        let baseSd;
+        try {
+            baseSd = await fetchStructureDefinition(canonical);
+        }
+        catch {
+            return;
+        }
+        if (!baseSd)
+            return;
+        const byElementId = new Map();
+        for (const el of (baseSd.snapshot?.element ?? baseSd.differential?.element ?? [])) {
+            const id = el.id;
+            if (!id)
+                continue;
+            const profiles = (el.type ?? []).flatMap(t => t.profile ?? []);
+            if (profiles.length)
+                byElementId.set(id, profiles);
+        }
+        for (const field of needing) {
+            if (field.profileUrls?.length)
+                continue;
+            const inherited = byElementId.get(field.elementId);
+            if (inherited?.length)
+                field.profileUrls = inherited;
+        }
+        if (needing.every(f => f.profileUrls?.length))
+            return;
+        canonical = baseSd.baseDefinition;
+    }
+}
 // ── Extension metadata resolution for validator emission ──────────────────
 /**
  * Scan fields for extension slices with profile URLs, resolve their
  * StructureDefinitions, and extract value[x] type + binding metadata.
+ *
+ * Keyed by the *version-stripped* canonical. A slice names its extension twice and
+ * the two forms disagree: `type.profile` carries a version suffix
+ * (`…/sdc-questionnaire-contextExpression|4.0.0`) while the pinned `url` child
+ * carries the bare canonical. Keying on whichever arrived first left the other
+ * lookup empty, and an absent entry means "SD unreadable, conclude nothing" — so
+ * DTRStdQuestionnaire's contextExpression emitted no validation at all.
+ * Callers must strip before reading; use `lookupExtensionMetadata`.
  */
 async function resolveExtensionMetadata(fields) {
     const extUrls = new Set();
@@ -41,11 +204,35 @@ async function resolveExtensionMetadata(fields) {
         return undefined;
     const map = new Map();
     await Promise.all([...extUrls].map(async (url) => {
+        // Fetch by the url as written — the version suffix selects the right SD — but
+        // key the result by the stripped form so either spelling finds it.
+        const key = stripVersionFromCanonicalUrl(url);
         try {
             const extSd = await fetchStructureDefinition(url);
-            if (!extSd?.snapshot?.element)
+            const els = extensionElements(extSd);
+            if (!els)
+                return;
+            const valueEl = els.find(el => el.path === 'Extension.value[x]' || el.id === 'Extension.value[x]');
+            const subExtensions = collectSubExtensionSlices(els);
+            const subExtensionMin = readSubExtensionMin(els);
+            // A complex extension carries sub-extensions instead of a value, and forbids a
+            // value outright (ext-1: extension.exists() != value.exists()). Recorded as an
+            // empty type list — different from no entry at all, which would mean the SD
+            // could not be read and nothing can be concluded.
+            //
+            // Recognised two ways because published SDs state it two ways: value[x] pinned
+            // to max=0 (sdc-questionnaire-contextExpression), or a required
+            // Extension.extension with no value[x] element at all
+            // (KBV_EX_ERP_PracticeSupply_Payor, whose differential omits value[x] entirely —
+            // the earlier `if (!valueEl) return` dropped it before anything was read).
+            if (valueEl?.max === '0' || (subExtensionMin ?? 0) >= 1) {
+                map.set(key, {
+                    valueTypes: [],
+                    subExtensionMin,
+                    subExtensions: subExtensions.length ? subExtensions : undefined,
+                });
                 return;
-            const valueEl = extSd.snapshot.element.find((el) => (el.path === 'Extension.value[x]' || el.id === 'Extension.value[x]'));
+            }
             if (!valueEl)
                 return;
             const types = (valueEl.type || []).map((t) => t.code).filter(Boolean);
@@ -54,28 +241,96 @@ async function resolveExtensionMetadata(fields) {
             const entry = { valueTypes: types };
             // Check binding on value[x] first, then fall back to typed slices
             // (e.g., Extension.valueCode may carry the binding instead of Extension.value[x])
-            let binding = valueEl.binding;
-            if (!binding?.valueSet && types.length === 1) {
+            let binding = readBinding(valueEl);
+            if (!binding && types.length === 1) {
                 const suffix = types[0].charAt(0).toUpperCase() + types[0].slice(1);
-                const sliceEl = extSd.snapshot.element.find((el) => el.id === `Extension.value[x]:value${suffix}` ||
+                const sliceEl = els.find(el => el.id === `Extension.value[x]:value${suffix}` ||
                     el.path === `Extension.value${suffix}` ||
                     el.id === `Extension.value${suffix}`);
-                if (sliceEl?.binding?.valueSet) {
-                    binding = sliceEl.binding;
-                }
+                binding = readBinding(sliceEl);
             }
-            if (binding?.strength && binding?.valueSet) {
-                const vsUri = typeof binding.valueSet === 'string'
-                    ? binding.valueSet
-                    : binding.valueSet?.reference;
-                if (vsUri) {
-                    entry.binding = { strength: binding.strength, uri: vsUri.split('|')[0] };
+            if (binding)
+                entry.binding = binding;
+            map.set(key, entry);
+        }
+        catch {
+            // Extension SD not resolvable — skip
+        }
+    }));
+    return map.size > 0 ? map : undefined;
+}
+/**
+ * Resolve what a datatype profile pins, for slices discriminated by
+ * `{profile, $this}`.
+ *
+ * Such a slice names a profile instead of a value, so membership can only be decided
+ * by reading the profile. sdc slices Questionnaire.useContext against
+ * sdc-usagecontext-questionnaire-library, which pins UsageContext.code to
+ * usage-context-type|workflow — that pin is the discriminator in practice.
+ *
+ * Extension slices are excluded: they are already handled by resolveExtensionMetadata
+ * and are matched on url, not on a pinned value.
+ */
+async function resolveDatatypeProfilePins(fields) {
+    const urls = new Set();
+    for (const f of fields) {
+        if (!f.sliceName || !f.profileUrls?.length)
+            continue;
+        const basePath = (f.name || '').replace(/^[^.]+\./, '').split(':')[0];
+        if (basePath.endsWith('extension') || basePath.endsWith('modifierExtension'))
+            continue;
+        urls.add(f.profileUrls[0]);
+    }
+    if (urls.size === 0)
+        return undefined;
+    const map = new Map();
+    await Promise.all([...urls].map(async (url) => {
+        try {
+            const sd = await fetchStructureDefinition(url);
+            // Only datatype profiles: a resource profile's members are matched by
+            // resourceType, which the type-discriminator path already covers.
+            if (!sd?.snapshot?.element || sd.kind !== 'complex-type')
+                return;
+            for (const el of sd.snapshot.element) {
+                const id = typeof el.id === 'string' ? el.id : '';
+                const relPath = id.includes('.') ? id.substring(id.indexOf('.') + 1) : '';
+                // Skip the root and anything below a nested choice, which needs a concrete
+                // property name the pin does not carry.
+                if (!relPath || relPath.includes('[x]'))
+                    continue;
+                const coding = el.patternCoding ?? el.fixedCoding;
+                if (coding && typeof coding === 'object') {
+                    const c = coding;
+                    if (typeof c.code === 'string') {
+                        map.set(url, {
+                            path: relPath,
+                            shape: 'coding',
+                            system: typeof c.system === 'string' ? c.system : undefined,
+                            code: c.code,
+                        });
+                        return;
+                    }
+                }
+                const concept = el.patternCodeableConcept ?? el.fixedCodeableConcept;
+                const nested = concept && typeof concept === 'object'
+                    ? concept.coding
+                    : undefined;
+                if (Array.isArray(nested) && nested.length > 0) {
+                    const c = nested[0];
+                    if (typeof c.code === 'string') {
+                        map.set(url, {
+                            path: relPath,
+                            shape: 'codeableConcept',
+                            system: typeof c.system === 'string' ? c.system : undefined,
+                            code: c.code,
+                        });
+                        return;
+                    }
                 }
             }
-            map.set(url, entry);
         }
         catch {
-            // Extension SD not resolvable — skip
+            // Profile not resolvable — leave the slice unmatched rather than guess.
         }
     }));
     return map.size > 0 ? map : undefined;
@@ -111,7 +366,10 @@ export async function processStructureDefinition(sd, ctx) {
     // ── External profile resolution ──────────────────────────────────
     for (const [typeName, profileInfo] of interfaceResult.referencedExternalProfiles) {
         const normalizedTypeName = toPascalCase(sanitizeIdentifier(typeName));
-        const isUsedHere = interfaceContent.includes(`import { ${normalizedTypeName} } from "./${normalizedTypeName}"`) ||
+        // Tolerates the `type` modifier the interface emitter writes; the second
+        // clause already did, but leaving the first matching only the bare form
+        // makes the two disagree for no reason.
+        const isUsedHere = new RegExp(`import(?:\\s+type)?\\s+\\{\\s*${normalizedTypeName}\\s*\\}\\s+from\\s+"\\./${normalizedTypeName}"`).test(interfaceContent) ||
             (interfaceContent.includes(`from "./${normalizedTypeName}"`) && interfaceContent.includes(`{ ${normalizedTypeName} }`));
         if (!isUsedHere)
             continue;
@@ -189,9 +447,13 @@ export async function processStructureDefinition(sd, ctx) {
     let finalInterfaceContent = interfaceContent;
     for (const [originalName, actualName] of profileIdToName?.entries() || []) {
         if (originalName !== actualName) {
-            const oldImport = `import { ${originalName} } from "./${originalName}"`;
-            const newImport = `import { ${actualName} } from "./${actualName}"`;
-            finalInterfaceContent = finalInterfaceContent.replace(oldImport, newImport);
+            // Matched by pattern, not by a literal string: the emitted form carries a
+            // `type` modifier, and a literal that omitted it renamed the *usages*
+            // while leaving the import pointing at the old module — which generated
+            // `Cannot find module './BodySite'` alongside `Cannot find name
+            // 'BodyStructureReference'` in the same file.
+            const importRegex = new RegExp(`import(\\s+type)?\\s+\\{\\s*${originalName}\\s*\\}\\s+from\\s+"\\./${originalName}"`, 'g');
+            finalInterfaceContent = finalInterfaceContent.replace(importRegex, (_m, typeModifier) => `import${typeModifier ?? ''} { ${actualName} } from "./${actualName}"`);
             const typeUsageRegex = new RegExp(`(:\\s+|Array<|\\|\\s+|&\\s+|extends\\s+)${originalName}(?=\\s*[;,>\\|&\\)\\n\\[\\s{])`, 'g');
             finalInterfaceContent = finalInterfaceContent.replace(typeUsageRegex, `$1${actualName}`);
         }
@@ -211,9 +473,12 @@ export async function processStructureDefinition(sd, ctx) {
     finalInterfaceContent = dedupedLines.join('\n');
     // ── Required fields ──────────────────────────────────────────────
     const merged = mergeFields(aligned.alignedNewFields, parsed.oldFields);
+    await fillUnstatedFromBaseResource(merged, sd.type);
+    await fillSliceProfileUrlsFromBaseProfiles(merged, sd.baseDefinition);
     // ── Pre-resolve Extension SDs for validator emission ─────────────
     const extensionMetadata = await resolveExtensionMetadata(merged);
-    const validateResult = generateValidateProfileFunction(interfaceName, merged, valueSets, sd.url, sd.type, profileUrlToName, extensionMetadata, sd.baseDefinition, profileUrlToType);
+    const datatypeProfilePins = await resolveDatatypeProfilePins(merged);
+    const validateResult = generateValidateProfileFunction(interfaceName, merged, valueSets, sd.url, sd.type, profileUrlToName, extensionMetadata, sd.baseDefinition, profileUrlToType, datatypeProfilePins);
     const validateFn = validateResult.code;
     const candidateRequiredFields = [...aligned.alignedNewFields, ...parsed.oldFields];
     const profileDiffFieldNames = new Set(aligned.alignedNewFields.map(f => f.name));
@@ -251,12 +516,15 @@ export async function processStructureDefinition(sd, ctx) {
             continue;
         const parentFieldName = parts[1].split(':')[0];
         let relativePath = parts.slice(2).map((p) => p.split(':')[0]).join('.');
-        if (relativePath.includes('[x]') && f.type && f.type !== 'any' && f.type !== 'unknown') {
-            const fType = f.type;
-            relativePath = relativePath.replace(/(\w+)\[x\]/g, (_match, baseName) => {
-                const suffix = fType === 'code' ? 'Code' : capitalize(fType);
-                return `${baseName}${suffix}`;
-            });
+        if (relativePath.includes('[x]')) {
+            const resolvedPath = resolveChoiceSegments(f, parts, candidateRequiredFields);
+            // An intermediate choice we cannot narrow to one type has no property name.
+            // Dropping the requirement is the only honest outcome: naming it after the
+            // leaf's type invents a sibling property that no profile permits, and the
+            // random generator would then emit data both validators reject.
+            if (!resolvedPath)
+                continue;
+            relativePath = resolvedPath;
         }
         let profileUrl = f.typeOptions?.[0]?.profileUrls?.[0];
         if (!profileUrl && (relativePath === 'identifier' || relativePath.startsWith('identifier.'))) {
@@ -280,7 +548,12 @@ export async function processStructureDefinition(sd, ctx) {
         for (let i = 0; i < relativePathParts.length; i++) {
             const intermediatePath = [root, parentFieldName, ...relativePathParts.slice(0, i + 1)].join('.');
             if (fieldIsArrayMap.get(intermediatePath)) {
-                arraySegments.push(relativePathParts[i]);
+                // The relative prefix, not the bare segment name: a name repeating at two
+                // depths would otherwise share one verdict.
+                // MedicinalProductDefinition.name.part is 0..*, while the `part` string
+                // inside it is 1..1, and matching on the name alone wrapped the string in
+                // an array too.
+                arraySegments.push(relativePathParts.slice(0, i + 1).join('.'));
             }
         }
         let fieldType = f.type;

package/out/src/generator/sdProcessorHelpers.js

@@ -5,7 +5,7 @@ import path from 'path';
 import fs from 'fs';
 import { logger } from '../logger.js';
 import { generateRandomFiles } from './emitters/class/randomSupportGenerator.js';
-import { generateValidatorOptionsContent } from './emitters/validator/validatorGenerator.js';
+import { generateValidatorOptionsContent } from './emitters/validator/validatorRuntime.js';
 import { ctx } from './fhir/versionContext.js';
 // ── Fetch failure tracking ─────────────────────────────────────────
 let failedFetchCount = 0;

package/out/src/generator/sdProcessorRequiredFields.js

@@ -127,3 +127,123 @@ export function extractAndDeduplicateRequiredFields(candidateRequiredFields, sdI
     }
     return requiredFields;
 }
+/**
+ * The type a choice element should be named after.
+ *
+ * `typeOptions[0].code` is preferred over `field.type` because a choice property
+ * is named for the base type, never for a profile on it: R4 declares
+ * `Coverage.costToBeneficiary.value[x]` as `Quantity` profiled to SimpleQuantity,
+ * and the property is `valueQuantity`. Reading `field.type` yielded
+ * `valueSimpleQuantity`, which no FHIR resource has.
+ */
+function firstType(field) {
+    const type = field?.typeOptions?.[0]?.code || field?.type;
+    if (!type || type === 'any' || type === 'unknown')
+        return undefined;
+    return type;
+}
+/**
+ * A concrete type for an element that must be named unambiguously.
+ *
+ * Undefined when more than one type is permitted: a leaf may pick any of them and
+ * still be valid data, but an element with children may not, since the children
+ * exist under one type only.
+ */
+function singleType(field) {
+    if (!field)
+        return undefined;
+    if (field.typeOptions && field.typeOptions.length > 1)
+        return undefined;
+    return firstType(field);
+}
+/** `SimpleQuantity` -> `SimpleQuantity`, `code` -> `Code`: the choice-name suffix. */
+function choiceSuffix(type) {
+    return type === 'code' ? 'Code' : type.charAt(0).toUpperCase() + type.slice(1);
+}
+/**
+ * The one type an intermediate choice segment has been narrowed to.
+ *
+ * The parser strips slice qualifiers from field names, so a sliced choice yields
+ * several entries under the same id: the open base element carrying every
+ * permitted type, plus one narrowed entry per slice. Only the narrowed entries
+ * name a property, and they must agree — two slices pinning `value[x]` to
+ * different types share no single property name, so the requirement cannot be
+ * expressed and the caller drops it.
+ *
+ * The trailing `[x]` is also tried stripped, because a profile that pins the
+ * choice may record it under the bare name.
+ */
+/**
+ * Narrowed types by field name, built once per field list.
+ *
+ * The scan used to run per `[x]` segment, which is O(fields × segments): us-core
+ * has thousands of both, and generation crossed the 300s subprocess timeout in CI
+ * (`spawnSync /bin/sh ETIMEDOUT`) while every package small enough to finish still
+ * passed. Keyed on the array itself so callers need not thread an index through.
+ */
+const narrowedTypeIndexes = new WeakMap();
+function narrowedTypeIndex(candidateFields) {
+    const cached = narrowedTypeIndexes.get(candidateFields);
+    if (cached)
+        return cached;
+    const index = new Map();
+    for (const candidate of candidateFields) {
+        const type = singleType(candidate);
+        if (!type || !candidate.name)
+            continue;
+        let types = index.get(candidate.name);
+        if (!types)
+            index.set(candidate.name, (types = new Set()));
+        types.add(type);
+    }
+    narrowedTypeIndexes.set(candidateFields, index);
+    return index;
+}
+function narrowedSegmentType(id, candidateFields) {
+    const index = narrowedTypeIndex(candidateFields);
+    const bare = id.replace(/\[x\]$/, '');
+    // Both spellings, unioned: the same element appears under `value[x]` and, once a
+    // profile pins it, under `value`. Disagreement still names nothing.
+    const narrowed = new Set([
+        ...(index.get(id) ?? []),
+        ...(bare === id ? [] : index.get(bare) ?? []),
+    ]);
+    return narrowed.size === 1 ? [...narrowed][0] : undefined;
+}
+/**
+ * Resolve every `x[x]` segment of a nested requirement path to its concrete
+ * property name, using the type of *that* segment.
+ *
+ * The leaf's type is the field's own; an intermediate `[x]` must be looked up by
+ * its element id, because a profile that narrows `value[x]` to one type still
+ * carries children beneath it. Reading the leaf's type there produced names like
+ * `valueSimpleQuantity.origin` for `Observation.component:ekgLeads.value[x].origin`
+ * — four invented sibling properties in place of one `valueSampledData` object,
+ * all of which the reference validator rejects as unrecognized.
+ *
+ * @param parts `field.name` split on `.`, slice qualifiers intact.
+ * @returns the dotted path relative to the parent field, or undefined when an
+ *   intermediate choice cannot be narrowed to a single type.
+ */
+export function resolveChoiceSegments(field, parts, candidateFields) {
+    const segments = parts.slice(2);
+    const resolved = [];
+    for (let i = 0; i < segments.length; i++) {
+        const segment = segments[i].split(':')[0];
+        const choice = /^(\w+)\[x\]$/.exec(segment);
+        if (!choice) {
+            resolved.push(segment);
+            continue;
+        }
+        // A leaf carries no children, so any permitted type yields valid data; an
+        // intermediate segment must be the one its children actually belong to.
+        const isLeaf = i === segments.length - 1;
+        const type = isLeaf
+            ? firstType(field)
+            : narrowedSegmentType(parts.slice(0, 2 + i + 1).join('.'), candidateFields);
+        if (!type)
+            return undefined;
+        resolved.push(choice[1] + choiceSuffix(type));
+    }
+    return resolved.join('.');
+}

package/out/src/main.js

@@ -3,6 +3,7 @@ import { generateClient } from "./generator/emitters/client/clientGenerator.js";
 import { extractPackage } from "./generator/parser/packageParser.js";
 import { getCacheConfig, getFhirPackagesCacheDir, clearAllCaches, ensureCacheDir, setCacheConfig } from "./generator/core/cacheConfig.js";
 import { fetchArrayBuffer, fetchJson } from "./generator/core/fetchUtils.js";
+import { FHIR_REGISTRIES, PACKAGE_DOWNLOAD_ATTEMPTS } from "./generator/core/constants.js";
 import { handleInstallCommand } from "./cli/installCommand.js";
 import { handleUpdateCommand } from "./cli/updateCommand.js";
 import { buildQualityReport, formatReportSummary, resetDiagnostics } from "./generator/core/sdDiagnostics.js";
@@ -177,18 +178,43 @@ async function downloadPackage(packageSpec, registry) {
         return tgzPath; // Return path to tgz (may not exist, but packageDir does)
     }
     console.log(`Downloading ${packageName}@${version} from ${registry}...`);
-    // Simplifier API endpoint: GET /package/{id}/{version}
-    const url = `${registry.replace(/\/$/, '')}/${packageName}/${version}`;
-    try {
-        const response = await fetchArrayBuffer(url);
-        fs.writeFileSync(tgzPath, Buffer.from(response.data));
-        console.log(`✓ Downloaded package`);
-        return tgzPath;
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        throw new Error(`Failed to download package: ${message}. URL: ${url}`, { cause: error });
+    // Try the requested registry first, then the other known mirrors. A single
+    // transient `fetch failed` used to abort the whole generation: a parity run
+    // downloads ~30 packages, and four of them failed this way in one run —
+    // including one whose version had not changed. The registries serve identical
+    // tarballs, so a retry and a mirror are both cheap and safe.
+    const candidates = [
+        registry.replace(/\/$/, ''),
+        ...FHIR_REGISTRIES.filter(r => r !== registry.replace(/\/$/, '')),
+    ];
+    const attempts = [];
+    for (const base of candidates) {
+        // Registry endpoint: GET /{id}/{version}
+        const url = `${base}/${packageName}/${version}`;
+        for (let attempt = 1; attempt <= PACKAGE_DOWNLOAD_ATTEMPTS; attempt++) {
+            try {
+                const response = await fetchArrayBuffer(url);
+                fs.writeFileSync(tgzPath, Buffer.from(response.data));
+                console.log(`✓ Downloaded package`);
+                return tgzPath;
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                attempts.push(`${url} (attempt ${attempt}): ${message}`);
+                // A 404 means this mirror does not carry the version — no point
+                // retrying it, move to the next registry.
+                if (/\b404\b|not found/i.test(message))
+                    break;
+                if (attempt < PACKAGE_DOWNLOAD_ATTEMPTS) {
+                    const backoffMs = 1000 * 2 ** (attempt - 1);
+                    console.log(`  retrying in ${backoffMs}ms (${message})`);
+                    await new Promise(resolve => setTimeout(resolve, backoffMs));
+                }
+            }
+        }
     }
+    throw new Error(`Failed to download package ${packageName}@${version} from ${candidates.length} registry/registries:\n  `
+        + attempts.join('\n  '));
 }
 export function parseCliArgs(argv) {
     const out = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "babelfhir-ts",
-  "version": "1.5.19",
+  "version": "1.5.21",
   "description": "BabelFHIR-TS: generate TypeScript interfaces, validators, and helper classes from FHIR R4/R4B/R5 StructureDefinitions (profiles) directly inside package archives.",
   "type": "module",
   "main": "out/src/main.js",
@@ -40,6 +40,7 @@
     "generate:clients:check": "tsx scripts/generate-client-packages.ts --check",
     "generate:parity-matrix": "tsx scripts/generate-parity-matrix.ts",
     "generate:parity-matrix:check": "tsx scripts/generate-parity-matrix.ts --check",
+    "check:ig-versions": "tsx scripts/check-ig-versions.ts",
     "generate:check": "npm run generate && npm run typecheck && npm run typecheck:output && npm run lint:output",
     "generate:check:prefab": "npm run generate -- --prefab && npm run typecheck && npm run typecheck:output && npm run lint:output",
     "generate:check:package": "tsx scripts/generate-check-package.ts",
@@ -85,6 +86,7 @@
   },
   "devDependencies": {
     "@eslint/js": "^10.0.1",
+    "@max-health/config": "github:max-health-inc/config",
     "@maxhealth.tech/prefab": "^0.3.5",
     "@types/node": "^25.9.5",
     "@types/semver": "^7.7.1",