babelfhir-ts 1.5.21 → 1.6.1

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

@@ -78,6 +78,34 @@ export function resolveWellKnownValueSetCodes(valueSetCodesMap) {
         log.info(`Resolved ${resolved} core ValueSets from well-known system codes (no tx server needed)`);
     }
 }
+/**
+ * Drop the codes a ValueSet's `compose.exclude` removes, returning what survives.
+ *
+ * Concept excludes drop the listed system|code pairs. Filter excludes cover `is-a`
+ * only, by dropping the named code itself: the full hierarchy is not available
+ * here, and that is the case published IGs actually rely on.
+ */
+function applyComposeExcludes(bucket, excludes) {
+    if (!Array.isArray(excludes))
+        return bucket;
+    let kept = bucket;
+    for (const excl of excludes) {
+        if (Array.isArray(excl.concept)) {
+            const dropped = new Set(excl.concept.map(c => `${excl.system || ''}|${c.code}`));
+            kept = kept.filter(e => !dropped.has(`${e.system || ''}|${e.code}`));
+        }
+        if (Array.isArray(excl.filter)) {
+            for (const f of excl.filter) {
+                if (f.op !== 'is-a' || !f.value)
+                    continue;
+                const code = f.value;
+                const system = excl.system || '';
+                kept = kept.filter(e => !(e.code === code && (e.system || '') === system));
+            }
+        }
+    }
+    return kept;
+}
 /**
  * Resolve ValueSets that use compose.include with valueSet references (include-by-valueSet)
  * and/or compose.exclude entries. These can't be resolved during the initial per-package pass
@@ -136,37 +164,11 @@ function resolveValueSetCompose(visitedDirs, merged) {
                         }
                     }
                 }
-                // Apply compose.exclude — remove specific codes
-                if (content.compose.exclude && Array.isArray(content.compose.exclude)) {
-                    for (const excl of content.compose.exclude) {
-                        if (excl.concept && Array.isArray(excl.concept)) {
-                            const excludeSet = new Set(excl.concept.map((c) => `${excl.system || ''}|${c.code}`));
-                            for (let i = bucket.length - 1; i >= 0; i--) {
-                                if (excludeSet.has(`${bucket[i].system || ''}|${bucket[i].code}`)) {
-                                    bucket.splice(i, 1);
-                                }
-                            }
-                        }
-                        // Filter-based exclude: handle is-a by removing the specified code
-                        if (excl.filter && Array.isArray(excl.filter)) {
-                            for (const f of excl.filter) {
-                                if (f.op === 'is-a' && f.value) {
-                                    const excludeCode = f.value;
-                                    const excludeSystem = excl.system || '';
-                                    for (let i = bucket.length - 1; i >= 0; i--) {
-                                        if (bucket[i].code === excludeCode && (bucket[i].system || '') === excludeSystem) {
-                                            bucket.splice(i, 1);
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-                if (bucket.length > 0) {
-                    merged[canonical] = bucket;
+                const kept = applyComposeExcludes(bucket, content.compose.exclude);
+                if (kept.length > 0) {
+                    merged[canonical] = kept;
                     resolved++;
-                    log.info(`Resolved ValueSet ${canonical} via compose references (${bucket.length} codes)`);
+                    log.info(`Resolved ValueSet ${canonical} via compose references (${kept.length} codes)`);
                 }
             }
             catch { /* skip */ }
