babelfhir-ts 1.5.21 → 1.6.0

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/sliceValidatorGenerator.js

@@ -5,7 +5,7 @@
  */
 import { addDiagnostic } from '../../core/sdDiagnostics.js';
 import { INLINE_RESOURCE_SLOTS } from './validatorFieldBuilders.js';
-import { safeAccessor, safeList, sliceElseBranch, rewritePrimitiveExtensionPath, isArrayPath, resolveNestedPatternChild } from './sliceValidatorUtils.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';
@@ -311,27 +311,11 @@ function generatePatternCodeableConceptValidation(slice, relPath, errorPath, sli
             ? `${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);
-      }
-    }`;
-        }
+        // 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 +355,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;
@@ -522,9 +506,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

@@ -209,7 +209,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/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);

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

@@ -1,4 +1,4 @@
-import { choicePropertyName, narrowedChoiceType } from '../../core/utils.js';
+import { choicePropertyName, narrowedChoiceType, stripSliceSuffix } from '../../core/utils.js';
 /**
  * The element slots FHIR types as `Resource`, i.e. the ones that hold an inline
  * resource rather than a reference to one: DomainResource.contained,
@@ -22,7 +22,7 @@ const ABSTRACT_RESOURCE_TYPES = new Set(['Resource', 'DomainResource']);
  * HL7 uses, so this cannot flag a conformant resource.
  */
 function buildNestedObjectTypeValidations(fields, arrayFieldPaths, result) {
-    const isArrayPath = (p) => arrayFieldPaths.has(p) || arrayFieldPaths.has(p.split(':')[0]);
+    const isArrayPath = (p) => arrayFieldPaths.has(p) || arrayFieldPaths.has(stripSliceSuffix(p));
     const seen = new Set();
     for (const field of fields) {
         if (field.sliceName || field.isArray)
@@ -63,6 +63,7 @@ function buildNestedObjectTypeValidations(fields, arrayFieldPaths, result) {
         const body = `${indent}const _soValue = at(${expr}, '${leaf}');
 ${indent}if (_soValue !== undefined && _soValue !== null && typeof _soValue !== 'object') {
 ${indent}  errors.push("The property ${leaf} must be an Object, not a Primitive property (at ${rel})");
+${indent}  _structuralFailures.add('${rel}');
 ${indent}}`;
         result.push(`
   // Structural type check: ${rel} must be an Object
@@ -160,8 +161,9 @@ export function buildInlineResourceTypeValidations(fields, profileUrl) {
  * is one identifier among several, so requiring its children of every identifier
  * would report a conformant resource.
  */
+/** Undefined for an empty path, which callers treat as "nothing to check". */
 function leafFieldName(parts) {
-    return parts[parts.length - 1];
+    return parts.at(-1);
 }
 function resolveChoiceSliceSegments(elementIdRel) {
     const segments = elementIdRel.split('.');
@@ -172,7 +174,7 @@ function resolveChoiceSliceSegments(elementIdRel) {
             continue;
         }
         const [base, sliceName] = segment.split(':');
-        if (!base.endsWith('[x]') || !sliceName)
+        if (!base || !base.endsWith('[x]') || !sliceName)
             return undefined;
         const baseProp = base.slice(0, -'[x]'.length);
         if (!sliceName.startsWith(baseProp) || sliceName === baseProp)
@@ -236,17 +238,20 @@ export function buildNestedRequiredValidations(fields, arrayFieldPaths) {
             // Only an unambiguous choice yields one property name. A multi-typed choice
             // may legitimately carry any variant, and picking one would flag a conformant
             // resource — which is what the previous depth guard was protecting against.
-            if (uniqueTypes.length !== 1)
+            const [onlyType] = uniqueTypes;
+            if (uniqueTypes.length !== 1 || !onlyType)
                 return;
-            const choiceSuffix = uniqueTypes[0].charAt(0).toUpperCase() + uniqueTypes[0].slice(1);
+            const choiceSuffix = onlyType.charAt(0).toUpperCase() + onlyType.slice(1);
             rel = relFull.replace(/^[^.]+\./, '').replace(/\[x\]/, choiceSuffix);
         }
         const resolvedParts = rel.split('.');
-        const isArrayPath = (p) => arrayFieldPaths.has(p) || arrayFieldPaths.has(p.split(':')[0]);
+        const isArrayPath = (p) => arrayFieldPaths.has(p) || arrayFieldPaths.has(stripSliceSuffix(p));
         // Check which intermediate parts are arrays
         const intermediateParts = resolvedParts.slice(1, -1);
         const hasIntermediateArray = intermediateParts.some((_part, idx) => isArrayPath(resolvedParts.slice(0, idx + 2).join('.')));
         const arrayParent = resolvedParts[0];
+        if (!arrayParent)
+            return;
         const topIsArray = isArrayPath(arrayParent);
         // An array is needed somewhere above the leaf, but it need not be the first
         // segment: the flat branches below index straight into resource.<arrayParent>,
@@ -275,17 +280,22 @@ export function buildNestedRequiredValidations(fields, arrayFieldPaths) {
   }`);
             return;
         }
-        const leafField = resolvedParts[resolvedParts.length - 1];
+        const leafField = resolvedParts.at(-1);
+        if (!leafField)
+            return;
         // Check if the leaf field itself is an array — if so, don't flag Array values as absent
         const fullLeafPath = resolvedParts.join('.');
-        const leafIsArray = arrayFieldPaths.has(fullLeafPath) || arrayFieldPaths.has(fullLeafPath.split(':')[0]);
+        const leafIsArray = arrayFieldPaths.has(fullLeafPath) || arrayFieldPaths.has(stripSliceSuffix(fullLeafPath));
         if (hasIntermediateArray) {
             // Build nested for-loops for paths with intermediate arrays
             const levels = [];
             for (let i = 0; i < resolvedParts.length - 1; i++) {
+                const name = resolvedParts[i];
+                if (!name)
+                    continue;
                 const pathToHere = resolvedParts.slice(0, i + 1).join('.');
-                const isArr = arrayFieldPaths.has(pathToHere) || arrayFieldPaths.has(pathToHere.split(':')[0]);
-                levels.push({ name: resolvedParts[i], isArray: isArr });
+                const isArr = arrayFieldPaths.has(pathToHere) || arrayFieldPaths.has(stripSliceSuffix(pathToHere));
+                levels.push({ name, isArray: isArr });
             }
             const lines = [];
             let indent = '  ';
@@ -295,6 +305,8 @@ export function buildNestedRequiredValidations(fields, arrayFieldPaths) {
             let isTyped = true;
             for (let i = 0; i < levels.length; i++) {
                 const level = levels[i];
+                if (!level)
+                    continue;
                 const child = isTyped ? `${currentVar}.${level.name}` : `at(${currentVar}, '${level.name}')`;
                 if (level.isArray) {
                     const loopVar = `_nrEl${i}`;
@@ -393,7 +405,7 @@ function emitNestedFixedValue(result, rel, field, arrayFieldPaths, profileUrl, b
         .some(candidate => candidate.split('.').some(segment => segment.includes(':')));
     if (hasSliceQualifier)
         return;
-    const isArrayPath = (p) => arrayFieldPaths.has(p) || arrayFieldPaths.has(p.split(':')[0]);
+    const isArrayPath = (p) => arrayFieldPaths.has(p) || arrayFieldPaths.has(stripSliceSuffix(p));
     const segments = rel.split('.');
     const parents = segments.slice(0, -1);
     const leaf = segments[segments.length - 1];
@@ -547,9 +559,9 @@ export function buildProhibitedFieldValidations(fields, arrayFieldPaths, fieldPa
         const resolvedParts = eidRel.split('.').map(p => {
             if (p.includes(':')) {
                 const [basePart, sliceName] = p.split(':', 2);
-                if (basePart.includes('[x]') && sliceName)
+                if (basePart?.includes('[x]') && sliceName)
                     return sliceName;
-                return basePart;
+                return basePart ?? p;
             }
             return p.replace(/\[x\]$/, '');
         });
@@ -573,9 +585,13 @@ export function buildProhibitedFieldValidations(fields, arrayFieldPaths, fieldPa
         }
         else if (pathParts.length >= 2) {
             const arrayParent = pathParts[0];
-            if (!arrayFieldPaths.has(arrayParent) && !arrayFieldPaths.has(arrayParent.split(':')[0]))
+            if (!arrayParent)
+                return;
+            if (!arrayFieldPaths.has(arrayParent) && !arrayFieldPaths.has(stripSliceSuffix(arrayParent)))
+                return;
+            const leafField = pathParts.at(-1);
+            if (!leafField)
                 return;
-            const leafField = pathParts[pathParts.length - 1];
             const fullPath = `${resourceType}.${rel}`;
             // `at()` walks the dotted path and yields `unknown`, so the prohibited
             // field is probed without widening the element to `any`.
@@ -703,7 +719,7 @@ const CONTAINER_TYPES = new Set([
  * `constraint` looking like an HL7-only finding.
  */
 function buildArrayNestedPrimitiveKindValidations(fields, arrayFieldPaths, result) {
-    const isArrayPath = (p) => arrayFieldPaths.has(p) || arrayFieldPaths.has(p.split(':')[0]);
+    const isArrayPath = (p) => arrayFieldPaths.has(p) || arrayFieldPaths.has(stripSliceSuffix(p));
     const seen = new Set();
     for (const field of fields) {
         if (field.sliceName || field.isArray)
@@ -846,6 +862,7 @@ export function buildStructuralTypeValidations(fields, arrayFieldPaths) {
     if (_stValue !== undefined && _stValue !== null && typeof _stValue !== 'object') {
       const _stType = at(resource, 'resourceType');
       errors.push("The property ${rel} must be an Object, not a Primitive property (at " + (typeof _stType === 'string' ? _stType : "Resource") + ".${rel})");
+      _structuralFailures.add('${rel}');
     }
   }`);
             }

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

@@ -8,7 +8,7 @@ import { buildNestedRequiredValidations, buildFixedValueValidations, buildProhib
 import { buildBindingValidations } from './validatorBindingBuilder.js';
 import { generateBundleRefValidation, generateContainedRefValidation, generateExtensionStructuralValidation, generateAggregationRefValidation, buildReferenceTargetTypeValidation, buildBundleEntryResolution } from './validatorTemplates.js';
 import { HELPER_NAMES } from './validatorRuntime.js';
-import { quoteFhirPathPath, normalizeCollectionTypeFilters, isBaseElementInvariant } from './validatorExpressions.js';
+import { isBaseElementInvariant, scopeConstraintExpression } from './validatorExpressions.js';
 const log = logger.withTag('validator');
 /**
  * A constraint declared on a slice applies only to that slice's members.
@@ -407,55 +407,40 @@ export function generateValidateProfileFunction(interfaceName, fields, valueSets
         const lastSegment = path.split('.').pop() || '';
         return !!lastSegment && relativeFieldNames.has(`${path}.${lastSegment}`);
     };
+    // Paths a structural type check can actually record, read back from the code
+    // just emitted rather than re-deriving which fields qualify — two copies of
+    // that predicate would drift, and a guard on a path nothing records is a dead
+    // conditional in every generated validator.
+    const structuralFailurePaths = new Set([...structuralTypeValidations.join('').matchAll(/_structuralFailures\.add\('([^']+)'\)/g)].map(m => m[1]));
+    const hasStructuralChecks = structuralFailurePaths.size > 0;
     // ── Generate FHIRPath evaluation code ───────────────────────────────────
     const validationLogic = filteredConstraints
         .map((item, index) => {
         const constraint = item.constraint;
         const fieldPath = item.fieldPath;
-        let escapedExpression = normalizeCollectionTypeFilters(constraint.expression || '')
-            .replace(/\s*\n\s*/g, ' ')
-            .replace(/\\/g, '\\\\')
-            .replace(/"/g, '\\"');
+        // Shared with the Zod emitter so both evaluate the identical expression.
+        const escapedExpression = scopeConstraintExpression(constraint.expression || '', fieldPath, {
+            isRecursiveElement,
+            sliceFilter: item.sliceFilter,
+        });
         const escapedHuman = (constraint.human || '').replace(/"/g, '\\"').replace(/[\r\n]+/g, ' ');
-        // Scope constraints to their fieldPath if needed
-        // If fieldPath exists and the expression doesn't already navigate FROM it,
-        // wrap with .all() so the constraint evaluates relative to each element.
-        // Only check the START of the expression — built constraints (e.g.,
-        // "action.exists()") always begin with the fieldPath, while field-level
-        // constraints are relative to the element and start with child names.
-        // Checking for fieldPath anywhere in the expression causes false positives
-        // for recursive elements (e.g., "resource.exists() != action.exists()"
-        // on fieldPath "action" — the expression contains "action" but only as a
-        // child property reference, not a root navigation).
-        //
-        // NOTE: resource-root constraints (fieldPath === baseResourceType) also
-        // need .all() wrapping.  FHIRPath `implies` returns empty when the
-        // antecedent is missing, and .all() correctly converts that to false —
-        // matching the HL7 / Firely validator behavior which fires the constraint.
-        if (fieldPath) {
-            const escaped = fieldPath.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-            const fieldPathNavigationPattern = new RegExp(`^${escaped}\\s*\\.`);
-            const fieldPathStandalonePattern = new RegExp(`^${escaped}(?:[^.\\w]|$)`);
-            const expressionRefersToField = fieldPathNavigationPattern.test(escapedExpression) || fieldPathStandalonePattern.test(escapedExpression);
-            if (!expressionRefersToField) {
-                const resourceTypePattern = /^[A-Z][a-zA-Z]+\./;
-                if (!resourceTypePattern.test(escapedExpression)) {
-                    const walkRecursion = isRecursiveElement(fieldPath)
-                        && !isBaseElementInvariant(constraint.expression || '');
-                    const navigation = item.sliceFilter
-                        ? `${quoteFhirPathPath(fieldPath)}.where(${item.sliceFilter})`
-                        : quoteFhirPathPath(fieldPath);
-                    const scope = walkRecursion ? `repeat(${navigation})` : navigation;
-                    escapedExpression = `${scope}.all(${escapedExpression})`;
-                }
-            }
-        }
         const needsTerminology = /\bmemberOf\b/.test(constraint.expression || '');
         let evaluateBlock = `
     const result${index} = await fhirpath.evaluate(resource, "${escapedExpression}", { resource, rootResource: resource }, fhirpath_model, fhirpathOptions);
     if (!result${index}.every(Boolean)) {
       ${constraint.severity === "error" ? "errors" : "warnings"}.push("Constraint violation: ${escapedHuman}");
     }`;
+        // One defect, one diagnostic. An element that failed its structural type
+        // check cannot satisfy an invariant that inspects its children, so
+        // evaluating them here adds a second error for the same root cause — the
+        // ele-1 ("must have a @value or children") cascade behind
+        // ClinicalUseDefinition*, where HL7 reports only the type error. HL7 is
+        // the reference implementation and reports the root cause once.
+        if (fieldPath && structuralFailurePaths.has(fieldPath)) {
+            evaluateBlock = `
+    if (!_structuralFailures.has('${fieldPath}')) {${evaluateBlock}
+    }`;
+        }
         // 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
@@ -545,6 +530,12 @@ ${body}
         fhirpathOptionsLines.push('    async: true as const,', '    ...(options?.terminologyUrl ? { terminologyUrl: options.terminologyUrl } : {}),', '    ...(options?.fhirServerUrl ? { fhirServerUrl: options.fhirServerUrl } : {}),');
     }
     const fhirpathOptionsBlock = `const fhirpathOptions = {\n${fhirpathOptionsLines.join('\n')}\n  };`;
+    // Paths whose value is the wrong JSON kind. Populated by the structural type
+    // checks, which the assembled body now runs before any invariant so the guard
+    // has something to read.
+    const structuralFailureDecl = hasStructuralChecks
+        ? 'const _structuralFailures = new Set<string>();\n  '
+        : '';
     let valueSetImportStatements = '';
     if (valueSetImports.size > 0) {
         valueSetImportStatements = Array.from(valueSetImports.entries())
@@ -562,8 +553,8 @@ ${body}
         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}
-  ${bundleEntryResolution}${referenceTargetTypeValidation}${validationLogic}${fixedPatternValidations.join('')}${nestedRequiredValidations.join('')}${fixedValueValidations.join('')}${structuralTypeValidations.join('')}${prohibitedFieldValidations.join('')}${bindingValidations.join('')}${primitiveFormatValidations.join('')}${choiceNarrowingValidations.join('')}${sliceValidations.join('')}${closedSlicingValidations.join('')}${datatypeProfileDelegations.join('')}${nonDomainTextCheck}${extensionStructuralValidation}${containedRefValidation}${bundledAggregationValidation}${bundleRefValidation}
+  ${structuralFailureDecl}${fhirpathOptionsBlock}
+  ${bundleEntryResolution}${referenceTargetTypeValidation}${structuralTypeValidations.join('')}${validationLogic}${fixedPatternValidations.join('')}${nestedRequiredValidations.join('')}${fixedValueValidations.join('')}${prohibitedFieldValidations.join('')}${bindingValidations.join('')}${primitiveFormatValidations.join('')}${choiceNarrowingValidations.join('')}${sliceValidations.join('')}${closedSlicingValidations.join('')}${datatypeProfileDelegations.join('')}${nonDomainTextCheck}${extensionStructuralValidation}${containedRefValidation}${bundledAggregationValidation}${bundleRefValidation}
   return { errors, warnings };
 }`,
         valueSetImports

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

@@ -26,8 +26,19 @@ export interface ValidatorOptions {
   terminologyUrl?: string;
   /** FHIR server URL for resolve() evaluation (e.g. "https://hapi.fhir.org/baseR4"). */
   fhirServerUrl?: string;
-  /** HTTP headers keyed by server URL — used for auth with terminology or FHIR servers. */
-  httpHeaders?: Record<string, string>;
+  /**
+   * HTTP headers for auth with terminology or FHIR servers, keyed by server base
+   * URL, each mapping header name to value:
+   *
+   *     { "https://tx.fhir.org/r4": { Authorization: "Bearer …" } }
+   *
+   * Two levels, not one. The comment always said "keyed by server URL" while the
+   * type said \`Record<string, string>\`, so a caller typing against it wrote
+   * \`{ Authorization: "Bearer …" }\` — which fhirpath reads as base URL
+   * "Authorization" with a string where a header map belongs, and the header is
+   * never sent. fhirpath 5.1.0 corrected the same mistake in its own declaration.
+   */
+  httpHeaders?: Record<string, Record<string, string>>;
   /** AbortSignal for cancelling long-running async evaluations. */
   signal?: AbortSignal;
   /** Debug tracing callback — invoked for every FHIRPath trace() call. */

package/out/src/generator/emitters/valueset/valueSetGenerator.js

@@ -2,6 +2,7 @@
  * ValueSet Generator
  * Generates TypeScript files for FHIR ValueSets with runtime validation support
  */
+import { pascalCaseIdentifier } from '../../core/utils.js';
 /**
  * Assign a unique identifier to every ValueSet that will be emitted.
  *
@@ -148,16 +149,11 @@ export function generateValueSetTypeScript(valueSet, options) {
  * Sanitize ValueSet name for use as TypeScript identifier
  */
 export function sanitizeValueSetName(name) {
-    // Remove common prefixes
-    let sanitized = name.replace(/^ValueSet[-_]?/i, '');
-    // Split on non-alphanumeric and capitalize each part
-    const parts = sanitized.split(/[^a-zA-Z0-9]+/).filter(Boolean);
-    sanitized = parts.map(p => p.charAt(0).toUpperCase() + p.slice(1)).join('');
-    // Ensure it starts with a letter
-    if (/^[0-9]/.test(sanitized)) {
-        sanitized = 'VS' + sanitized;
-    }
-    return sanitized || 'UnnamedValueSet';
+    return pascalCaseIdentifier(name, {
+        stripPrefix: /^ValueSet[-_]?/i,
+        digitPrefix: 'VS',
+        fallback: 'UnnamedValueSet',
+    });
 }
 /**
  * Generate a ValueSet registry file that exports all ValueSets