babelfhir-ts 1.3.4 → 1.3.6

package/README.md

@@ -160,7 +160,7 @@ The second pipeline validates using the [official HL7 FHIR Validator](https://co
 ![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)
 
-> Terminology validation requires a tx server. The pipeline uses `--tx-server https://tx.fhir.org/r4` during generation to expand ValueSets and produce valid codes.
+> 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.
 
 📊 **[Full Report](https://max-health-inc.github.io/BabelFHIR-TS/)**
 <!-- HL7-PARITY-BADGES:END -->

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

@@ -158,9 +158,14 @@ export function generateSliceElement(slice, elementType) {
                     log.debug(`Resource child - sliceName: ${sliceName}, profileUrls: ${JSON.stringify(profileUrls)}, profileUrl: ${profileUrl}`);
                     const metaProfile = profileUrl ? `, meta: { profile: ['${profileUrl}'] }` : '';
                     let resourceType = 'Composition';
-                    if (child.baseTypeCode) {
+                    // Prefer concrete baseTypeCode (skip generic 'Resource'), then slice name
+                    // (always the target resource type, e.g., 'Composition'), then profile URL.
+                    if (child.baseTypeCode && child.baseTypeCode !== 'Resource') {
                         resourceType = capitalise(child.baseTypeCode);
                     }
+                    else if (/^[A-Z][a-zA-Z]+$/.test(slice.name || '')) {
+                        resourceType = slice.name;
+                    }
                     else if (profileUrl) {
                         const profileName = profileUrl.split('/').pop() || '';
                         if (profileName.includes('-')) {

package/out/src/generator/emitters/validator/sliceValidatorGenerator.js

@@ -127,18 +127,24 @@ export function generateSliceValidations(ctx) {
                         generateExtensionUrlSliceValidation(slice, relPath, errorPath, sliceLabel, varName, min, extensionUrl, fieldPathMap, arrayFieldPaths, sliceValidations);
                     }
                     else {
-                        sliceValidations.push(`
+                        const profileMatch = detectProfileDiscriminator(slice, fields);
+                        if (profileMatch) {
+                            generateProfileDiscriminatorValidation(slice, relPath, errorPath, sliceLabel, varName, min, profileMatch, sliceValidations, ctx);
+                        }
+                        else {
+                            sliceValidations.push(`
   // Slice validation for ${relPath}:${sliceLabel} skipped: no pattern/value discriminator found
   // Discriminator types 'type', 'profile', 'exists', 'position' are not yet supported`);
-                        addDiagnostic({
-                            profileUrl: ctx.profileUrl || '',
-                            profileName: ctx.profileName || '',
-                            severity: 'warning',
-                            category: 'discriminator',
-                            elementPath: `${relPath}:${sliceLabel}`,
-                            message: `Slice "${sliceLabel}" on "${relPath}" has no pattern/value discriminator — only type/profile/exists/position which are not yet evaluable.`,
-                            impact: 'Strict validators may reject valid resources because they cannot match this slice discriminator.',
-                        });
+                            addDiagnostic({
+                                profileUrl: ctx.profileUrl || '',
+                                profileName: ctx.profileName || '',
+                                severity: 'warning',
+                                category: 'discriminator',
+                                elementPath: `${relPath}:${sliceLabel}`,
+                                message: `Slice "${sliceLabel}" on "${relPath}" has no pattern/value discriminator — only type/profile/exists/position which are not yet evaluable.`,
+                                impact: 'Strict validators may reject valid resources because they cannot match this slice discriminator.',
+                            });
+                        }
                     }
                 }
             }
@@ -382,3 +388,97 @@ function generatePatternCodingValidation(slice, relPath, errorPath, sliceLabel,
         }
     }
 }
+/**
+ * Detect whether a slice uses a `profile` discriminator on a `.resource` child.
+ * Returns the expected resourceType and profile URLs if found, undefined otherwise.
+ *
+ * Heuristic: the child field `<sliceElementId>.resource` with `profileUrls`
+ * indicates a profile-based entry slice.  The resource type is derived from
+ * the profile URL (last path segment, PascalCase) or the slice name itself
+ * when the profile URL belongs to a non-core IG.
+ */
+function detectProfileDiscriminator(slice, fields) {
+    const sliceElemId = (slice.elementId || slice.name).replace(/^[^.]+\./, '');
+    const resourceChild = fields.find(f => {
+        const fId = (f.elementId || f.name).replace(/^[^.]+\./, '');
+        return fId === `${sliceElemId}.resource`;
+    });
+    if (!resourceChild?.profileUrls?.length)
+        return undefined;
+    const profileUrls = resourceChild.profileUrls;
+    // Derive base resource type from the profile URL: the last path segment of a
+    // core FHIR profile IS the resource type (e.g., .../StructureDefinition/Patient → Patient).
+    // For IG-specific profiles (e.g., .../ch-core-composition), the slice name is
+    // typically the resource type (e.g., "Composition"), so prefer that.
+    const sliceName = slice.sliceName || '';
+    // Validate: slice name should start with uppercase and be a plausible resource type
+    if (/^[A-Z][a-zA-Z]+$/.test(sliceName)) {
+        return { resourceType: sliceName, profileUrls };
+    }
+    // Fallback: try to extract from profile URL
+    const profileUrl = profileUrls[0];
+    const lastSegment = profileUrl.split('/').pop() || '';
+    if (/^[A-Z][a-zA-Z]+$/.test(lastSegment)) {
+        return { resourceType: lastSegment, profileUrls };
+    }
+    return undefined;
+}
+/**
+ * Generate slice validation for profile-discriminated entry slices.
+ * Matches Bundle entries by `entry[i].resource.resourceType`, enforces min/max,
+ * and delegates to the profiled validator when the profile URL is in profileUrlToName.
+ */
+function generateProfileDiscriminatorValidation(slice, relPath, errorPath, sliceLabel, varName, min, match, out, ctx) {
+    const { resourceType, profileUrls } = match;
+    const max = typeof slice.max === 'number' && slice.max !== Infinity ? slice.max : undefined;
+    const parentPath = relPath.includes('.') ? relPath.split('.').slice(0, -1).join('.') : '';
+    const accessor = parentPath ? `(resource as any)?.${parentPath.replace(/\./g, '?.')}` : `resource.${relPath}`;
+    // For top-level entry slices, access resource.entry directly
+    const arrayAccessor = relPath === 'entry' || !relPath.includes('.') ? `resource.${relPath}` : accessor;
+    // Resolve profiled validator for delegation
+    let delegateInterfaceName;
+    if (ctx.profileUrlToName && ctx.validatorImports) {
+        for (const pUrl of profileUrls) {
+            const name = ctx.profileUrlToName.get(pUrl);
+            if (name && name !== ctx.profileName) {
+                delegateInterfaceName = name;
+                ctx.validatorImports.set(name, `./${name}.js`);
+                break;
+            }
+        }
+    }
+    // When delegating, annotate the array so .resource is accessible without casts
+    const entriesType = delegateInterfaceName ? ': Array<Record<string, any>>' : '';
+    let code = `
+  // Required slice validation for ${relPath}:${sliceLabel} (profile discriminator → ${resourceType})
+  {
+    const _${varName}Entries${entriesType} = (Array.isArray(${arrayAccessor}) ? ${arrayAccessor} : []).filter(
+      (e: any) => e?.resource?.resourceType === '${resourceType}'
+    );`;
+    if (min > 0) {
+        code += `
+    if (_${varName}Entries.length < ${min}) {
+      errors.push("Slice '${errorPath}:${sliceLabel}': a matching slice is required, but not found");
+    }`;
+    }
+    if (max !== undefined) {
+        code += `
+    if (_${varName}Entries.length > ${max}) {
+      errors.push("${errorPath}:${sliceLabel}: max allowed = ${max}, but found " + _${varName}Entries.length);
+    }`;
+    }
+    // Delegate to profiled validator for each matched entry
+    if (delegateInterfaceName) {
+        code += `
+    for (const _e of _${varName}Entries) {
+      if (_e.resource) {
+        const _sub = await validate${delegateInterfaceName}(_e.resource, options);
+        errors.push(..._sub.errors);
+        warnings.push(..._sub.warnings);
+      }
+    }`;
+    }
+    code += `
+  }`;
+    out.push(code);
+}

package/out/src/generator/emitters/validator/validatorBindingBuilder.js

@@ -49,7 +49,7 @@ export function buildBindingValidations(fields, fieldParentMap, arrayFieldPaths,
 // ── System-presence fallback ────────────────────────────────────────────────
 function emitSystemPresenceFallback(output, field, rel, isNested, arrayFieldPaths) {
     const type = field.type || field.baseTypeCode;
-    if (type !== 'CodeableConcept' && type !== 'Coding')
+    if (type !== 'CodeableConcept' && type !== 'Coding' && type !== 'Quantity')
         return;
     const vsUri = (field.binding.uri || '').split('|')[0];
     const vsDisplayName = vsUri.split('/').pop() || vsUri;
@@ -87,7 +87,7 @@ function emitTopLevelSystemPresence(output, field, rel, type, vsDisplayName, vsU
   }`);
         }
     }
-    else {
+    else if (type === 'Coding') {
         if (field.isArray) {
             output.push(`
   // Required binding system-presence fallback for ${rel} (Coding array, ValueSet unresolved)
@@ -111,11 +111,35 @@ function emitTopLevelSystemPresence(output, field, rel, type, vsDisplayName, vsU
   }`);
         }
     }
+    else if (type === 'Quantity') {
+        if (field.isArray) {
+            output.push(`
+  // Required binding system-presence fallback for ${rel} (Quantity array, ValueSet unresolved)
+  if (_bRes.${rel} && Array.isArray(_bRes.${rel})) {
+    for (const _spQ of _bRes.${rel}) {
+      const _q = _spQ as { code?: string; system?: string };
+      if (_q.code !== undefined && (_q.system === undefined || _q.system === '')) {
+        errors.push("The System URI could not be determined for the code '" + _q.code + "' in the ValueSet '${vsDisplayName}' (${vsUri})");
+      }
+    }
+  }`);
+        }
+        else {
+            output.push(`
+  // Required binding system-presence fallback for ${rel} (Quantity, ValueSet unresolved)
+  if (_bRes.${rel}) {
+    const _q = _bRes.${rel} as { code?: string; system?: string };
+    if (_q.code !== undefined && (_q.system === undefined || _q.system === '')) {
+      errors.push("The System URI could not be determined for the code '" + _q.code + "' in the ValueSet '${vsDisplayName}' (${vsUri})");
+    }
+  }`);
+        }
+    }
 }
 // ── System-only binding ─────────────────────────────────────────────────────
 function emitSystemOnlyBinding(output, field, rel, isNested, vsInfo, arrayFieldPaths) {
     const type = field.type || field.baseTypeCode;
-    if (type !== 'CodeableConcept' && type !== 'Coding')
+    if (type !== 'CodeableConcept' && type !== 'Coding' && type !== 'Quantity')
         return;
     const sysVsUri = (field.binding.uri || '').split('|')[0];
     const systemsLiteral = JSON.stringify(vsInfo.systems);
@@ -188,6 +212,32 @@ function emitTopLevelSystemOnly(output, field, rel, type, vsDisplayName, sysVsUr
   }`);
         }
     }
+    else if (type === 'Quantity') {
+        if (field.isArray) {
+            output.push(`
+  // Required ValueSet system-level binding validation for ${rel} (Quantity array)
+  if (_bRes.${rel} && Array.isArray(_bRes.${rel})) {
+    for (const _sysQ of _bRes.${rel}) {
+      const _q = _sysQ as { code?: string; system?: string };
+      const _allowedSystems = ${systemsLiteral};
+      if (_q.code !== undefined && _q.system !== undefined && !_allowedSystems.includes(_q.system)) {
+        errors.push("Code '" + _q.code + "' from system '" + _q.system + "' does not exist in the value set '${vsDisplayName}' (${sysVsUri}), but the binding is of strength 'required'");
+      }
+    }
+  }`);
+        }
+        else {
+            output.push(`
+  // Required ValueSet system-level binding validation for ${rel} (Quantity)
+  if (_bRes.${rel}) {
+    const _q = _bRes.${rel} as { code?: string; system?: string };
+    const _allowedSystems = ${systemsLiteral};
+    if (_q.code !== undefined && _q.system !== undefined && !_allowedSystems.includes(_q.system)) {
+      errors.push("Code '" + _q.code + "' from system '" + _q.system + "' does not exist in the value set '${vsDisplayName}' (${sysVsUri}), but the binding is of strength 'required'");
+    }
+  }`);
+        }
+    }
 }
 // ── Resolved code-level binding ─────────────────────────────────────────────
 function emitResolvedBinding(output, field, rel, isNested, vsInfo, arrayFieldPaths) {

package/out/src/generator/emitters/validator/validatorBindingLeafEmitters.js

@@ -74,7 +74,7 @@ export function emitSystemPresenceLeaf(leafAcc, indent, type, vsDisplayName, vsU
             code += `\n${indent}}`;
         }
     }