@@ -240,10 +242,11 @@ export function detectFhirVersion(extractedRoot) {
             const content = JSON.parse(fs.readFileSync(file, 'utf-8'));
             if (content.resourceType === 'ImplementationGuide') {
                 const versions = Array.isArray(content.fhirVersion) ? content.fhirVersion : [];
-                if (versions.length > 0) {
-                    const slug = FHIR_VERSION_TO_SLUG[versions[0]];
+                const [declared] = versions;
+                if (declared) {
+                    const slug = FHIR_VERSION_TO_SLUG[declared];
                     if (slug) {
-                        log.info(`Auto-detected FHIR version ${versions[0]} (${slug}) from ImplementationGuide`);
+                        log.info(`Auto-detected FHIR version ${declared} (${slug}) from ImplementationGuide`);
                         return slug;
                     }
                 }
@@ -432,6 +435,7 @@ export function readValueSetCodesFromDir(extractedRoot, codeSystemMap) {
             if (!canonical)
                 continue;
             const bucket = [];
+            let kept = bucket;
             // Prefer expansion if present (already resolved codes)
             if (content.expansion && Array.isArray(content.expansion.contains)) {
                 for (const c of content.expansion.contains) {
@@ -458,38 +462,10 @@ export function readValueSetCodesFromDir(extractedRoot, codeSystemMap) {
                         }
                     }
                 }
-                // Apply compose.exclude — remove codes that should be excluded
-                if (content.compose.exclude && Array.isArray(content.compose.exclude)) {
-                    for (const excl of content.compose.exclude) {
-                        // Concept-based exclude: remove explicitly listed codes
-                        if (excl.concept && Array.isArray(excl.concept)) {
-                            const excludeSet = new Set(excl.concept.map((c) => `${excl.system || ''}|${c.code}`));
-                            for (let i = bucket.length - 1; i >= 0; i--) {
-                                if (excludeSet.has(`${bucket[i].system || ''}|${bucket[i].code}`)) {
-                                    bucket.splice(i, 1);
-                                }
-                            }
-                        }
-                        // Filter-based exclude: handle is-a filter by removing the specified code
-                        // (full hierarchy traversal is not available; this covers the common case)
-                        if (excl.filter && Array.isArray(excl.filter)) {
-                            for (const f of excl.filter) {
-                                if (f.op === 'is-a' && f.value) {
-                                    const excludeCode = f.value;
-                                    const excludeSystem = excl.system || '';
-                                    for (let i = bucket.length - 1; i >= 0; i--) {
-                                        if (bucket[i].code === excludeCode && (bucket[i].system || '') === excludeSystem) {
-                                            bucket.splice(i, 1);
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
+                kept = applyComposeExcludes(bucket, content.compose.exclude);
             }
-            if (bucket.length) {
-                map[canonical] = bucket;
+            if (kept.length) {
+                map[canonical] = kept;
             }
         }
         catch (err) {
@@ -498,6 +474,20 @@ export function readValueSetCodesFromDir(extractedRoot, codeSystemMap) {
     }
     return map;
 }
+/**
+ * Whether a `dependencies` entry names a FHIR package at a concrete version.
+ *
+ * A FHIR IG manifest lists unscoped names pinned to exact versions. An npm
+ * scope or a semver range means the manifest being read is not an IG's — and
+ * the cache path built from it is unwritable (`<cache>/@types/fhir->=0.0.44
+ * <0.1.0.tgz`), which surfaced as an unhandled rejection from the download
+ * stream and took the whole run down instead of skipping one entry.
+ */
+export function isFhirPackageSpec(depName, depVersion) {
+    if (depName.startsWith('@'))
+        return false;
+    return /^[A-Za-z0-9][A-Za-z0-9.\-+]*$/.test(depVersion);
+}
 /**
  * Recursively ensure all dependency packages are downloaded and extracted.
  * Walks the dependency tree from an extracted package's package.json,
@@ -508,6 +498,10 @@ export async function ensureDependenciesDownloaded(extractedRoot) {
     ensureCacheDir(cacheDir);
     const visited = new Set();
     async function downloadAndExtract(depName, depVersion) {
+        if (!isFhirPackageSpec(depName, depVersion)) {
+            log.warn(`Ignoring dependency that is not a FHIR package spec: ${depName}@${depVersion}`);
+            return null;
+        }
         const depDir = path.join(cacheDir, `${depName}@${depVersion}`);
         // Already cached (@ separator)?
         if (fs.existsSync(depDir) && fs.readdirSync(depDir).length > 0) {
@@ -824,6 +818,64 @@ export function readValueSetsFromDir(extractedRoot) {
     }
     return map;
 }
+/**
+ * Read all NamingSystem resources from an extracted package directory.
+ *
+ * Entries with no `uniqueId` are dropped: there is nothing to emit for them.
+ */
+export function readNamingSystemsFromDir(extractedRoot) {
+    const jsonFiles = findJsonFilesByPrefix(extractedRoot, 'NamingSystem-');
+    const found = [];
+    let skippedRetired = 0;
+    let skippedNoId = 0;
+    for (const file of jsonFiles) {
+        try {
+            const content = JSON.parse(fs.readFileSync(file, 'utf-8'));
+            if (content.resourceType !== 'NamingSystem')
+                continue;
+            if (content.status === 'retired') {
+                skippedRetired++;
+                continue;
+            }
+            const uniqueIds = (Array.isArray(content.uniqueId) ? content.uniqueId : [])
+                .filter((u) => typeof u?.value === 'string' && u.value.length > 0)
+                .map((u) => ({
+                type: u.type || 'other',
+                value: u.value,
+                ...(u.preferred !== undefined && { preferred: u.preferred }),
+                ...(u.comment && { comment: u.comment }),
+            }));
+            // Destructured rather than length-checked: this is what proves the tuple
+            // shape to the compiler, so the emitters need no undefined handling.
+            const [firstId, ...restIds] = uniqueIds;
+            if (!firstId) {
+                skippedNoId++;
+                continue;
+            }
+            const name = content.name || content.title || content.id;
+            if (!name) {
+                skippedNoId++;
+                continue;
+            }
+            found.push({
+                name,
+                ...(content.title && { title: content.title }),
+                ...(content.description && { description: content.description }),
+                ...(content.kind && { kind: content.kind }),
+                uniqueIds: [firstId, ...restIds],
+            });
+            log.debug(`Loaded NamingSystem: ${name} (${uniqueIds.length} uniqueId entries)`);
+        }
+        catch (err) {
+            log.debug(`Skipping invalid JSON while reading NamingSystems ${file}: ${err.message}`);
+        }
+    }
+    // Say what was dropped: a silently shorter list reads as "the IG declares none".
+    if (skippedRetired > 0 || skippedNoId > 0) {
+        log.info(`NamingSystems: emitting ${found.length}, skipped ${skippedRetired} retired and ${skippedNoId} without a usable uniqueId`);
+    }
+    return found;
+}
 /**
  * Read all SearchParameter resources from a package directory.
  * Returns a map of base resource type → array of search parameter definitions.

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

@@ -3,6 +3,7 @@
  * Handles local registry, disk cache, network fetching (canonical URLs, Simplifier,
  * hl7.org fallbacks, bundled base R4 SDs), and ValueSet binding URL collection.
  */
+import { stripVersionFromCanonicalUrl } from '../core/utils.js';
 import path from "path";
 import fs from "fs";
 import https from "https";
@@ -89,7 +90,8 @@ export async function fetchStructureDefinition(url, fallbackUrl) {
     // Strip version suffix from canonical URLs (e.g., "http://....|5.3.0-ballot-tc1" -> "http://....")
     // FHIR canonical URLs use | to separate the URL from the version
     if (url.includes('|')) {
-        const [baseUrl, version] = url.split('|');
+        const baseUrl = stripVersionFromCanonicalUrl(url);
+        const version = url.substring(url.indexOf('|') + 1);
         logger.debug(`[fetchSD] Stripping version suffix from canonical URL: ${url} -> ${baseUrl} (version: ${version})`);
         url = baseUrl;
     }
@@ -373,7 +375,7 @@ export function collectValueSetBindingUrls(structureDefinitions) {
             for (const element of sd.differential.element) {
                 if (element.binding?.valueSet) {
                     // Strip version fragment if present (e.g., "...ValueSet|4.0.1")
-                    const url = element.binding.valueSet.split('|')[0];
+                    const url = stripVersionFromCanonicalUrl(element.binding.valueSet);
                     bindingUrls.add(url);
                 }
             }
@@ -382,7 +384,7 @@ export function collectValueSetBindingUrls(structureDefinitions) {
         if (sd.snapshot?.element) {
             for (const element of sd.snapshot.element) {
                 if (element.binding?.valueSet) {
-                    const url = element.binding.valueSet.split('|')[0];
+                    const url = stripVersionFromCanonicalUrl(element.binding.valueSet);
                     bindingUrls.add(url);
                 }
             }

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

@@ -399,7 +399,7 @@ export async function parseStructureDefinition(structureDefinition, fhirServerUr
         }
         if (bindingUri) {
             // Strip version suffix for map lookup (e.g. "…/ValueSet/foo|1.0.0" → "…/ValueSet/foo")
-            const lookupUri = bindingUri.split('|')[0];
+            const lookupUri = stripVersionFromCanonicalUrl(bindingUri);
             const codes = valueSetCodesMap?.[lookupUri] ?? valueSetCodesMap?.[bindingUri];
             if (codes && codes.length) {
                 // Deterministic pick based on simple hash of binding URI

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

@@ -6,6 +6,7 @@
  * Composition-specific helpers live in sliceAggregatorComposition.ts.
  */
 import { logger } from "../../logger.js";
+import { stripVersionFromCanonicalUrl } from '../core/utils.js';
 import { fetchStructureDefinition } from './sdFetcher.js';
 import { resolveValueSetDefault } from '../core/constants.js';
 import { complexExtValueDefault, resolveCompositionOpts } from './sliceAggregatorComposition.js';
@@ -26,7 +27,7 @@ export function synthesizeSlicePatternsFromChildren(fields) {
         if (!idToUse)
             continue;
         const match = idToUse.match(/^(.*?)(?:\.coding|\.text|$)/);
-        const basePath = match ? match[1] : idToUse;
+        const basePath = match?.[1] ?? idToUse;
         if (!fieldsByBasePath.has(basePath)) {
             fieldsByBasePath.set(basePath, []);
         }
@@ -256,6 +257,8 @@ export async function aggregateRequiredSlices(fields, baseFields = [], valueSetC
                                 if (pathParts.length !== 2)
                                     continue;
                                 const childPath = pathParts[1];
+                                if (!childPath)
+                                    continue;
                                 // eslint-disable-next-line @typescript-eslint/no-explicit-any
                                 const elemAny = elem;
                                 const fixedValue = elemAny.fixedUri ??
@@ -267,10 +270,11 @@ export async function aggregateRequiredSlices(fields, baseFields = [], valueSetC
                                 const bindingUri = elem.binding?.valueSet;
                                 let resolvedDefault = bindingUri ? resolveValueSetDefault(bindingUri) : undefined;
                                 if (!resolvedDefault && bindingUri && valueSetCodesMap) {
-                                    const bare = bindingUri.split('|')[0];
+                                    const bare = stripVersionFromCanonicalUrl(bindingUri);
                                     const codes = valueSetCodesMap[bare] ?? valueSetCodesMap[bindingUri];
-                                    if (codes?.length) {
-                                        resolvedDefault = { code: codes[0].code, system: codes[0].system };
+                                    const [firstCode] = codes ?? [];
+                                    if (firstCode) {
+                                        resolvedDefault = { code: firstCode.code, system: firstCode.system };
                                     }
                                 }
                                 const isSimpleExtension = isChoiceElement && elem.type?.length &&
@@ -315,8 +319,8 @@ export async function aggregateRequiredSlices(fields, baseFields = [], valueSetC
                 }
             }
             // ── Complex extension handling ─────────────────────────────────────
-            if (slice.profileUrls && slice.profileUrls.length > 0) {
-                const extProfileUrl = slice.profileUrls[0];
+            const [extProfileUrl] = slice.profileUrls ?? [];
+            if (extProfileUrl) {
                 try {
                     const extProfile = await fetchStructureDefinition(extProfileUrl, '');
                     if (extProfile?.type === 'Extension') {
@@ -333,10 +337,9 @@ export async function aggregateRequiredSlices(fields, baseFields = [], valueSetC
                                 const subExt = {
                                     url: urlElem?.fixedUri || subSliceName,
                                 };
-                                if (valueElem?.type?.length) {
-                                    const vt = typeof valueElem.type[0] === 'string'
-                                        ? valueElem.type[0]
-                                        : valueElem.type[0].code;
+                                const firstType = valueElem?.type?.[0];
+                                if (firstType) {
+                                    const vt = typeof firstType === 'string' ? firstType : firstType.code;
                                     const cap = vt.charAt(0).toUpperCase() + vt.slice(1);
                                     subExt[`value${cap}`] = complexExtValueDefault(vt);
                                 }

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

@@ -2,6 +2,7 @@
  * Composition profile constraint resolution for slice aggregation.
  */
 import { fetchStructureDefinition } from './sdFetcher.js';
+import { stripVersionFromCanonicalUrl } from '../core/utils.js';
 import { DEFAULT_BASE64_HELLO } from '../core/constants.js';
 /** Return a sensible default value for a FHIR type used in complex extension value[x]. */
 export function complexExtValueDefault(fhirType) {
@@ -21,7 +22,15 @@ export function complexExtValueDefault(fhirType) {
         case 'canonical': return 'https://example.org';
         case 'Reference': return { reference: 'Resource/example' };
         case 'Quantity': return { value: 1, unit: 'unit' };
-        case 'Period': return { start: new Date().toISOString() };
+        // Dates go through the same placeholders the class emitter resolves into
+        // randomDate(), so a sub-extension gets a fresh value per random() call.
+        // Previously dateTime/instant/date fell through to 'value', which is not a
+        // valid FHIR dateTime, and Period froze the generation-time clock into the
+        // emitted source.
+        case 'dateTime':
+        case 'instant': return '__DATE_EXPR__';
+        case 'date': return '__DATE10_EXPR__';
+        case 'Period': return { start: '__DATE_EXPR__' };
         default: return 'value';
     }
 }
@@ -130,7 +139,7 @@ export async function resolveCompositionOpts(profileUrl) {
         const e = elem;
         if (REFERENCE_FIELDS.includes(e.path) && Array.isArray(e.type)) {
             for (const tp of (e.type[0]?.targetProfile ?? [])) {
-                const tpBase = tp.split('|')[0];
+                const tpBase = stripVersionFromCanonicalUrl(tp);
                 if (tpBase.startsWith('http://hl7.org/fhir/StructureDefinition/'))
                     continue;
                 const lastSeg = tpBase.split('/').pop() ?? '';

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

@@ -3,6 +3,7 @@
  * Parses FHIR ValueSet resources and extracts codes for TypeScript union type generation
  */
 import { logger } from '../../logger.js';
+import { stripVersionFromCanonicalUrl } from '../core/utils.js';
 import { ctx } from '../fhir/versionContext.js';
 import fs from 'fs';
 import path from 'path';
@@ -118,7 +119,9 @@ export function getUniformSystem(valueSet) {
     if (valueSet.concepts.length === 0) {
         return null;
     }
-    const firstSystem = valueSet.concepts[0].system;
+    const firstSystem = valueSet.concepts[0]?.system;
+    if (firstSystem === undefined)
+        return null;
     const allSameSystem = valueSet.concepts.every(c => c.system === firstSystem);
     return allSameSystem ? firstSystem : null;
 }
@@ -222,7 +225,7 @@ export function addPlaceholdersForExternalBindings(valueSets, bindingUrls, fhirC
 function findValueSetInCache(canonicalUrl, fhirCacheDir) {
     // Derive the expected filename from the canonical URL
     // e.g. "http://hl7.org/fhir/ValueSet/mimetypes" → "ValueSet-mimetypes.json"
-    const urlName = canonicalUrl.split('|')[0].split('/').pop();
+    const urlName = stripVersionFromCanonicalUrl(canonicalUrl).split('/').pop();
     if (!urlName)
         return undefined;
     const expectedFilename = `ValueSet-${urlName}.json`;
@@ -242,7 +245,7 @@ function findValueSetInCache(canonicalUrl, fhirCacheDir) {
                 if (content.resourceType !== 'ValueSet')
                     continue;
                 // Verify the canonical URL matches (not just the filename)
-                if (content.url && content.url === canonicalUrl.split('|')[0]) {
+                if (content.url && content.url === stripVersionFromCanonicalUrl(canonicalUrl)) {
                     const parsed = parseValueSet(content);
                     if (parsed)
                         return parsed;

package/out/src/generator/sdProcessor.js

@@ -10,7 +10,7 @@ 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, stripVersionFromCanonicalUrl } from './core/utils.js';
+import { writeInterfaceAndValidatorToFile, mergeFields, alignFields, writeToFile, getBaseResource, sanitizeIdentifier, toPascalCase, stripVersionFromCanonicalUrl, stripSliceSuffix } 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';
@@ -113,7 +113,10 @@ async function fillUnstatedFromBaseResource(fields, resourceType) {
         if (!current)
             continue;
         for (let i = next; i < segments.length && current; i++) {
-            current = resolveComplexTypeChildType(current, segments[i]);
+            const segment = segments[i];
+            if (segment === undefined)
+                break;
+            current = resolveComplexTypeChildType(current, segment);
         }
         if (current) {
             field.type = current;
@@ -193,11 +196,12 @@ async function fillSliceProfileUrlsFromBaseProfiles(fields, baseDefinition) {
 async function resolveExtensionMetadata(fields) {
     const extUrls = new Set();
     for (const f of fields) {
-        if (!f.sliceName || !f.profileUrls?.length)
+        const firstProfile = f.sliceName ? f.profileUrls?.[0] : undefined;
+        if (!firstProfile)
             continue;
-        const basePath = (f.name || '').replace(/^[^.]+\./, '').split(':')[0];
+        const basePath = stripSliceSuffix((f.name || '').replace(/^[^.]+\./, ''));
         if (basePath.endsWith('extension') || basePath.endsWith('modifierExtension')) {
-            extUrls.add(f.profileUrls[0]);
+            extUrls.add(firstProfile);
         }
     }
     if (extUrls.size === 0)
@@ -242,8 +246,9 @@ async function resolveExtensionMetadata(fields) {
             // 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 = readBinding(valueEl);
-            if (!binding && types.length === 1) {
-                const suffix = types[0].charAt(0).toUpperCase() + types[0].slice(1);
+            const onlyType = types.length === 1 ? types[0] : undefined;
+            if (!binding && onlyType) {
+                const suffix = onlyType.charAt(0).toUpperCase() + onlyType.slice(1);
                 const sliceEl = els.find(el => el.id === `Extension.value[x]:value${suffix}` ||
                     el.path === `Extension.value${suffix}` ||
                     el.id === `Extension.value${suffix}`);
@@ -274,12 +279,13 @@ async function resolveExtensionMetadata(fields) {
 async function resolveDatatypeProfilePins(fields) {
     const urls = new Set();
     for (const f of fields) {
-        if (!f.sliceName || !f.profileUrls?.length)
+        const firstProfile = f.sliceName ? f.profileUrls?.[0] : undefined;
+        if (!firstProfile)
             continue;
-        const basePath = (f.name || '').replace(/^[^.]+\./, '').split(':')[0];
+        const basePath = stripSliceSuffix((f.name || '').replace(/^[^.]+\./, ''));
         if (basePath.endsWith('extension') || basePath.endsWith('modifierExtension'))
             continue;
-        urls.add(f.profileUrls[0]);
+        urls.add(firstProfile);
     }
     if (urls.size === 0)
         return undefined;
@@ -514,8 +520,11 @@ export async function processStructureDefinition(sd, ctx) {
             continue;
         if (f.isOptional || f.isForbidden)
             continue;
-        const parentFieldName = parts[1].split(':')[0];
-        let relativePath = parts.slice(2).map((p) => p.split(':')[0]).join('.');
+        const parentSegment = parts[1];
+        if (!parentSegment)
+            continue;
+        const parentFieldName = stripSliceSuffix(parentSegment);
+        let relativePath = parts.slice(2).map((p) => stripSliceSuffix(p)).join('.');
         if (relativePath.includes('[x]')) {
             const resolvedPath = resolveChoiceSegments(f, parts, candidateRequiredFields);
             // An intermediate choice we cannot narrow to one type has no property name.
@@ -566,9 +575,9 @@ export async function processStructureDefinition(sd, ctx) {
                 const parentPath = parts.slice(0, -1).join('.');
                 const parentField = candidateRequiredFields.find(pf => pf?.name === parentPath && pf.type && pf.type !== 'any' && pf.type !== 'unknown')
                     || parsed.oldFields.find(pf => pf?.name === parentPath && pf.type && pf.type !== 'any' && pf.type !== 'unknown');
-                if (parentField?.type) {
-                    const childName = parts[parts.length - 1].split(':')[0];
-                    fieldType = resolveComplexTypeChildType(parentField.type, childName);
+                const leafSegment = parts.at(-1);
+                if (parentField?.type && leafSegment) {
+                    fieldType = resolveComplexTypeChildType(parentField.type, stripSliceSuffix(leafSegment));
                 }
             }
         }
@@ -640,8 +649,8 @@ export async function processStructureDefinition(sd, ctx) {
             if (originalField?.typeOptions?.[0]?.targetProfileUrls?.[0]) {
                 const targetUrl = stripVersionFromCanonicalUrl(originalField.typeOptions[0].targetProfileUrls[0]);
                 const match = targetUrl.match(/\/([^/]+)$/);
-                if (match) {
-                    const candidate = match[1];
+                const candidate = match?.[1];
+                if (candidate) {
                     const knownResourceNames = versionCtx().resourceNames;
                     if (knownResourceNames.includes(candidate)) {
                         rf.targetResourceType = candidate;
@@ -651,9 +660,9 @@ export async function processStructureDefinition(sd, ctx) {
                         let resolved = false;
                         for (const bf of baseFields) {
                             for (const tp of bf.typeOptions?.[0]?.targetProfileUrls ?? []) {
-                                const bm = tp.match(/\/([^/]+)$/);
-                                if (bm && knownResourceNames.includes(bm[1])) {
-                                    rf.targetResourceType = bm[1];
+                                const bmCandidate = tp.match(/\/([^/]+)$/)?.[1];
+                                if (bmCandidate && knownResourceNames.includes(bmCandidate)) {
+                                    rf.targetResourceType = bmCandidate;
                                     resolved = true;
                                     break;
                                 }
@@ -732,7 +741,7 @@ export async function processStructureDefinition(sd, ctx) {
         writeToFile(path.join(outputDir, `${interfaceName}Class.ts`), classContent);
     }
     if (flags?.schema === 'zod') {
-        const zodResult = generateZodSchema(interfaceName, aligned.alignedNewFields, baseResource, parsed.oldFields, valueSets);
+        const zodResult = generateZodSchema(interfaceName, aligned.alignedNewFields, baseResource, parsed.oldFields, valueSets, !!flags?.zodInvariants);
         writeToFile(path.join(outputDir, `${interfaceName}.zod.ts`), zodResult.code);
     }
     if (flags?.prefab) {

package/out/src/generator/sdProcessorRequiredFields.js

@@ -1,6 +1,7 @@
 /**
  * Required-field extraction and deduplication for sdProcessor.
  */
+import { stripSliceSuffix } from './core/utils.js';
 /**
  * Build and deduplicate the list of required fields from candidate fields.
  * Filters to direct children of the root, then deduplicates by name with
@@ -22,7 +23,7 @@ export function extractAndDeduplicateRequiredFields(candidateRequiredFields, sdI
         return root === baseResource || root === sdRoot || (root === type && profileDiffFieldNames.has(f.name));
     })
         .map(f => ({
-        name: (f.name.split('.').pop() || f.name).split(':')[0],
+        name: stripSliceSuffix(f.name.split('.').pop() || f.name),
         type: f.type || 'string',
         baseType: f.baseTypeCode,
         isArray: f.isArray,
@@ -229,7 +230,7 @@ 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 segment = stripSliceSuffix(segments[i] ?? '');
         const choice = /^(\w+)\[x\]$/.exec(segment);
         if (!choice) {
             resolved.push(segment);

package/out/src/main.js

@@ -57,6 +57,7 @@ function printUsage() {
     console.log("  --no-classes             Only generate interfaces and types (skip class generation)");
     console.log("  --no-client              Skip FHIR client generation (client generated by default)");
     console.log("  --schema <format>        Generate schema files alongside outputs (supported: zod)");
+    console.log("  --zod-invariants         Emit FHIRPath invariants into Zod schemas (fuller checking, slower parse)");
     console.log("  --dicomweb               Generate DICOMweb helpers typed to ImagingStudy profiles in the IG");
     console.log("  --prefab                 Generate Prefab UI render functions per profile (@maxhealth.tech/prefab)");
     console.log("  --prefab-styles <path>   Path to styles module (.ts/.js) copied into the generated prefab/ folder");
@@ -366,6 +367,10 @@ export function parseCliArgs(argv) {
             i++;
             continue;
         }
+        if (arg === '--zod-invariants') {
+            out.flags.zodInvariants = true;
+            continue;
+        }
         if (arg === '--fhir-version') {
             const val = argv[i + 1];
             if (!val || val.startsWith('-'))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "babelfhir-ts",
-  "version": "1.5.21",
+  "version": "1.6.1",
   "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",
@@ -86,24 +86,24 @@
   },
   "devDependencies": {
     "@eslint/js": "^10.0.1",
-    "@max-health/config": "github:max-health-inc/config",
-    "@maxhealth.tech/prefab": "^0.3.5",
+    "@max-health-inc/config": "^3.1.0",
+    "@maxhealth.tech/prefab": "^0.3.7",
     "@types/node": "^25.9.5",
-    "@types/semver": "^7.7.1",
+    "@types/semver": "^7.8.0",
     "@types/unzipper": "^0.10.11",
     "@vitest/coverage-v8": "^4.1.10",
-    "@vitest/eslint-plugin": "^1.6.24",
+    "@vitest/eslint-plugin": "^1.6.26",
     "@vitest/ui": "^4.1.10",
     "cross-env": "^10.1.0",
     "eslint": "^10.8.0",
-    "fhirpath": "^5.0.0",
-    "globals": "^17.7.0",
+    "fhirpath": "^5.1.0",
+    "globals": "^17.9.0",
     "rimraf": "^6.1.3",
     "semver": "^7.8.5",
     "typescript": "^6.0.3",
-    "typescript-eslint": "^8.65.0",
+    "typescript-eslint": "^8.66.0",
     "vitepress": "^1.6.4",
-    "vitepress-plugin-llms": "^1.13.3",
+    "vitepress-plugin-llms": "^1.13.4",
     "vitest": "^4.1.10",
     "zod": "4.3.6"
   },
@@ -111,7 +111,10 @@
     "@types/fhir": "^0.0.44",
     "consola": "^3.4.2",
     "tar": "^7.5.22",
-    "tsx": "^4.23.1",
+    "tsx": "^4.23.7",
     "unzipper": "^0.12.5"
+  },
+  "overrides": {
+    "brace-expansion": "^5.0.9"
   }
 }