babelfhir-ts 1.5.21 → 1.6.1

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

@@ -1,6 +1,7 @@
 /**
  * BackboneElement and binding-codes slice validation strategies.
  */
+import { firstSegment } from '../../core/utils.js';
 import { safeAccessor, safeList, sliceElseBranch, detectNestedArray, FHIR_PRIMITIVE_STRING_TYPES, collectWithinSliceMaxChildren, generateWithinSliceMaxChecks } from './sliceValidatorUtils.js';
 /** Collect required direct children of a BackboneElement slice for per-element validation. */
 export function collectRequiredSliceChildren(sliceElementId, fields, discriminatorProp, profileName, relPath) {
@@ -45,6 +46,11 @@ export function collectNestedRequiredSliceChildren(sliceElementId, fields, discr
         const parts = relativePath.split('.');
         if (parts.length !== 2)
             continue;
+        // Destructured so the two segments are values: the length check establishes
+        // there are exactly two, but indexing alone does not tell the compiler.
+        const [parentSegment, childSegment] = parts;
+        if (!parentSegment || !childSegment)
+            continue;
         if (relativePath.includes(':'))
             continue;
         if (f.max === 0)
@@ -52,20 +58,21 @@ export function collectNestedRequiredSliceChildren(sliceElementId, fields, discr
         const childMin = typeof f.min === 'number' ? f.min : (f.isOptional ? 0 : 1);
         if (childMin < 1)
             continue;
-        const parentProp = parts[0].replace(/\[x\]$/, '');
+        const parentProp = parentSegment.replace(/\[x\]$/, '');
         if (parentProp === discriminatorProp)
             continue;
-        const isChoiceType = parts[1].endsWith('[x]');
-        const prop = parts[1].replace(/\[x\]$/, '');
+        const isChoiceType = childSegment.endsWith('[x]');
+        const prop = childSegment.replace(/\[x\]$/, '');
         const key = `${parentProp}.${prop}`;
         if (seen.has(key))
             continue;
         seen.add(key);
-        const parentFieldId = `${sliceElementId}.${parts[0]}`;
+        const parentFieldId = `${sliceElementId}.${parentSegment}`;
         const parentField = fields.find(pf => (pf.elementId || pf.name) === parentFieldId);
         const isParentArray = parentField?.isArray ?? false;
-        const baseParts = relPath.split('.');
-        const lastPart = baseParts[baseParts.length - 1];
+        // relPath is non-empty, so split() yields a last segment; falling back to the
+        // whole path keeps the error path readable if it ever does not.
+        const lastPart = relPath.split('.').at(-1) ?? relPath;
         result.push({ parentProp, isParentArray, prop, errorPath: `${profileName}.${lastPart}.${parentProp}.${prop}`, isChoiceType });
     }
     return result;
@@ -87,7 +94,11 @@ export function collectFixedValueSliceChildren(sliceElementId, fields, discrimin
         // Handle choice type slicing: value[x]:valueString → prop "valueString"
         let prop = relativePath;
         if (prop.includes('[x]:')) {
-            prop = prop.split(':')[1]; // "valueString", "valueCode", etc.
+            // The typed variant after the colon: "valueString", "valueCode", etc.
+            const typedVariant = prop.split(':')[1];
+            if (!typedVariant)
+                continue;
+            prop = typedVariant;
         }
         else if (prop.includes(':')) {
             continue; // Skip other slice references
@@ -117,13 +128,13 @@ export function generateBackboneElementValidation(slice, relPath, errorPath, sli
     const sliceId = (slice.elementId || slice.name).replace(/^[^.]+\./, '');
     let discriminatorProp = '';
     if (childFieldId.startsWith(sliceId + '.')) {
-        discriminatorProp = childFieldId.substring(sliceId.length + 1).split('.')[0];
+        discriminatorProp = firstSegment(childFieldId.substring(sliceId.length + 1));
     }
     else {
         const childFieldName = discriminatorChild.name.replace(/^[^.]+\./, '');
         const sliceName = slice.name.replace(/^[^.]+\./, '');
         if (childFieldName.startsWith(sliceName + '.')) {
-            discriminatorProp = childFieldName.substring(sliceName.length + 1).split('.')[0];
+            discriminatorProp = firstSegment(childFieldName.substring(sliceName.length + 1));
         }
     }
     if (discriminatorProp.includes('[x]')) {
@@ -167,7 +178,7 @@ export function generateBackboneElementValidation(slice, relPath, errorPath, sli
     }
     if (!checks)
         return;
-    const resourceType = profileName || sliceElementId.split('.')[0];
+    const resourceType = profileName || firstSegment(sliceElementId);
     const requiredChildren = collectRequiredSliceChildren(sliceElementId, fields, discriminatorProp, resourceType, relPath);
     const nestedChildren = collectNestedRequiredSliceChildren(sliceElementId, fields, discriminatorProp, resourceType, relPath);
     const directChecksInner = requiredChildren.map(c => c.isChoiceType
@@ -257,12 +268,16 @@ export function generateBackboneElementValidation(slice, relPath, errorPath, sli
  */
 export function generateFixedValueSliceValidation(slice, relPath, errorPath, sliceLabel, varName, min, fields, childFieldsWithFixedValue, out, profileName) {
     const sliceElementId = slice.elementId || slice.name;
+    // The caller only reaches here with a fixed-value child, but an empty list would
+    // otherwise read its discriminator off undefined.
     const discriminatorChild = childFieldsWithFixedValue[0];
+    if (!discriminatorChild)
+        return;
     const childFieldId = (discriminatorChild.elementId || discriminatorChild.name).replace(/^[^.]+\./, '');
     const sliceId = (slice.elementId || slice.name).replace(/^[^.]+\./, '');
     let discriminatorProp = '';
     if (childFieldId.startsWith(sliceId + '.')) {
-        discriminatorProp = childFieldId.substring(sliceId.length + 1).split('.')[0];
+        discriminatorProp = firstSegment(childFieldId.substring(sliceId.length + 1));
     }
     if (!discriminatorProp)
         return;
@@ -270,7 +285,7 @@ export function generateFixedValueSliceValidation(slice, relPath, errorPath, sli
         ? `"${discriminatorChild.fixedValue}"`
         : String(discriminatorChild.fixedValue);
     const checks = `at(item, '${discriminatorProp}') === ${fixedVal}`;
-    const resourceType = profileName || sliceElementId.split('.')[0];
+    const resourceType = profileName || firstSegment(sliceElementId);
     const requiredChildren = collectRequiredSliceChildren(sliceElementId, fields, discriminatorProp, resourceType, relPath);
     const nestedChildren = collectNestedRequiredSliceChildren(sliceElementId, fields, discriminatorProp, resourceType, relPath);
     const fixedChildren = collectFixedValueSliceChildren(sliceElementId, fields, discriminatorProp);

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

@@ -6,7 +6,7 @@
  * validator, which is what keeps findings inside a nested resource from being
  * lost. Split out of sliceValidatorGenerator, which had grown past the size limit.
  */
-import { stripVersionFromCanonicalUrl } from '../../core/utils.js';
+import { stripVersionFromCanonicalUrl, firstSegment } from '../../core/utils.js';
 import { safeAccessor, safeList, collectWithinSliceMaxChildren, generateWithinSliceMaxChecks } from './sliceValidatorUtils.js';
 export function generateProfiledChildDelegation(slice, relPath, childFieldsWithFixedValue, out, ctx) {
     if (!ctx.profileUrlToName || !ctx.validatorImports)
@@ -26,10 +26,12 @@ export function generateProfiledChildDelegation(slice, relPath, childFieldsWithF
         return;
     // Get discriminator info to build the filter expression
     const discriminatorChild = childFieldsWithFixedValue[0];
+    if (!discriminatorChild)
+        return;
     const childFieldId = (discriminatorChild.elementId || discriminatorChild.name).replace(/^[^.]+\./, '');
     let discriminatorProp = '';
     if (childFieldId.startsWith(sliceElemId + '.')) {
-        discriminatorProp = childFieldId.substring(sliceElemId.length + 1).split('.')[0];
+        discriminatorProp = firstSegment(childFieldId.substring(sliceElemId.length + 1));
     }
     if (!discriminatorProp)
         return;
@@ -148,9 +150,9 @@ export function detectReferenceProfileDiscriminator(slice, profileUrlToType) {
     if (!slice.typeOptions?.length)
         return undefined;
     const refType = slice.typeOptions.find(t => t.code === 'Reference');
-    if (!refType?.targetProfileUrls?.length)
+    const targetUrl = refType?.targetProfileUrls?.[0];
+    if (!targetUrl)
         return undefined;
-    const targetUrl = refType.targetProfileUrls[0];
     // 1. Authoritative: resolve from profileUrlToType map
     if (profileUrlToType) {
         const resolved = profileUrlToType.get(targetUrl);
@@ -190,7 +192,7 @@ export function detectReferenceProfileDiscriminator(slice, profileUrlToType) {
 export function generateReferenceProfileDiscriminatorValidation(slice, relPath, errorPath, sliceLabel, varName, min, targetResourceType, out, fields, baseResourceType) {
     // Build within-slice child max constraint checks (e.g., max=0 forbidden fields)
     const maxChildren = fields ? collectWithinSliceMaxChildren(slice, fields) : [];
-    const resType = baseResourceType || (slice.elementId || slice.name).split('.')[0];
+    const resType = baseResourceType || firstSegment(slice.elementId || slice.name);
     const childMaxChecks = generateWithinSliceMaxChecks(maxChildren, `_${varName}Refs`, resType, relPath, sliceLabel);
     out.push(`
   // Required Reference-profile slice validation for ${relPath}:${sliceLabel} (target → ${targetResourceType})
@@ -333,7 +335,7 @@ export function detectProfileDiscriminator(slice, fields, profileUrlToType) {
     }
     // 2. Try to extract from profile URL last segment (core profiles)
     const profileUrl = profileUrls[0];
-    const lastSegment = profileUrl.split('/').pop() || '';
+    const lastSegment = profileUrl?.split('/').pop() || '';
     if (/^[A-Z][a-zA-Z]+$/.test(lastSegment)) {
         return { resourceType: lastSegment, profileUrls };
     }

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

@@ -2,7 +2,7 @@
  * Extension and ValueSet slice validation strategies.
  */
 import { safeAccessor, safeList, sliceElseBranch, detectNestedArray, findArrayAncestor, isArrayPath, FHIR_PRIMITIVE_STRING_TYPES } from './sliceValidatorUtils.js';
-import { stripVersionFromCanonicalUrl } from '../../core/utils.js';
+import { stripVersionFromCanonicalUrl, stripSliceSuffix } from '../../core/utils.js';
 import { buildSubExtensionScope, renderScopeHops } from './subExtensionScope.js';
 /**
  * Read pre-resolved Extension SD metadata for a canonical.
@@ -267,7 +267,7 @@ export function generateExistsExtensionValidation(slice, relPath, errorPath, sli
  * profile URL that can serve as the extension URL discriminator.
  */
 export function detectExtensionUrlSlice(slice, relPath, fields) {
-    const basePath = relPath.split(':')[0];
+    const basePath = stripSliceSuffix(relPath);
     if (!basePath.endsWith('extension') && !basePath.endsWith('modifierExtension'))
         return undefined;
     if (slice.profileUrls && slice.profileUrls.length > 0) {
@@ -335,7 +335,7 @@ export function generateExtensionUrlSliceValidation(slice, relPath, errorPath, s
         const scopedElemId = (slice.elementId || '').replace(/^[^.]+\./, '');
         const scopedErrorPath = scopedElemId || `${errorPath}:${sliceLabel}`;
         // The slot the slice lives in: its own last segment, minus the slice qualifier.
-        const leafProp = scopedElemId.split('.').pop().split(':')[0];
+        const leafProp = stripSliceSuffix(scopedElemId.split('.').pop() ?? '');
         const body = renderScopeHops(subScope, (container, indent) => {
             const matches = `${varName}Matches`;
             let inner = `\n${indent}const ${matches} = elements(at(${container}, '${leafProp}')).filter((item) => item.url === "${extensionUrl}");`;

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

@@ -5,7 +5,8 @@
  */
 import { addDiagnostic } from '../../core/sdDiagnostics.js';
 import { INLINE_RESOURCE_SLOTS } from './validatorFieldBuilders.js';
-import { safeAccessor, safeList, sliceElseBranch, rewritePrimitiveExtensionPath, isArrayPath, resolveNestedPatternChild } from './sliceValidatorUtils.js';
+import { firstSegment, stripSliceSuffix } from '../../core/utils.js';
+import { safeAccessor, safeList, sliceElseBranch, rewritePrimitiveExtensionPath, isArrayPath, resolveNestedPatternChild, collectWithinSliceMaxChildren, generateWithinSliceMaxChecks } from './sliceValidatorUtils.js';
 import { generateProfiledChildDelegation, detectReferenceProfileDiscriminator, generateReferenceProfileDiscriminatorValidation, generateOptionalProfiledSliceDelegation, detectProfileDiscriminator, generateProfileDiscriminatorValidation, detectSelfTypeDiscriminator, generateSelfTypeSliceValidation, generateDatatypeProfileSliceValidation, } from './sliceDelegation.js';
 import { generateBackboneElementValidation, generateBindingCodesValidation, generateFixedValueSliceValidation } from './sliceBackboneValidation.js';
 import { generateValueSetValidation, detectExistsExtensionDiscriminator, generateExistsExtensionValidation, detectExtensionUrlSlice, generateExtensionUrlSliceValidation, } from './sliceExtensionValidation.js';
@@ -144,7 +145,7 @@ export function generateSliceValidations(ctx) {
                         return subMin > 0;
                     }).map(f => {
                         const fId = (f.elementId || f.name).replace(/^[^.]+\./, '');
-                        return fId.substring(sliceElemId.length + 1).split('.')[0];
+                        return firstSegment(fId.substring(sliceElemId.length + 1));
                     });
                     generatePatternCodingValidation(slice, relPath, errorPath, sliceLabel, varName, min, fields, sliceValidations, requiredSubFields, ctx.baseResourceType, ctx.profileUrl);
                 }
@@ -152,17 +153,21 @@ export function generateSliceValidations(ctx) {
                     // For extension slices where the only fixedValue child is 'url', prefer the
                     // extension URL validation path — it includes value[x] type checking from
                     // resolved ExtensionMetadata, which generic fixedValue validation doesn't.
-                    const isExtensionUrlOnly = childFieldsWithFixedValue.length === 1 &&
-                        childFieldsWithFixedValue[0].fixedValue &&
-                        typeof childFieldsWithFixedValue[0].fixedValue === 'string' &&
+                    // Read the sole child once rather than indexing it five times.
+                    const onlyFixedChild = childFieldsWithFixedValue.length === 1
+                        ? childFieldsWithFixedValue[0]
+                        : undefined;
+                    const extUrl = typeof onlyFixedChild?.fixedValue === 'string'
+                        ? onlyFixedChild.fixedValue
+                        : undefined;
+                    const isExtensionUrlOnly = !!onlyFixedChild && extUrl !== undefined &&
                         (() => {
-                            const fId = (childFieldsWithFixedValue[0].elementId || childFieldsWithFixedValue[0].name).replace(/^[^.]+\./, '');
+                            const fId = (onlyFixedChild.elementId || onlyFixedChild.name).replace(/^[^.]+\./, '');
                             const sliceEId = (slice.elementId || slice.name).replace(/^[^.]+\./, '');
                             const relChild = fId.startsWith(sliceEId + '.') ? fId.substring(sliceEId.length + 1) : '';
                             return relChild === 'url';
                         })();
-                    if (isExtensionUrlOnly) {
-                        const extUrl = childFieldsWithFixedValue[0].fixedValue;
+                    if (isExtensionUrlOnly && extUrl !== undefined) {
                         generateExtensionUrlSliceValidation(slice, relPath, errorPath, sliceLabel, varName, min, extUrl, fieldPathMap, arrayFieldPaths, sliceValidations, ctx);
                     }
                     else {
@@ -194,6 +199,10 @@ export function generateSliceValidations(ctx) {
                             generateProfileDiscriminatorValidation(slice, relPath, errorPath, sliceLabel, varName, min, profileMatch, sliceValidations, ctx);
                         }
                         else {
+                            const sliceProfileUrl = slice.profileUrls?.[0];
+                            const datatypePin = sliceProfileUrl
+                                ? ctx.datatypeProfilePins?.get(sliceProfileUrl)
+                                : undefined;
                             const refResourceType = detectReferenceProfileDiscriminator(slice, ctx.profileUrlToType);
                             if (refResourceType) {
                                 generateReferenceProfileDiscriminatorValidation(slice, relPath, errorPath, sliceLabel, varName, min, refResourceType, sliceValidations, fields, ctx.baseResourceType);
@@ -201,10 +210,11 @@ export function generateSliceValidations(ctx) {
                             else if (slice.fixedValue !== undefined && !isChoiceTypeSlice) {
                                 generateSelfFixedValueSliceValidation(slice, relPath, errorPath, sliceLabel, varName, min, sliceValidations);
                             }
-                            else if (slice.profileUrls?.length && ctx.datatypeProfilePins?.get(slice.profileUrls[0])) {
+                            else if (datatypePin) {
                                 // A {profile, $this} slice against a datatype profile: the profile's
-                                // own pinned element is what distinguishes its members.
-                                generateDatatypeProfileSliceValidation(relPath, errorPath, sliceLabel, varName, min, ctx.datatypeProfilePins.get(slice.profileUrls[0]), sliceValidations);
+                                // own pinned element is what distinguishes its members. Resolved once
+                                // above, which also drops the non-null assertion on the second lookup.
+                                generateDatatypeProfileSliceValidation(relPath, errorPath, sliceLabel, varName, min, datatypePin, sliceValidations);
                             }
                             else if (INLINE_RESOURCE_SLOTS.has(relPath) && detectSelfTypeDiscriminator(slice)) {
                                 // An inline-resource slot sliced by {type, $this}: the member is the
@@ -310,28 +320,12 @@ function generatePatternCodeableConceptValidation(slice, relPath, errorPath, sli
         const sliceFullId = slice.sliceName && !sliceElemId.includes(':')
             ? `${sliceElemId}:${slice.sliceName}`
             : sliceElemId;
-        const resType = baseResourceType || sliceElemId.split('.')[0];
-        const childMaxFields = fields.filter(f => {
-            const fId = (f.elementId || f.name).replace(/^[^.]+\./, '');
-            if (!fId.startsWith(sliceFullId + '.'))
-                return false;
-            const relChild = fId.substring(sliceFullId.length + 1);
-            if (relChild.includes('.'))
-                return false;
-            return typeof f.max === 'number' && f.max < Infinity;
-        });
-        for (const child of childMaxFields) {
-            const childFullId = (child.elementId || child.name).replace(/^[^.]+\./, '');
-            const childProp = childFullId.substring(sliceFullId.length + 1);
-            const maxVal = child.max;
-            childMaxChecks += `
-    for (const _wsElem of ${varName}Elements) {
-      const _wsArr = at(_wsElem, '${childProp}');
-      if (Array.isArray(_wsArr) && _wsArr.length > ${maxVal}) {
-        errors.push("${resType}.${relPath}:${sliceLabel}.${childProp}: max allowed = ${maxVal}, but found " + _wsArr.length);
-      }
-    }`;
-        }
+        const resType = baseResourceType || firstSegment(sliceElemId);
+        // Shared with the backbone and delegation slice validators. The inline copy
+        // this replaces was array-only, so `max=0` on a singleton child could never
+        // fire, and it rejected any dotted path, so a grandchild like
+        // `entity:patient.what.reference` was never reached.
+        childMaxChecks += generateWithinSliceMaxChecks(collectWithinSliceMaxChildren(slice, fields), `${varName}Elements`, resType, relPath, sliceLabel);
         // Build within-slice fixedValue checks on nested descendants.
         // E.g. category:labCategory.coding.system fixed to a specific URI.
         const fixedValueDescendants = fields.filter(f => {
@@ -371,11 +365,11 @@ function generatePatternCodeableConceptValidation(slice, relPath, errorPath, sli
         // pattern coding values as effectively fixed on each coding element
         // within matched slice members. The HL7 validator treats pattern values
         // as fixed when combined with max=1 cardinality.
-        const codingChild = childMaxFields.find(f => {
+        const codingChild = fields.find(f => {
             const fId = (f.elementId || f.name).replace(/^[^.]+\./, '');
-            return fId.substring(sliceFullId.length + 1) === 'coding';
+            return fId.startsWith(sliceFullId + '.') && fId.substring(sliceFullId.length + 1) === 'coding';
         });
-        if (codingChild && typeof codingChild.max === 'number' && codingChild.max === 1) {
+        if (codingChild?.max === 1) {
             const pRef = profileUrl ? `${profileUrl}#${resType}.${relPath}:${sliceLabel}` : `${resType}.${relPath}:${sliceLabel}`;
             for (const pc of patternCodings) {
                 const pSys = pc.system ? String(pc.system) : undefined;
@@ -462,7 +456,7 @@ function generatePatternCodingValidation(slice, relPath, errorPath, sliceLabel,
     // nothing where HL7 reports the mismatch. The CodeableConcept sibling has done
     // this for its descendants all along — the gap was only here.
     const sliceIdRel = (slice.elementId || slice.name).replace(/^[^.]+\./, '');
-    const resType = baseResourceType || sliceIdRel.split('.')[0];
+    const resType = baseResourceType || firstSegment(sliceIdRel);
     const fixedChildChecks = fields
         .filter(f => {
         if (typeof f.fixedValue !== 'string' && typeof f.fixedValue !== 'number' && f.fixedValue !== true)
@@ -508,10 +502,12 @@ function generatePatternCodingValidation(slice, relPath, errorPath, sliceLabel,
     const sliceIdParts = sliceElemId.split('.');
     for (let i = 0; i < sliceIdParts.length - 1; i++) {
         const part = sliceIdParts[i];
-        if (part.includes(':')) {
+        if (part?.includes(':')) {
             const [basePath, sliceNameInId] = part.split(':');
+            if (!basePath)
+                continue;
             const parentSlice = fields.find(f => f.sliceName === sliceNameInId &&
-                f.name.replace(/^[^.]+\./, '').split('.')[0] === basePath.split(':')[0]);
+                firstSegment(f.name.replace(/^[^.]+\./, '')) === stripSliceSuffix(basePath));
             if (parentSlice) {
                 const parentMin = typeof parentSlice.min === 'number' ? parentSlice.min : (parentSlice.isOptional ? 0 : 1);
                 if (parentMin === 0) {
@@ -522,9 +518,13 @@ function generatePatternCodingValidation(slice, relPath, errorPath, sliceLabel,
         }
     }
     const matchedChecks = subFieldChecks + fixedChildChecks;
-    const subFieldBlock = matchedChecks ? `
+    // Within-slice max cardinality on this slice's own children, through the same
+    // helper the backbone and delegation validators use. This validator never ran
+    // them, so a `max=0` child of a Coding slice went unreported.
+    const maxChecks = generateWithinSliceMaxChecks(collectWithinSliceMaxChildren(slice, fields), `${varName}Elements`, resType, relPath, sliceLabel);
+    const subFieldBlock = (matchedChecks ? `
     for (const matched of ${varName}Elements) {${matchedChecks}
-    }` : '';
+    }` : '') + maxChecks;
     if (isNestedInArray && arrayParentPath) {
         const remainingPath = relPath.substring(arrayParentPath.length + 1);
         const optionalPath = remainingPath.split('.').join('?.');

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

@@ -1,6 +1,7 @@
 /**
  * Shared utility functions for slice validation code generation.
  */
+import { stripSliceSuffix } from '../../core/utils.js';
 /** FHIR primitive type codes whose JSON extensions use _fieldName prefix. */
 export const FHIR_PRIMITIVES = new Set([
     'boolean', 'integer', 'string', 'decimal', 'uri', 'url', 'canonical',
@@ -56,7 +57,7 @@ export function detectNestedArray(relPath, fields) {
         const partialPath = pathParts.slice(0, i + 1).join('.');
         const parentField = fields.find(f => {
             const fieldPath = f.name.replace(/^[^.]+\./, '');
-            return fieldPath === partialPath || fieldPath.split(':')[0] === partialPath;
+            return fieldPath === partialPath || stripSliceSuffix(fieldPath) === partialPath;
         });
         if (parentField && parentField.isArray) {
             return {
@@ -101,7 +102,7 @@ export function rewritePrimitiveExtensionPath(relPath, fields) {
     const sdSuffix = parts.slice(0, extIdx).join('.');
     const parentField = fields.find(f => {
         const fPath = f.name.replace(/^[^.]+\./, '');
-        return fPath === sdSuffix || fPath.split(':')[0] === sdSuffix;
+        return fPath === sdSuffix || stripSliceSuffix(fPath) === sdSuffix;
     });
     if (parentField && FHIR_PRIMITIVES.has(parentField.type || '')) {
         parts[extIdx - 1] = `_${parentSegment}`;
@@ -209,7 +210,11 @@ export function collectWithinSliceMaxChildren(slice, fields) {
             .every((_, i) => isTraversableIntermediate(segments.slice(0, i + 1).join('.')));
         if (!intermediatesOk)
             continue;
-        const leaf = segments[segments.length - 1];
+        const leaf = segments.at(-1);
+        // relChild is non-empty here, so split() always produced a leaf; the guard is
+        // what tells the compiler, and skipping is right if a path ever arrives empty.
+        if (!leaf)
+            continue;
         const isChoiceType = leaf.endsWith('[x]');
         const propPath = [...segments.slice(0, -1), isChoiceType ? leaf.replace(/\[x\]$/, '') : leaf];
         result.push({ propPath, fhirPath: relChild, maxVal: f.max, isArray: !!f.isArray, isChoiceType });

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

@@ -25,7 +25,8 @@ export function instanceUrlForSlice(slice, fields) {
         if (childId === sliceFullId + '.url' && typeof f.fixedValue === 'string')
             return f.fixedValue;
     }
-    return slice.profileUrls?.length ? stripVersionFromCanonicalUrl(slice.profileUrls[0]) : undefined;
+    const firstProfile = slice.profileUrls?.[0];
+    return firstProfile ? stripVersionFromCanonicalUrl(firstProfile) : undefined;
 }
 /**
  * Build the walk down to the elements that *contain* a sub-extension slice.
@@ -54,7 +55,14 @@ export function buildSubExtensionScope(slice, fields) {
         return null;
     const hops = [];
     for (let i = 0; i < containerSegments.length; i++) {
-        const [prop, sliceName] = containerSegments[i].split(':');
+        const segment = containerSegments[i];
+        if (segment === undefined)
+            return null;
+        const [prop, sliceName] = segment.split(':');
+        // split() on a non-empty segment always yields a first part; bailing keeps the
+        // "no unscoped walk" guarantee this function exists for.
+        if (!prop)
+            return null;
         let url;
         if (sliceName) {
             const ancestorId = containerSegments.slice(0, i + 1).join('.');

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

@@ -1,3 +1,4 @@
+import { stripVersionFromCanonicalUrl } from '../../core/utils.js';
 import { buildNestedLoopCode, emitSystemPresenceLeaf, emitSystemOnlyLeaf, emitResolvedLeaf, } from './validatorBindingLeafEmitters.js';
 /**
  * Emit a typed read of `rel` off the resource.
@@ -106,7 +107,7 @@ function emitSystemPresenceFallback(output, field, rel, isNested, arrayFieldPath
     const type = field.type || field.baseTypeCode;
     if (type !== 'CodeableConcept' && type !== 'Coding' && type !== 'Quantity')
         return;
-    const vsUri = (field.binding.uri || '').split('|')[0];
+    const vsUri = stripVersionFromCanonicalUrl(field.binding.uri || '');
     const vsDisplayName = vsUri.split('/').pop() || vsUri;
     if (isNested) {
         const code = buildNestedLoopCode(field, rel, arrayFieldPaths, (leafAcc, indent, fType) => emitSystemPresenceLeaf(leafAcc, indent, fType, vsDisplayName, vsUri, field.isArray), `Required binding system-presence fallback for ${rel} (nested, ValueSet unresolved)`, type);
@@ -139,7 +140,7 @@ function emitSystemOnlyBinding(output, field, rel, isNested, vsInfo, arrayFieldP
     const type = field.type || field.baseTypeCode;
     if (type !== 'CodeableConcept' && type !== 'Coding' && type !== 'Quantity')
         return;
-    const sysVsUri = (field.binding.uri || '').split('|')[0];
+    const sysVsUri = stripVersionFromCanonicalUrl(field.binding.uri || '');
     const systemsLiteral = JSON.stringify(vsInfo.systems);
     const vsDisplayName = vsInfo.displayName;
     if (isNested) {
@@ -186,7 +187,7 @@ function emitResolvedBinding(output, field, rel, isNested, vsInfo, arrayFieldPat
     const type = field.type || field.baseTypeCode;
     const vsName = vsInfo.sanitizedName;
     const vsDisplayName = vsInfo.displayName;
-    const vsUri = (field.binding.uri || '').split('|')[0];
+    const vsUri = stripVersionFromCanonicalUrl(field.binding.uri || '');
     if (isNested) {
         const code = buildNestedLoopCode(field, rel, arrayFieldPaths, (leafAcc, indent, fType) => emitResolvedLeaf(leafAcc, indent, fType, vsName, vsDisplayName, vsUri, field.isArray), `Required ValueSet binding validation for ${rel} (nested)`, type);
         if (code)

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

@@ -1,3 +1,4 @@
+import { stripSliceSuffix } from '../../core/utils.js';
 /**
  * Build nested loop code for iterating through array parents to reach a leaf field.
  * Shared by all three binding modes (system-presence, system-only, resolved).
@@ -6,10 +7,10 @@ export function buildNestedLoopCode(field, rel, arrayFieldPaths, emitLeaf, comme
     const parts = rel.split('.');
     const leafField = parts[parts.length - 1];
     const loopInfos = [];
-    for (let i = 0; i < parts.length - 1; i++) {
+    for (const [i, segment] of parts.slice(0, -1).entries()) {
         const partialPath = parts.slice(0, i + 1).join('.');
-        const isArr = arrayFieldPaths.has(partialPath) || arrayFieldPaths.has(partialPath.split(':')[0]);
-        loopInfos.push({ segment: parts[i], isArray: isArr });
+        const isArr = arrayFieldPaths.has(partialPath) || arrayFieldPaths.has(stripSliceSuffix(partialPath));
+        loopInfos.push({ segment, isArray: isArr });
     }
     // A nested path with no array ancestor is still reachable: the loop below already
     // descends plain levels with an `if (… !== undefined)`. Requiring an array meant
@@ -21,8 +22,7 @@ export function buildNestedLoopCode(field, rel, arrayFieldPaths, emitLeaf, comme
     let code = `\n  // ${comment}`;
     let indent = '  ';
     let currentVar = 'resource';
-    for (let i = 0; i < loopInfos.length; i++) {
-        const li = loopInfos[i];
+    for (const [i, li] of loopInfos.entries()) {
         // Every level goes through `at()`, including the first. Reading `resource.x`
         // directly assumed the emitted interface declares `x`, which a logical model
         // does not: SDCQuestionLibrary derives from Resource, so `resource.address`

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

@@ -1,3 +1,4 @@
+import { stripSliceSuffix } from '../../core/utils.js';
 /**
  * Build required-field existence constraints.
  * Emits FHIRPath-style constraints for fields with min >= 1.
@@ -158,7 +159,8 @@ export function buildForbiddenFieldConstraintEntries(fields) {
         const eidRel = eid.replace(/^[^.]+\./, '');
         const concreteParts = eidRel.split('.').map(p => {
             if (p.includes(':')) {
-                const [basePart, sliceName] = p.split(':', 2);
+                const basePart = stripSliceSuffix(p);
+                const sliceName = p.substring(p.indexOf(':') + 1);
                 if (basePart.includes('[x]') && sliceName)
                     return sliceName;
                 return basePart;
@@ -216,7 +218,7 @@ export function buildPatternValidations(fields, arrayFieldPaths, fieldPathMap) {
         if (!isNestedInArray) {
             for (let i = 0; i < pathParts.length - 1; i++) {
                 const parentPath = pathParts.slice(0, i + 1).join('.');
-                if (arrayFieldPaths.has(parentPath) || arrayFieldPaths.has(parentPath.split(':')[0])) {
+                if (arrayFieldPaths.has(parentPath) || arrayFieldPaths.has(stripSliceSuffix(parentPath))) {
                     isNestedInArray = true;
                     break;
                 }
@@ -224,7 +226,7 @@ export function buildPatternValidations(fields, arrayFieldPaths, fieldPathMap) {
         }
         const pattern = field.patternConstraint;
         const parentFieldName = pathParts.length === 2 ? pathParts[0] : '';
-        const parentIsArray = parentFieldName && (arrayFieldPaths.has(parentFieldName) || arrayFieldPaths.has(parentFieldName.split(':')[0]));
+        const parentIsArray = parentFieldName && (arrayFieldPaths.has(parentFieldName) || arrayFieldPaths.has(stripSliceSuffix(parentFieldName)));
         const isNestedCodingPattern = pathParts.length === 2 && rel.endsWith('.coding')
             && parentIsArray
             && pattern && typeof pattern === 'object' && 'code' in pattern && !('coding' in pattern);
@@ -268,10 +270,10 @@ export function buildPatternValidations(fields, arrayFieldPaths, fieldPathMap) {
     return patternValidations;
 }
 function emitNestedCodingPattern(output, fields, pathParts, parentFieldName, pattern, humanRel) {
-    const parentPath = pathParts[0];
-    const parentBasePath = parentPath.split(':')[0];
+    const parentPath = pathParts[0] ?? '';
+    const parentBasePath = stripSliceSuffix(parentPath);
     const parentIsSliced = fields.some(f => f.sliceName &&
-        (f.name || '').replace(/^[^.]+\./, '').split(':')[0] === parentBasePath);
+        stripSliceSuffix((f.name || '').replace(/^[^.]+\./, '')) === parentBasePath);
     if (parentIsSliced)
         return;
     // Same split as the CodeableConcept case: identity here, pinned details below.

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

@@ -48,6 +48,50 @@ export function normalizeCollectionTypeFilters(expression) {
  * They are dropped for nested field paths, and kept at a single level for
  * recursive elements, rather than being walked through the whole recursion.
  */
+/**
+ * Escape a constraint expression for embedding in a double-quoted emitted string,
+ * and scope it to its element.
+ *
+ * Shared by the validator and the Zod emitter. Both evaluate the same FHIRPath
+ * against the same resource, so a second copy of this scoping would make the two
+ * disagree on the same profile — which parity would report as a real mismatch.
+ *
+ * If the expression does not already navigate from `fieldPath`, it is wrapped in
+ * `<path>.all(...)`. Only the START of the expression is checked: built
+ * constraints (e.g. "action.exists()") begin with the fieldPath, while
+ * field-level constraints are relative to the element and start with child
+ * names. Matching the fieldPath anywhere would false-positive on recursive
+ * elements, where "resource.exists() != action.exists()" on fieldPath "action"
+ * mentions the name only as a child reference.
+ *
+ * Resource-root constraints (fieldPath === baseResourceType) need the wrapping
+ * too: FHIRPath `implies` yields empty when the antecedent is missing, and
+ * `.all()` converts that to false, which is what HL7 and Firely report.
+ */
+export function scopeConstraintExpression(expression, fieldPath, opts = {}) {
+    let escaped = normalizeCollectionTypeFilters(expression || '')
+        .replace(/\s*\n\s*/g, ' ')
+        .replace(/\\/g, '\\\\')
+        .replace(/"/g, '\\"');
+    if (!fieldPath)
+        return escaped;
+    const escapedPath = fieldPath.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const navigationPattern = new RegExp(`^${escapedPath}\\s*\\.`);
+    const standalonePattern = new RegExp(`^${escapedPath}(?:[^.\\w]|$)`);
+    if (navigationPattern.test(escaped) || standalonePattern.test(escaped))
+        return escaped;
+    const resourceTypePattern = /^[A-Z][a-zA-Z]+\./;
+    if (resourceTypePattern.test(escaped))
+        return escaped;
+    const walkRecursion = !!opts.isRecursiveElement?.(fieldPath)
+        && !isBaseElementInvariant(expression || '');
+    const navigation = opts.sliceFilter
+        ? `${quoteFhirPathPath(fieldPath)}.where(${opts.sliceFilter})`
+        : quoteFhirPathPath(fieldPath);
+    const scope = walkRecursion ? `repeat(${navigation})` : navigation;
+    escaped = `${scope}.all(${escaped})`;
+    return escaped;
+}
 export function isBaseElementInvariant(expression) {
     return /^hasValue\(\)\s+or\s+\(children\(\)\.count\(\)\s*>\s*id\.count\(\)\)$/.test(expression)
         || /^extension\.exists\(\)\s*!=\s*value\.exists\(\)$/.test(expression);