-    else {
+    else if (type === 'Coding') {
         if (isArray) {
             code += `\n${indent}if (${leafAcc} && Array.isArray(${leafAcc})) {`;
             indent += '  ';
@@ -99,6 +99,31 @@ export function emitSystemPresenceLeaf(leafAcc, indent, type, vsDisplayName, vsU
             code += `\n${indent}}`;
         }
     }
+    else if (type === 'Quantity') {
+        if (isArray) {
+            code += `\n${indent}if (${leafAcc} && Array.isArray(${leafAcc})) {`;
+            indent += '  ';
+            code += `\n${indent}for (const _spQ of ${leafAcc}) {`;
+        }
+        else {
+            code += `\n${indent}if (${leafAcc} !== undefined) {`;
+            indent += '  ';
+            code += `\n${indent}const _spQ = ${leafAcc};`;
+        }
+        indent += '  ';
+        code += `\n${indent}const _q = _spQ as { code?: string; system?: string };`;
+        code += `\n${indent}if (_q.code !== undefined && (_q.system === undefined || _q.system === '')) {`;
+        indent += '  ';
+        code += `\n${indent}errors.push("The System URI could not be determined for the code '" + _q.code + "' in the ValueSet '${vsDisplayName}' (${vsUri})");`;
+        indent = indent.slice(2);
+        code += `\n${indent}}`;
+        indent = indent.slice(2);
+        code += `\n${indent}}`;
+        if (isArray) {
+            indent = indent.slice(2);
+            code += `\n${indent}}`;
+        }
+    }
     return code;
 }
 export function emitSystemOnlyLeaf(leafAcc, indent, type, vsDisplayName, sysVsUri, systemsLiteral, isArray) {
@@ -177,6 +202,38 @@ export function emitSystemOnlyLeaf(leafAcc, indent, type, vsDisplayName, sysVsUr
             code += `\n${indent}}`;
         }
     }
+    else if (type === 'Quantity') {
+        if (isArray) {
+            code += `\n${indent}if (${leafAcc} && Array.isArray(${leafAcc})) {`;
+            indent += '  ';
+            code += `\n${indent}for (const _sysQ of ${leafAcc}) {`;
+            indent += '  ';
+            code += `\n${indent}const _q = _sysQ as { code?: string; system?: string };`;
+            code += `\n${indent}const _allowedSystems = ${systemsLiteral};`;
+            code += `\n${indent}if (_q.code !== undefined && _q.system !== undefined && !_allowedSystems.includes(_q.system)) {`;
+            indent += '  ';
+            code += `\n${indent}errors.push("Code '" + _q.code + "' from system '" + _q.system + "' does not exist in the value set '${vsDisplayName}' (${sysVsUri}), but the binding is of strength 'required'");`;
+            indent = indent.slice(2);
+            code += `\n${indent}}`;
+            indent = indent.slice(2);
+            code += `\n${indent}}`;
+            indent = indent.slice(2);
+            code += `\n${indent}}`;
+        }
+        else {
+            code += `\n${indent}{`;
+            indent += '  ';
+            code += `\n${indent}const _q = (${leafAcc} as any);`;
+            code += `\n${indent}const _allowedSystems = ${systemsLiteral};`;
+            code += `\n${indent}if (_q?.code !== undefined && _q?.system !== undefined && !_allowedSystems.includes(_q.system)) {`;
+            indent += '  ';
+            code += `\n${indent}errors.push("Code '" + _q.code + "' from system '" + _q.system + "' does not exist in the value set '${vsDisplayName}' (${sysVsUri}), but the binding is of strength 'required'");`;
+            indent = indent.slice(2);
+            code += `\n${indent}}`;
+            indent = indent.slice(2);
+            code += `\n${indent}}`;
+        }
+    }
     return code;
 }
 export function emitResolvedLeaf(leafAcc, indent, type, vsName, vsDisplayName, vsUri, isArray) {

package/out/src/generator/emitters/validator/validatorGenerator.js

@@ -27,8 +27,9 @@ export interface ValidatorOptions {
 }
 `;
 }
-export function generateValidateProfileFunction(interfaceName, fields, valueSets, profileUrl, baseResourceType) {
+export function generateValidateProfileFunction(interfaceName, fields, valueSets, profileUrl, baseResourceType, profileUrlToName) {
     const valueSetImports = new Map();
+    const validatorImports = new Map();
     // ── Collect field-level constraints ──────────────────────────────────────
     const constraintsWithContext = [];
     fields.forEach((field) => {
@@ -143,6 +144,7 @@ export function generateValidateProfileFunction(interfaceName, fields, valueSets
     const sliceValidations = generateSliceValidations({
         fields, fieldPathMap, arrayFieldPaths, getValueSetForBinding,
         valueSetImports, profileUrl, profileName: interfaceName, baseResourceType,
+        profileUrlToName, validatorImports,
     });
     const primitiveFormatValidations = buildPrimitiveFormatValidations(fields);
     const bundleRefValidation = generateBundleRefValidation(baseResourceType);
@@ -153,14 +155,23 @@ export function generateValidateProfileFunction(interfaceName, fields, valueSets
     const filteredConstraints = uniqueConstraints.filter(c => {
         const expr = c.constraint.expression || "";
         const fieldPath = c.fieldPath || "";
+        // Filter out text.div-related expressions (narrative HTML), XPath-style
+        // variables ($A…$Z), and value[x] type-discriminator patterns.
         if (/(text\.div\b|\.all\(div\b|\$[A-Z]|value\.[A-Z])/.test(expr))
             return false;
+        // Filter $this on choice-type fields — fhirpath scoping differs from HL7.
         if (c.isChoiceType && /\$this\b/.test(expr))
             return false;
+        // For nested fields (depth > 1), filter only base FHIR invariants whose
+        // evaluation diverges between fhirpath.js and HL7:
+        //   ele-1: hasValue() or (children().count() > id.count())
+        //   ext-1: extension.exists() != value.exists()
+        // Profile-specific constraints at nested depth are allowed through —
+        // the .all() wrapping handles scoping correctly for these.
         if (fieldPath && fieldPath.split('.').length > 1) {
-            const isSimpleExistenceCheck = /^[a-zA-Z.]+\.exists\(\)$/.test(expr);
-            const isSimpleCountCheck = /^[a-zA-Z.]+\.count\(\)\s*[<>=]+\s*\d+$/.test(expr);
-            if (!isSimpleExistenceCheck && !isSimpleCountCheck)
+            const isEle1 = /^hasValue\(\)\s+or\s+\(children\(\)\.count\(\)\s*>\s*id\.count\(\)\)$/.test(expr);
+            const isExt1 = /^extension\.exists\(\)\s*!=\s*value\.exists\(\)$/.test(expr);
+            if (isEle1 || isExt1)
                 return false;
         }
         return true;
@@ -198,20 +209,30 @@ export function generateValidateProfileFunction(interfaceName, fields, valueSets
             }
         }
         const needsTerminology = /\bmemberOf\b/.test(constraint.expression || '');
-        const needsResolve = /\bresolve\b/.test(constraint.expression || '');
         let evaluateBlock = `
     const result${index} = await fhirpath.evaluate(resource, "${escapedExpression}", { resource }, fhirpath_model, fhirpathOptions);
     if (!result${index}.every(Boolean)) {
       ${constraint.severity === "error" ? "errors" : "warnings"}.push("Constraint violation: ${escapedHuman}");
     }`;
+        // Gate memberOf() behind terminologyUrl.  For resolve(), use try/catch
+        // instead of a hard gate: FHIRPath `and` short-circuits, so expressions
+        // like `(A and resolve().is(X)) or (B and focus.exists().not())` can still
+        // evaluate the resolve-free branch when A is false.  If resolve() IS
+        // reached without a fhirServerUrl, fhirpath.js throws — catch it and
+        // degrade to a warning instead of silently skipping the entire constraint.
+        const needsResolve = /\bresolve\b/.test(constraint.expression || '');
         if (needsTerminology) {
             evaluateBlock = `
     if (options?.terminologyUrl) {${evaluateBlock}
+    } else {
+      warnings.push("Constraint not evaluated (no terminologyUrl): ${escapedHuman}");
     }`;
         }
         else if (needsResolve) {
             evaluateBlock = `
-    if (options?.fhirServerUrl) {${evaluateBlock}
+    try {${evaluateBlock}
+    } catch {
+      warnings.push("Constraint partially not evaluated (resolve requires fhirServerUrl): ${escapedHuman}");
     }`;
         }
         return evaluateBlock;
@@ -260,9 +281,15 @@ ${extensionStructuralValidation}${containedRefValidation}
             .map(([name, path]) => `import { isValid${name}Code } from '${path}';`)
             .join('\n') + '\n\n';
     }
+    let validatorImportStatements = '';
+    if (validatorImports.size > 0) {
+        validatorImportStatements = Array.from(validatorImports.entries())
+            .map(([name, importPath]) => `import { validate${name} } from '${importPath}';`)
+            .join('\n') + '\n\n';
+    }
     const fixedPatternValidations = patternValidations.map(v => v.replace(/if \(resource\.(\w+)\.(\w+)/g, (_match, parent, child) => `if (resource.${parent} && resource.${parent}.${child}`));
     return {
-        code: `${fhirpathImport}${optionsImport}${valueSetImportStatements}export async function validate${interfaceName}(resource: ${interfaceName}, options?: ValidatorOptions): Promise<{ errors: string[]; warnings: string[] }> {
+        code: `${fhirpathImport}${optionsImport}${valueSetImportStatements}${validatorImportStatements}export async function validate${interfaceName}(resource: ${interfaceName}, options?: ValidatorOptions): Promise<{ errors: string[]; warnings: string[] }> {
   const errors: string[] = [];
   const warnings: string[] = [];
   ${fhirpathOptionsBlock}

package/out/src/generator/emitters/validator/validatorTemplates.js

@@ -104,10 +104,14 @@ export function generateExtensionStructuralValidation() {
     return `
   // Base FHIR structural validation: extension.url required, ext-1 constraint, empty objects
   {
-    const _checkExtensions = (obj: unknown, path: string): void => {
+    const _checkExtensions = (obj: unknown, path: string, depth: number): void => {
       if (!obj || typeof obj !== 'object') return;
-      if (Array.isArray(obj)) { obj.forEach((item, i) => _checkExtensions(item, path + '[' + i + ']')); return; }
+      if (Array.isArray(obj)) { obj.forEach((item, i) => _checkExtensions(item, path + '[' + i + ']', depth + 1)); return; }
       const rec = obj as Record<string, unknown>;
+      // Empty object check — HL7 validates all FHIR elements must have content
+      if (depth > 0 && Object.keys(rec).length === 0) {
+        errors.push('Object must have some content');
+      }
       // Validate extension arrays
       for (const extKey of ['extension', 'modifierExtension'] as const) {
         const exts = rec[extKey];
@@ -115,11 +119,6 @@ export function generateExtensionStructuralValidation() {
           for (const ext of exts) {
             if (ext && typeof ext === 'object' && !Array.isArray(ext)) {
               const e = ext as Record<string, unknown>;
-              // Empty extension object check
-              if (Object.keys(e).length === 0) {
-                errors.push('Object must have some content');
-                continue;
-              }
               if (typeof e.url !== 'string' || !e.url) {
                 errors.push('Extension.url is required in order to identify, use and validate the extension');
               }
@@ -136,11 +135,11 @@ export function generateExtensionStructuralValidation() {
       // Recurse into child objects (skip primitive values)
       for (const [_key, _val] of Object.entries(rec)) {
         if (_val && typeof _val === 'object') {
-          _checkExtensions(_val, path + '.' + _key);
+          _checkExtensions(_val, path + '.' + _key, depth + 1);
         }
       }
     };
-    _checkExtensions(resource, '');
+    _checkExtensions(resource, '', 0);
   }
 `;
 }

package/out/src/generator/fhir/r4/base/well-known-system-codes.json

@@ -1,5 +1,5 @@
 {
-  "_description": "Curated sample codes for large external CodeSystems (LOINC, SNOMED CT, etc.) that cannot be shipped in full due to size or licensing. Used as fallback when the CodeSystem has content='not-present' to allow ValueSet resolution for core R4 ValueSets like observation-codes without requiring a terminology server.",
+  "_description": "Curated sample codes for large external CodeSystems (LOINC, SNOMED CT, etc.) and complete code sets for small core FHIR R4 CodeSystems that cannot be loaded from packages skipped by isLargeHl7Package (hl7.fhir.r4.core, hl7.terminology, etc.). Used as fallback to allow ValueSet resolution for core R4 ValueSets without requiring a terminology server.",
   "_valueSets": "Maps core R4 ValueSet canonical URLs to included CodeSystem URLs. Used when the dependency package containing the ValueSet is not cached locally.",
   "systems": {
     "http://loinc.org": [
@@ -91,6 +91,370 @@
       { "code": "failed", "display": "Failed" },
       { "code": "completed", "display": "Completed" },
       { "code": "entered-in-error", "display": "Entered in Error" }
+    ],
+    "http://hl7.org/fhir/event-status": [
+      { "code": "preparation", "display": "Preparation" },
+      { "code": "in-progress", "display": "In Progress" },
+      { "code": "not-done", "display": "Not Done" },
+      { "code": "on-hold", "display": "On Hold" },
+      { "code": "stopped", "display": "Stopped" },
+      { "code": "completed", "display": "Completed" },
+      { "code": "entered-in-error", "display": "Entered in Error" },
+      { "code": "unknown", "display": "Unknown" }
+    ],
+    "http://hl7.org/fhir/observation-status": [
+      { "code": "registered", "display": "Registered" },
+      { "code": "preliminary", "display": "Preliminary" },
+      { "code": "final", "display": "Final" },
+      { "code": "amended", "display": "Amended" },
+      { "code": "corrected", "display": "Corrected" },
+      { "code": "cancelled", "display": "Cancelled" },
+      { "code": "entered-in-error", "display": "Entered in Error" },
+      { "code": "unknown", "display": "Unknown" }
+    ],
+    "http://hl7.org/fhir/administrative-gender": [
+      { "code": "male", "display": "Male" },
+      { "code": "female", "display": "Female" },
+      { "code": "other", "display": "Other" },
+      { "code": "unknown", "display": "Unknown" }
+    ],
+    "http://hl7.org/fhir/encounter-status": [
+      { "code": "planned", "display": "Planned" },
+      { "code": "arrived", "display": "Arrived" },
+      { "code": "triaged", "display": "Triaged" },
+      { "code": "in-progress", "display": "In Progress" },
+      { "code": "onleave", "display": "On Leave" },
+      { "code": "finished", "display": "Finished" },
+      { "code": "cancelled", "display": "Cancelled" },
+      { "code": "entered-in-error", "display": "Entered in Error" },
+      { "code": "unknown", "display": "Unknown" }
+    ],
+    "http://hl7.org/fhir/request-status": [
+      { "code": "draft", "display": "Draft" },
+      { "code": "active", "display": "Active" },
+      { "code": "on-hold", "display": "On Hold" },
+      { "code": "revoked", "display": "Revoked" },
+      { "code": "completed", "display": "Completed" },
+      { "code": "entered-in-error", "display": "Entered in Error" },
+      { "code": "unknown", "display": "Unknown" }
+    ],
+    "http://hl7.org/fhir/narrative-status": [
+      { "code": "generated", "display": "Generated" },
+      { "code": "extensions", "display": "Extensions" },
+      { "code": "additional", "display": "Additional" },
+      { "code": "empty", "display": "Empty" }
+    ],
+    "http://hl7.org/fhir/composition-status": [
+      { "code": "preliminary", "display": "Preliminary" },
+      { "code": "final", "display": "Final" },
+      { "code": "amended", "display": "Amended" },
+      { "code": "entered-in-error", "display": "Entered in Error" }
+    ],
+    "http://hl7.org/fhir/document-reference-status": [
+      { "code": "current", "display": "Current" },
+      { "code": "superseded", "display": "Superseded" },
+      { "code": "entered-in-error", "display": "Entered in Error" }
+    ],
+    "http://hl7.org/fhir/list-status": [
+      { "code": "current", "display": "Current" },
+      { "code": "retired", "display": "Retired" },
+      { "code": "entered-in-error", "display": "Entered in Error" }
+    ],
+    "http://hl7.org/fhir/fm-status": [
+      { "code": "active", "display": "Active" },
+      { "code": "cancelled", "display": "Cancelled" },
+      { "code": "draft", "display": "Draft" },
+      { "code": "entered-in-error", "display": "Entered in Error" }
+    ],
+    "http://hl7.org/fhir/diagnostic-report-status": [
+      { "code": "registered", "display": "Registered" },
+      { "code": "partial", "display": "Partial" },
+      { "code": "preliminary", "display": "Preliminary" },
+      { "code": "final", "display": "Final" },
+      { "code": "amended", "display": "Amended" },
+      { "code": "corrected", "display": "Corrected" },
+      { "code": "appended", "display": "Appended" },
+      { "code": "cancelled", "display": "Cancelled" },
+      { "code": "entered-in-error", "display": "Entered in Error" },
+      { "code": "unknown", "display": "Unknown" }
+    ],
+    "http://hl7.org/fhir/bundle-type": [
+      { "code": "document", "display": "Document" },
+      { "code": "message", "display": "Message" },
+      { "code": "transaction", "display": "Transaction" },
+      { "code": "transaction-response", "display": "Transaction Response" },
+      { "code": "batch", "display": "Batch" },
+      { "code": "batch-response", "display": "Batch Response" },
+      { "code": "history", "display": "History List" },
+      { "code": "searchset", "display": "Search Results" },
+      { "code": "collection", "display": "Collection" }
+    ],
+    "http://hl7.org/fhir/allergy-intolerance-type": [
+      { "code": "allergy", "display": "Allergy" },
+      { "code": "intolerance", "display": "Intolerance" }
+    ],
+    "http://hl7.org/fhir/group-type": [
+      { "code": "person", "display": "Person" },
+      { "code": "animal", "display": "Animal" },
+      { "code": "practitioner", "display": "Practitioner" },
+      { "code": "device", "display": "Device" },
+      { "code": "medication", "display": "Medication" },
+      { "code": "substance", "display": "Substance" }
+    ],
+    "http://hl7.org/fhir/measure-report-status": [
+      { "code": "complete", "display": "Complete" },
+      { "code": "pending", "display": "Pending" },
+      { "code": "error", "display": "Error" }
+    ],
+    "http://hl7.org/fhir/measure-report-type": [
+      { "code": "individual", "display": "Individual" },
+      { "code": "subject-list", "display": "Subject List" },
+      { "code": "summary", "display": "Summary" },
+      { "code": "data-collection", "display": "Data Collection" }
+    ],
+    "http://hl7.org/fhir/goal-status": [
+      { "code": "proposed", "display": "Proposed" },
+      { "code": "planned", "display": "Planned" },
+      { "code": "accepted", "display": "Accepted" },
+      { "code": "active", "display": "Active" },
+      { "code": "on-hold", "display": "On Hold" },
+      { "code": "completed", "display": "Completed" },
+      { "code": "cancelled", "display": "Cancelled" },
+      { "code": "entered-in-error", "display": "Entered in Error" },
+      { "code": "rejected", "display": "Rejected" }
+    ],
+    "http://hl7.org/fhir/episode-of-care-status": [
+      { "code": "planned", "display": "Planned" },
+      { "code": "waitlist", "display": "Waitlist" },
+      { "code": "active", "display": "Active" },
+      { "code": "onhold", "display": "On Hold" },
+      { "code": "finished", "display": "Finished" },
+      { "code": "cancelled", "display": "Cancelled" },
+      { "code": "entered-in-error", "display": "Entered in Error" }
+    ],
+    "http://hl7.org/fhir/specimen-status": [
+      { "code": "available", "display": "Available" },
+      { "code": "unavailable", "display": "Unavailable" },
+      { "code": "unsatisfactory", "display": "Unsatisfactory" },
+      { "code": "entered-in-error", "display": "Entered in Error" }
+    ],
+    "http://hl7.org/fhir/flag-status": [
+      { "code": "active", "display": "Active" },
+      { "code": "inactive", "display": "Inactive" },
+      { "code": "entered-in-error", "display": "Entered in Error" }
+    ],
+    "http://hl7.org/fhir/address-use": [
+      { "code": "home", "display": "Home" },
+      { "code": "work", "display": "Work" },
+      { "code": "temp", "display": "Temp" },
+      { "code": "old", "display": "Old / Incorrect" },
+      { "code": "billing", "display": "Billing" }
+    ],
+    "http://hl7.org/fhir/address-type": [
+      { "code": "postal", "display": "Postal" },
+      { "code": "physical", "display": "Physical" },
+      { "code": "both", "display": "Postal & Physical" }
+    ],
+    "http://hl7.org/fhir/contact-point-system": [
+      { "code": "phone", "display": "Phone" },
+      { "code": "fax", "display": "Fax" },
+      { "code": "email", "display": "Email" },
+      { "code": "pager", "display": "Pager" },
+      { "code": "url", "display": "URL" },
+      { "code": "sms", "display": "SMS" },
+      { "code": "other", "display": "Other" }
+    ],
+    "http://hl7.org/fhir/contact-point-use": [
+      { "code": "home", "display": "Home" },
+      { "code": "work", "display": "Work" },
+      { "code": "temp", "display": "Temp" },
+      { "code": "old", "display": "Old" },
+      { "code": "mobile", "display": "Mobile" }
+    ],
+    "http://hl7.org/fhir/identifier-use": [
+      { "code": "usual", "display": "Usual" },
+      { "code": "official", "display": "Official" },
+      { "code": "temp", "display": "Temp" },
+      { "code": "secondary", "display": "Secondary" },
+      { "code": "old", "display": "Old" }
+    ],
+    "http://hl7.org/fhir/name-use": [
+      { "code": "usual", "display": "Usual" },
+      { "code": "official", "display": "Official" },
+      { "code": "temp", "display": "Temp" },
+      { "code": "nickname", "display": "Nickname" },
+      { "code": "anonymous", "display": "Anonymous" },
+      { "code": "old", "display": "Old" },
+      { "code": "maiden", "display": "Name changed for Marriage" }
+    ],
+    "http://hl7.org/fhir/link-type": [
+      { "code": "replaced-by", "display": "Replaced-by" },
+      { "code": "replaces", "display": "Replaces" },
+      { "code": "refer", "display": "Refer" },
+      { "code": "seealso", "display": "See also" }
+    ],
+    "http://hl7.org/fhir/account-status": [
+      { "code": "active", "display": "Active" },
+      { "code": "inactive", "display": "Inactive" },
+      { "code": "entered-in-error", "display": "Entered in Error" },
+      { "code": "on-hold", "display": "On Hold" },
+      { "code": "unknown", "display": "Unknown" }
+    ],
+    "http://hl7.org/fhir/consent-state-codes": [
+      { "code": "draft", "display": "Pending" },
+      { "code": "proposed", "display": "Proposed" },
+      { "code": "active", "display": "Active" },
+      { "code": "rejected", "display": "Rejected" },
+      { "code": "inactive", "display": "Inactive" },
+      { "code": "entered-in-error", "display": "Entered in Error" }
+    ],
+    "http://hl7.org/fhir/substance-status": [
+      { "code": "active", "display": "Active" },
+      { "code": "inactive", "display": "Inactive" },
+      { "code": "entered-in-error", "display": "Entered in Error" }
+    ],
+    "http://hl7.org/fhir/questionnaire-answers-status": [
+      { "code": "in-progress", "display": "In Progress" },
+      { "code": "completed", "display": "Completed" },
+      { "code": "amended", "display": "Amended" },
+      { "code": "entered-in-error", "display": "Entered in Error" },
+      { "code": "stopped", "display": "Stopped" }
+    ],
+    "http://hl7.org/fhir/item-type": [
+      { "code": "group", "display": "Group" },
+      { "code": "display", "display": "Display" },
+      { "code": "question", "display": "Question" },
+      { "code": "boolean", "display": "Boolean" },
+      { "code": "decimal", "display": "Decimal" },
+      { "code": "integer", "display": "Integer" },
+      { "code": "date", "display": "Date" },
+      { "code": "dateTime", "display": "Date Time" },
+      { "code": "time", "display": "Time" },
+      { "code": "string", "display": "String" },
+      { "code": "text", "display": "Text" },
+      { "code": "url", "display": "Url" },
+      { "code": "choice", "display": "Choice" },
+      { "code": "open-choice", "display": "Open Choice" },
+      { "code": "attachment", "display": "Attachment" },
+      { "code": "reference", "display": "Reference" },
+      { "code": "quantity", "display": "Quantity" }
+    ],
+    "http://hl7.org/fhir/http-verb": [
+      { "code": "GET", "display": "GET" },
+      { "code": "HEAD", "display": "HEAD" },
+      { "code": "POST", "display": "POST" },
+      { "code": "PUT", "display": "PUT" },
+      { "code": "DELETE", "display": "DELETE" },
+      { "code": "PATCH", "display": "PATCH" }
+    ],
+    "http://hl7.org/fhir/capability-statement-kind": [
+      { "code": "instance", "display": "Instance" },
+      { "code": "capability", "display": "Capability" },
+      { "code": "requirements", "display": "Requirements" }
+    ],
+    "http://hl7.org/fhir/restful-capability-mode": [
+      { "code": "client", "display": "Client" },
+      { "code": "server", "display": "Server" }
+    ],
+    "http://hl7.org/fhir/search-param-type": [
+      { "code": "number", "display": "Number" },
+      { "code": "date", "display": "Date/DateTime" },
+      { "code": "string", "display": "String" },
+      { "code": "token", "display": "Token" },
+      { "code": "reference", "display": "Reference" },
+      { "code": "composite", "display": "Composite" },
+      { "code": "quantity", "display": "Quantity" },
+      { "code": "uri", "display": "URI" },
+      { "code": "special", "display": "Special" }
+    ],
+    "http://hl7.org/fhir/filter-operator": [
+      { "code": "=", "display": "Equals" },
+      { "code": "is-a", "display": "Is A (by subsumption)" },
+      { "code": "descendent-of", "display": "Descendent Of (by subsumption)" },
+      { "code": "is-not-a", "display": "Not (Is A) (by subsumption)" },
+      { "code": "regex", "display": "Regular Expression" },
+      { "code": "in", "display": "Not in Set" },
+      { "code": "not-in", "display": "Not in Set" },
+      { "code": "generalizes", "display": "Generalizes (by Subsumption)" },
+      { "code": "exists", "display": "Exists" }
+    ],
+    "http://hl7.org/fhir/CodeSystem/medicationrequest-status": [
+      { "code": "active", "display": "Active" },
+      { "code": "on-hold", "display": "On Hold" },
+      { "code": "cancelled", "display": "Cancelled" },
+      { "code": "completed", "display": "Completed" },
+      { "code": "entered-in-error", "display": "Entered in Error" },
+      { "code": "stopped", "display": "Stopped" },
+      { "code": "draft", "display": "Draft" },
+      { "code": "unknown", "display": "Unknown" }
+    ],
+    "http://hl7.org/fhir/CodeSystem/medication-status": [
+      { "code": "active", "display": "Active" },
+      { "code": "inactive", "display": "Inactive" },
+      { "code": "entered-in-error", "display": "Entered in Error" }
+    ],
+    "http://hl7.org/fhir/CodeSystem/medication-admin-status": [
+      { "code": "in-progress", "display": "In Progress" },
+      { "code": "not-done", "display": "Not Done" },
+      { "code": "on-hold", "display": "On Hold" },
+      { "code": "completed", "display": "Completed" },
+      { "code": "entered-in-error", "display": "Entered in Error" },
+      { "code": "stopped", "display": "Stopped" },
+      { "code": "unknown", "display": "Unknown" }
+    ],
+    "http://hl7.org/fhir/CodeSystem/medicationdispense-status": [
+      { "code": "preparation", "display": "Preparation" },
+      { "code": "in-progress", "display": "In Progress" },
+      { "code": "cancelled", "display": "Cancelled" },
+      { "code": "on-hold", "display": "On Hold" },
+      { "code": "completed", "display": "Completed" },
+      { "code": "entered-in-error", "display": "Entered in Error" },
+      { "code": "stopped", "display": "Stopped" },
+      { "code": "declined", "display": "Declined" },
+      { "code": "unknown", "display": "Unknown" }
+    ],
+    "http://hl7.org/fhir/request-intent": [
+      { "code": "proposal", "display": "Proposal" },
+      { "code": "plan", "display": "Plan" },
+      { "code": "directive", "display": "Directive" },
+      { "code": "order", "display": "Order" },
+      { "code": "original-order", "display": "Original Order" },
+      { "code": "reflex-order", "display": "Reflex Order" },
+      { "code": "filler-order", "display": "Filler Order" },
+      { "code": "instance-order", "display": "Instance Order" },
+      { "code": "option", "display": "Option" }
+    ],
+    "http://hl7.org/fhir/request-priority": [
+      { "code": "routine", "display": "Routine" },
+      { "code": "urgent", "display": "Urgent" },
+      { "code": "asap", "display": "ASAP" },
+      { "code": "stat", "display": "STAT" }
+    ],
+    "http://hl7.org/fhir/care-plan-activity-status": [
+      { "code": "not-started", "display": "Not Started" },
+      { "code": "scheduled", "display": "Scheduled" },
+      { "code": "in-progress", "display": "In Progress" },
+      { "code": "on-hold", "display": "On Hold" },
+      { "code": "completed", "display": "Completed" },
+      { "code": "cancelled", "display": "Cancelled" },
+      { "code": "stopped", "display": "Stopped" },
+      { "code": "unknown", "display": "Unknown" },
+      { "code": "entered-in-error", "display": "Entered in Error" }
+    ],
+    "http://hl7.org/fhir/quantity-comparator": [
+      { "code": "<", "display": "Less than" },
+      { "code": "<=", "display": "Less or Equal to" },
+      { "code": ">=", "display": "Greater or Equal to" },
+      { "code": ">", "display": "Greater than" }
+    ],
+    "http://hl7.org/fhir/days-of-week": [
+      { "code": "mon", "display": "Monday" },
+      { "code": "tue", "display": "Tuesday" },
+      { "code": "wed", "display": "Wednesday" },
+      { "code": "thu", "display": "Thursday" },
+      { "code": "fri", "display": "Friday" },
+      { "code": "sat", "display": "Saturday" },
+      { "code": "sun", "display": "Sunday" }
     ]
   },
   "valueSets": {
@@ -103,6 +467,53 @@
     "http://hl7.org/fhir/ValueSet/namingsystem-type": ["http://hl7.org/fhir/namingsystem-type"],
     "http://hl7.org/fhir/ValueSet/namingsystem-identifier-type": ["http://hl7.org/fhir/namingsystem-identifier-type"],
     "http://hl7.org/fhir/ValueSet/publication-status": ["http://hl7.org/fhir/publication-status"],
-    "http://hl7.org/fhir/ValueSet/task-status": ["http://hl7.org/fhir/task-status"]
+    "http://hl7.org/fhir/ValueSet/task-status": ["http://hl7.org/fhir/task-status"],
+    "http://hl7.org/fhir/ValueSet/event-status": ["http://hl7.org/fhir/event-status"],
+    "http://hl7.org/fhir/ValueSet/immunization-status": ["http://hl7.org/fhir/event-status"],
+    "http://hl7.org/fhir/ValueSet/observation-status": ["http://hl7.org/fhir/observation-status"],
+    "http://hl7.org/fhir/ValueSet/administrative-gender": ["http://hl7.org/fhir/administrative-gender"],
+    "http://hl7.org/fhir/ValueSet/encounter-status": ["http://hl7.org/fhir/encounter-status"],
+    "http://hl7.org/fhir/ValueSet/request-status": ["http://hl7.org/fhir/request-status"],
+    "http://hl7.org/fhir/ValueSet/narrative-status": ["http://hl7.org/fhir/narrative-status"],
+    "http://hl7.org/fhir/ValueSet/composition-status": ["http://hl7.org/fhir/composition-status"],
+    "http://hl7.org/fhir/ValueSet/document-reference-status": ["http://hl7.org/fhir/document-reference-status"],
+    "http://hl7.org/fhir/ValueSet/list-status": ["http://hl7.org/fhir/list-status"],
+    "http://hl7.org/fhir/ValueSet/fm-status": ["http://hl7.org/fhir/fm-status"],
+    "http://hl7.org/fhir/ValueSet/diagnostic-report-status": ["http://hl7.org/fhir/diagnostic-report-status"],
+    "http://hl7.org/fhir/ValueSet/bundle-type": ["http://hl7.org/fhir/bundle-type"],
+    "http://hl7.org/fhir/ValueSet/allergy-intolerance-type": ["http://hl7.org/fhir/allergy-intolerance-type"],
+    "http://hl7.org/fhir/ValueSet/group-type": ["http://hl7.org/fhir/group-type"],
+    "http://hl7.org/fhir/ValueSet/measure-report-status": ["http://hl7.org/fhir/measure-report-status"],
+    "http://hl7.org/fhir/ValueSet/measure-report-type": ["http://hl7.org/fhir/measure-report-type"],
+    "http://hl7.org/fhir/ValueSet/goal-status": ["http://hl7.org/fhir/goal-status"],
+    "http://hl7.org/fhir/ValueSet/episode-of-care-status": ["http://hl7.org/fhir/episode-of-care-status"],
+    "http://hl7.org/fhir/ValueSet/specimen-status": ["http://hl7.org/fhir/specimen-status"],
+    "http://hl7.org/fhir/ValueSet/flag-status": ["http://hl7.org/fhir/flag-status"],
+    "http://hl7.org/fhir/ValueSet/address-use": ["http://hl7.org/fhir/address-use"],
+    "http://hl7.org/fhir/ValueSet/address-type": ["http://hl7.org/fhir/address-type"],
+    "http://hl7.org/fhir/ValueSet/contact-point-system": ["http://hl7.org/fhir/contact-point-system"],
+    "http://hl7.org/fhir/ValueSet/contact-point-use": ["http://hl7.org/fhir/contact-point-use"],
+    "http://hl7.org/fhir/ValueSet/identifier-use": ["http://hl7.org/fhir/identifier-use"],
+    "http://hl7.org/fhir/ValueSet/name-use": ["http://hl7.org/fhir/name-use"],
+    "http://hl7.org/fhir/ValueSet/link-type": ["http://hl7.org/fhir/link-type"],
+    "http://hl7.org/fhir/ValueSet/account-status": ["http://hl7.org/fhir/account-status"],
+    "http://hl7.org/fhir/ValueSet/consent-state-codes": ["http://hl7.org/fhir/consent-state-codes"],
+    "http://hl7.org/fhir/ValueSet/substance-status": ["http://hl7.org/fhir/substance-status"],
+    "http://hl7.org/fhir/ValueSet/questionnaire-answers-status": ["http://hl7.org/fhir/questionnaire-answers-status"],
+    "http://hl7.org/fhir/ValueSet/item-type": ["http://hl7.org/fhir/item-type"],
+    "http://hl7.org/fhir/ValueSet/http-verb": ["http://hl7.org/fhir/http-verb"],
+    "http://hl7.org/fhir/ValueSet/capability-statement-kind": ["http://hl7.org/fhir/capability-statement-kind"],
+    "http://hl7.org/fhir/ValueSet/restful-capability-mode": ["http://hl7.org/fhir/restful-capability-mode"],
+    "http://hl7.org/fhir/ValueSet/search-param-type": ["http://hl7.org/fhir/search-param-type"],
+    "http://hl7.org/fhir/ValueSet/filter-operator": ["http://hl7.org/fhir/filter-operator"],
+    "http://hl7.org/fhir/ValueSet/medicationrequest-status": ["http://hl7.org/fhir/CodeSystem/medicationrequest-status"],
+    "http://hl7.org/fhir/ValueSet/medication-status": ["http://hl7.org/fhir/CodeSystem/medication-status"],
+    "http://hl7.org/fhir/ValueSet/medication-admin-status": ["http://hl7.org/fhir/CodeSystem/medication-admin-status"],
+    "http://hl7.org/fhir/ValueSet/medicationdispense-status": ["http://hl7.org/fhir/CodeSystem/medicationdispense-status"],
+    "http://hl7.org/fhir/ValueSet/request-intent": ["http://hl7.org/fhir/request-intent"],
+    "http://hl7.org/fhir/ValueSet/request-priority": ["http://hl7.org/fhir/request-priority"],
+    "http://hl7.org/fhir/ValueSet/care-plan-activity-status": ["http://hl7.org/fhir/care-plan-activity-status"],
+    "http://hl7.org/fhir/ValueSet/quantity-comparator": ["http://hl7.org/fhir/quantity-comparator"],
+    "http://hl7.org/fhir/ValueSet/days-of-week": ["http://hl7.org/fhir/days-of-week"]
   }
 }

package/out/src/generator/parser/packageParser.js

@@ -356,7 +356,7 @@ export async function createPackageFromDir(sourceDir, outFile) {
  * a map of CodeSystem URL → concept[].  This allows ValueSet resolution for
  * compose.include entries that reference a whole system without listing concepts.
  */
-export function readCodeSystemConceptsFromDir(extractedRoot) {
+export function readCodeSystemConceptsFromDir(extractedRoot, maxConceptCount) {
     const jsonFiles = findJsonFilesByPrefix(extractedRoot, 'CodeSystem-');
     const map = {};
     for (const file of jsonFiles) {
@@ -371,6 +371,9 @@ export function readCodeSystemConceptsFromDir(extractedRoot) {
             if (content.content !== 'complete')
                 continue;
             const concepts = flattenCodeSystemConcepts(content.concept);
+            // When a cap is set (large-package selective loading), skip huge CodeSystems
+            if (maxConceptCount !== undefined && concepts.length > maxConceptCount)
+                continue;
             if (concepts.length > 0) {
                 map[url] = concepts;
             }
@@ -570,6 +573,13 @@ export async function ensureDependenciesDownloaded(extractedRoot) {
  * Core SDs are derived via `deriveVersionData()` / bundled base definitions.
  * Extensions and terminology resources are fetched on-demand as needed.
  */
+/**
+ * Maximum number of flattened concepts a CodeSystem may have to be loaded from
+ * a large HL7 package during selective loading.  973 of the 1 054 complete
+ * CodeSystems in hl7.fhir.r4.core have ≤ 20 concepts; a cap of 500 captures
+ * every practically-used VS while keeping memory bounded.
+ */
+const LARGE_PKG_MAX_CONCEPTS = 500;
 export function isLargeHl7Package(depName) {
     // hl7.terminology.r5, hl7.terminology.r4, etc. — large CodeSystem/ValueSet packages
     if (depName.startsWith('hl7.terminology'))
@@ -667,11 +677,20 @@ export function readValueSetCodesWithDependencies(extractedRoot) {
             const pkgJson = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf-8'));
             const deps = pkgJson.dependencies || {};
             for (const [depName, depVersion] of Object.entries(deps)) {
-                if (isLargeHl7Package(depName))
-                    continue;
                 const depDir = path.join(cacheDir, `${depName}@${depVersion}`);
-                if (fs.existsSync(depDir))
+                if (!fs.existsSync(depDir))
+                    continue;
+                if (isLargeHl7Package(depName)) {
+                    // Selectively load small CodeSystems from large packages
+                    const smallCs = readCodeSystemConceptsFromDir(depDir, LARGE_PKG_MAX_CONCEPTS);
+                    for (const [url, concepts] of Object.entries(smallCs)) {
+                        if (!mergedCodeSystems[url])
+                            mergedCodeSystems[url] = concepts;
+                    }
+                }
+                else {
                     collectCodeSystems(depDir);
+                }
             }
         }
         catch { /* skip */ }
@@ -715,11 +734,19 @@ export function readValueSetCodesWithDependencies(extractedRoot) {
             const pkgJson = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf-8'));
             const deps = pkgJson.dependencies || {};
             for (const [depName, depVersion] of Object.entries(deps)) {
-                if (isLargeHl7Package(depName))
-                    continue;
                 // Look for dependency in cache: name@version format
                 const depDir = path.join(cacheDir, `${depName}@${depVersion}`);
-                if (fs.existsSync(depDir)) {
+                if (!fs.existsSync(depDir))
+                    continue;
+                if (isLargeHl7Package(depName)) {
+                    // Selectively load ValueSets from large packages (CodeSystems already loaded in pass 1)
+                    const vsCodes = readValueSetCodesFromDir(depDir, mergedCodeSystems);
+                    for (const [uri, codeBucket] of Object.entries(vsCodes)) {
+                        if (!merged[uri])
+                            merged[uri] = codeBucket;
+                    }
+                }
+                else {
                     log.info(`Loading ValueSets from dependency: ${depName}@${depVersion}`);
                     loadPackageAndDeps(depDir);
                 }

package/out/src/generator/parser/sdParser.js

@@ -463,7 +463,7 @@ export async function parseStructureDefinition(structureDefinition, fhirServerUr
     // Post-processing: Aggregate required slices onto parent array fields
     // This populates requiredSlices on array fields that have slices with min >= 1
     // Pass both newFields and baseFields so we can find parent fields from base profiles
-    await aggregateRequiredSlices(newFields, baseFields);
+    await aggregateRequiredSlices(newFields, baseFields, valueSetCodesMap);
     return { newFields, oldFields: baseFields };
 }
 // NOTE: buildFhirChildTypeMap was removed - now using pre-generated fhirDataTypes.json instead

package/out/src/generator/parser/sliceAggregator.js

@@ -103,8 +103,9 @@ export function synthesizeSlicePatternsFromChildren(fields) {
  *
  * @param fields - The new fields from the differential (slices are defined here)
  * @param baseFields - Optional fields from base profiles (parent array fields may be here)
+ * @param valueSetCodesMap - Resolved ValueSet→codes map for IG-specific bindings
  */
-export async function aggregateRequiredSlices(fields, baseFields = []) {
+export async function aggregateRequiredSlices(fields, baseFields = [], valueSetCodesMap) {
     const allFields = [...fields, ...baseFields];
     const slicesByParentPath = new Map();
     for (const field of fields) {
@@ -264,7 +265,14 @@ export async function aggregateRequiredSlices(fields, baseFields = []) {
                                     elemAny.patternString;
                                 const isChoiceElement = /^value\[x\]$/i.test(childPath);
                                 const bindingUri = elem.binding?.valueSet;
-                                const resolvedDefault = bindingUri ? resolveValueSetDefault(bindingUri) : undefined;
+                                let resolvedDefault = bindingUri ? resolveValueSetDefault(bindingUri) : undefined;
+                                if (!resolvedDefault && bindingUri && valueSetCodesMap) {
+                                    const bare = bindingUri.split('|')[0];
+                                    const codes = valueSetCodesMap[bare] ?? valueSetCodesMap[bindingUri];
+                                    if (codes?.length) {
+                                        resolvedDefault = { code: codes[0].code, system: codes[0].system };
+                                    }
+                                }
                                 const isSimpleExtension = isChoiceElement && elem.type?.length &&
                                     typeProfile?.type === 'Extension' &&
                                     !profileElements.some(pe => pe.path === 'Extension.extension' && pe.sliceName);

package/out/src/generator/parser/vsParser.js

@@ -19,6 +19,7 @@ export function parseValueSet(valueSet) {
     const concepts = [];
     // Collect system URIs from compose.include for system-level validation
     const systems = [];
+    let hasFilter = false;
     // Parse compose.include sections
     if (vs.compose?.include) {
         for (const include of vs.compose.include) {
@@ -36,18 +37,11 @@ export function parseValueSet(valueSet) {
                 }
             }
             // Filter-based inclusion (e.g., all codes from a system)
+            // We can't enumerate filter codes at build time, but we keep any
+            // explicit concepts from other includes and still process expansion below.
             if (include.filter) {
-                // For filter-based ValueSets, we can't enumerate codes at build time
-                // Mark as large to skip union type generation
-                log.debug(`ValueSet ${name} uses filters, skipping union type generation`);
-                return {
-                    url: url || '',
-                    name: name || 'Unknown',
-                    concepts: [],
-                    size: Infinity,
-                    isSmall: false,
-                    systems: systems.length > 0 ? systems : undefined,
-                };
+                hasFilter = true;
+                log.debug(`ValueSet ${name} uses filters, union type generation skipped`);
             }
         }
     }
@@ -61,8 +55,11 @@ export function parseValueSet(valueSet) {
             });
         }
     }
-    const size = concepts.length;
-    const isSmall = size > 0 && size <= ctx().valueSetThresholds.UNION_TYPE;
+    // When filters are present, the concept list may be incomplete.
+    // Use Infinity size to prevent union type generation, but still expose
+    // whatever concepts we did collect (explicit + expansion) for binding validation.
+    const size = hasFilter ? Infinity : concepts.length;
+    const isSmall = !hasFilter && concepts.length > 0 && concepts.length <= ctx().valueSetThresholds.UNION_TYPE;
     return {
         url: url || '',
         name: name || 'Unknown',

package/out/src/generator/sdProcessor.js

@@ -153,7 +153,7 @@ export async function processStructureDefinition(sd, ctx) {
     finalInterfaceContent = dedupedLines.join('\n');
     // ── Required fields ──────────────────────────────────────────────
     const merged = mergeFields(aligned.alignedNewFields, parsed.oldFields);
-    const validateResult = generateValidateProfileFunction(interfaceName, merged, valueSets, sd.url, sd.type);
+    const validateResult = generateValidateProfileFunction(interfaceName, merged, valueSets, sd.url, sd.type, profileUrlToName);
     const validateFn = validateResult.code;
     const candidateRequiredFields = [...aligned.alignedNewFields, ...parsed.oldFields];
     const profileDiffFieldNames = new Set(aligned.alignedNewFields.map(f => f.name));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "babelfhir-ts",
-  "version": "1.3.4",
+  "version": "1.3.6",
   "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",