babelfhir-ts 1.5.19 → 1.5.21

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

@@ -1,7 +1,186 @@
+import { choicePropertyName, narrowedChoiceType } 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,
+ * Bundle.entry.resource and Parameters.parameter.resource. A profile narrows them
+ * by naming concrete resource types — QuestionnaireResponse.contained restricted
+ * to Questionnaire, for instance.
+ */
+export const INLINE_RESOURCE_SLOTS = new Set(['contained', 'resource']);
+/** Type codes that place no restriction on which resource may appear. */
+const ABSTRACT_RESOURCE_TYPES = new Set(['Resource', 'DomainResource']);
+/**
+ * A complex-typed element below the root must still be a JSON object.
+ *
+ * The depth-1 pass covers only top-level fields, and it also skips container types,
+ * so Bundle.entry.resource was never checked at any depth — HL7 reports
+ * "The property resource must be an Object, not a Primitive property
+ * (at Bundle.entry[0].resource)" and we reported nothing. Containers are included
+ * here: a Resource-valued element holding a primitive is malformed regardless.
+ *
+ * Only fires on a value that is present and primitive, which is the same condition
+ * 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 seen = new Set();
+    for (const field of fields) {
+        if (field.sliceName || field.isArray)
+            continue;
+        const fullPath = field.name || '';
+        if (fullPath.includes('[x]'))
+            continue;
+        const rel = fullPath.replace(/^[^.]+\./, '');
+        if (!rel.includes('.') || seen.has(rel))
+            continue;
+        const fieldType = field.type || field.baseTypeCode;
+        if (!fieldType || isFhirPrimitive(fieldType))
+            continue;
+        // A primitive-valued element is checked by the format validations instead.
+        if (fieldType.startsWith('http://hl7.org/fhirpath/'))
+            continue;
+        const segments = rel.split('.');
+        const parents = segments.slice(0, -1);
+        const leaf = segments[segments.length - 1];
+        // Walk the parents, iterating any array level so each member is checked.
+        let expr = 'resource';
+        const open = [];
+        let indent = '    ';
+        parents.forEach((segment, i) => {
+            const pathToHere = parents.slice(0, i + 1).join('.');
+            if (isArrayPath(pathToHere)) {
+                const loopVar = `_soEl${i}`;
+                open.push(`${indent}for (const ${loopVar} of arr(at(${expr}, '${segment}'))) {`);
+                indent += '  ';
+                expr = loopVar;
+            }
+            else {
+                expr = `at(${expr}, '${segment}')`;
+            }
+        });
+        seen.add(rel);
+        const closes = open.map((_l, i) => '  '.repeat(open.length - i + 1) + '}').join('\n');
+        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}}`;
+        result.push(`
+  // Structural type check: ${rel} must be an Object
+  {
+${[...open, body, closes].filter(Boolean).join('\n')}
+  }`);
+    }
+}
+/**
+ * Build inline-resource type validations.
+ *
+ * An inline resource must carry a `resourceType`, and where the profile narrows
+ * the slot that type must be one it allows. We checked neither, so a resource
+ * generated without a resourceType — or of a type the profile forbids — passed
+ * while HL7 reported "Unable to find resourceType property" and "The type 'X' is
+ * not valid - no resources allowed here".
+ *
+ * Slots left as Resource/DomainResource are unrestricted and only get the
+ * resourceType presence check, which is what HL7 does too.
+ */
+export function buildInlineResourceTypeValidations(fields, profileUrl) {
+    const result = [];
+    // A slot can appear twice once base and profile fields are merged; emitting both
+    // would report the same violation twice.
+    const seen = new Set();
+    for (const field of fields) {
+        if (field.sliceName)
+            continue;
+        const rel = (field.name || '').replace(/^[^.]+\./, '');
+        if (seen.has(rel))
+            continue;
+        // Only the top-level slot for now; Bundle.entry.resource sits under an array
+        // and is covered by the Bundle-specific entry validation.
+        if (!rel || rel.includes('.') || !INLINE_RESOURCE_SLOTS.has(rel))
+            continue;
+        const declaredCodes = (field.typeOptions?.length
+            ? field.typeOptions.map(option => option.code)
+            : [field.type || field.baseTypeCode || '']).filter(code => /^[A-Z][A-Za-z]+$/.test(code));
+        if (declaredCodes.length === 0)
+            continue;
+        seen.add(rel);
+        const allowed = [...new Set(declaredCodes)].filter(code => !ABSTRACT_RESOURCE_TYPES.has(code));
+        const member = field.isArray ? '_irItem' : `at(resource, '${rel}')`;
+        const typeCheck = allowed.length > 0
+            ? `
+      } else if (typeof _irType === 'string' && !${JSON.stringify(allowed)}.includes(_irType)) {
+        errors.push("The type '" + _irType + "' is not valid - no resources allowed here (allowed = ${allowed.join(', ')})");`
+            : '';
+        // A contained resource is only reachable through a '#id' reference, so FHIR
+        // requires the id — HL7 reports it right alongside the missing resourceType.
+        const idCheck = rel === 'contained'
+            ? `
+      if (at(${member}, 'id') === undefined) {
+        errors.push("Resource requires an id, but none is present");
+      }`
+            : '';
+        // An untyped inline resource reads as a bare `Resource`, so a narrowed slot is
+        // also violated on type. HL7 reports all three together — the missing property,
+        // the profile's declared type, and the slot's allowed set — and reporting only
+        // the first left the other two attributed to HL7 alone.
+        const untypedIsWrongType = allowed.length > 0
+            ? `
+        errors.push("The Profile '${(profileUrl || '').replace(/'/g, "\\'")}' definition allows for the type ${allowed.join(', ')} but found type Resource");
+        errors.push("The type 'Resource' is not valid - no resources allowed here (allowed = ${allowed.join(', ')})");`
+            : '';
+        const body = `
+      const _irType = at(${member}, 'resourceType');
+      if (_irType === undefined) {
+        errors.push("Unable to find resourceType property");${untypedIsWrongType}${typeCheck}
+      }${idCheck}`;
+        result.push(field.isArray
+            ? `
+  // Inline resource check for ${rel}${allowed.length > 0 ? ` (restricted to ${allowed.join(', ')})` : ''}
+  for (const _irItem of arr(at(resource, '${rel}'))) {${body}
+  }`
+            : `
+  // Inline resource check for ${rel}${allowed.length > 0 ? ` (restricted to ${allowed.join(', ')})` : ''}
+  if (at(resource, '${rel}') !== undefined) {${body}
+  }`);
+    }
+    return result;
+}
 /**
  * Build deeply nested required field validations.
  * For fields like component.value[x].data (min=1) where the parent is an array.
  */
+/**
+ * Rewrite an element id whose only slice qualifiers name choice-type variants into
+ * the concrete JSON path, or undefined when any qualifier discriminates a subset.
+ *
+ * `ingredient.item[x]:itemCodeableConcept.text` → `ingredient.itemCodeableConcept.text`.
+ * A qualifier is only accepted when its base ends in `[x]` and the slice name starts
+ * with the base property, which is the convention that makes the slice name the
+ * property name. `identifier:NPI.value` fails both tests and is still skipped: NPI
+ * is one identifier among several, so requiring its children of every identifier
+ * would report a conformant resource.
+ */
+function leafFieldName(parts) {
+    return parts[parts.length - 1];
+}
+function resolveChoiceSliceSegments(elementIdRel) {
+    const segments = elementIdRel.split('.');
+    const out = [];
+    for (const segment of segments) {
+        if (!segment.includes(':')) {
+            out.push(segment.replace(/\[x\]$/, ''));
+            continue;
+        }
+        const [base, sliceName] = segment.split(':');
+        if (!base.endsWith('[x]') || !sliceName)
+            return undefined;
+        const baseProp = base.slice(0, -'[x]'.length);
+        if (!sliceName.startsWith(baseProp) || sliceName === baseProp)
+            return undefined;
+        out.push(sliceName);
+    }
+    return out.join('.');
+}
 export function buildNestedRequiredValidations(fields, arrayFieldPaths) {
     const result = [];
     fields
@@ -15,44 +194,87 @@ export function buildNestedRequiredValidations(fields, arrayFieldPaths) {
         let rel = relFull.replace(/^[^.]+\./, '').replace(/\[x\]/g, '');
         if (!rel)
             return;
-        // Skip slice-specific fields
+        // Skip slice-specific fields: a slice's requirements bind only its own
+        // members, and this builder emits an unconditional check.
+        //
+        // One exception, and it is not really a subset. A choice-type slice names a
+        // JSON property rather than discriminating within one: FHIR writes
+        // `item[x]:itemCodeableConcept` for the CodeableConcept variant of `item[x]`,
+        // and an instance carrying that variant writes `itemCodeableConcept`. So the
+        // slice *is* the property, and its required children apply whenever the
+        // property is present — which is what HL7 reports as
+        // "Medication.ingredient.item[x]:itemCodeableConcept.text: minimum required = 1"
+        // where we said nothing, because `field.name` flattens `item[x]` to `item`
+        // and loses which variant was meant.
         const elementId = field.elementId || relFull;
-        if (elementId.includes(':'))
-            return;
+        let choiceSliceResolved = false;
+        if (elementId.includes(':')) {
+            const resolved = resolveChoiceSliceSegments(elementId.replace(/^[^.]+\./, ''));
+            if (!resolved)
+                return;
+            rel = resolved;
+            choiceSliceResolved = true;
+        }
         const pathParts = rel.split('.');
         if (pathParts.length < 2)
             return;
-        // Resolve choice type in path
-        if (relFull.includes('[x]')) {
-            const relFullWithoutLeaf = relFull.substring(0, relFull.lastIndexOf('.'));
-            const parentField = fields.find(f => f.name === relFullWithoutLeaf);
-            const parentType = parentField?.baseTypeCode || parentField?.type;
-            // BackboneElement/Element are container types, never valid choice[x] suffixes.
-            // e.g. CodeSystem.concept.property is BackboneElement, but property.value[x]
-            // resolves to code/Coding/string/etc — not valueBackboneElement.
-            if (parentType && parentType !== 'any'
-                && parentType !== 'BackboneElement' && parentType !== 'Element') {
-                const choiceSuffix = parentType.charAt(0).toUpperCase() + parentType.slice(1);
-                rel = relFull.replace(/^[^.]+\./, '').replace(/\[x\]/, choiceSuffix);
-            }
-            else {
+        // Resolve choice type in path. Skipped when the element id already named the
+        // variant: this block reads the *leaf's* own type, which for a nested leaf
+        // (…item[x]:itemCodeableConcept.text) is the text's type, not the choice's.
+        if (relFull.includes('[x]') && !choiceSliceResolved) {
+            // The JSON property name comes from the element's *own* type, not its parent's.
+            // Reading the parent discarded the check whenever that parent was a container:
+            // Claim.item.location[x] is typed CodeableConcept, so the property is
+            // locationCodeableConcept, but item is a BackboneElement and the whole check
+            // was dropped — HL7 reported "Claim.item.location[x]: minimum required = 1"
+            // alone.
+            const ownTypes = (field.typeOptions?.length
+                ? field.typeOptions.map(option => option.code)
+                : [field.type || field.baseTypeCode || '']).filter(code => /^[A-Za-z][A-Za-z0-9]*$/.test(code)
+                && code !== 'BackboneElement' && code !== 'Element' && code !== 'any');
+            const uniqueTypes = [...new Set(ownTypes)];
+            // 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)
                 return;
-            }
+            const choiceSuffix = uniqueTypes[0].charAt(0).toUpperCase() + uniqueTypes[0].slice(1);
+            rel = relFull.replace(/^[^.]+\./, '').replace(/\[x\]/, choiceSuffix);
         }
         const resolvedParts = rel.split('.');
-        // Skip shallow choice-type paths — choice types at depth 2 are direct children
-        // of array parents where the substitution may not apply to all instances
-        if (relFull.includes('[x]') && resolvedParts.length < 3)
-            return;
-        const arrayParent = resolvedParts[0];
-        if (!arrayFieldPaths.has(arrayParent) && !arrayFieldPaths.has(arrayParent.split(':')[0]))
-            return;
+        const isArrayPath = (p) => arrayFieldPaths.has(p) || arrayFieldPaths.has(p.split(':')[0]);
         // Check which intermediate parts are arrays
         const intermediateParts = resolvedParts.slice(1, -1);
-        const hasIntermediateArray = intermediateParts.some((_part, idx) => {
-            const intermediatePath = resolvedParts.slice(0, idx + 2).join('.');
-            return arrayFieldPaths.has(intermediatePath) || arrayFieldPaths.has(intermediatePath.split(':')[0]);
-        });
+        const hasIntermediateArray = intermediateParts.some((_part, idx) => isArrayPath(resolvedParts.slice(0, idx + 2).join('.')));
+        const arrayParent = resolvedParts[0];
+        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>,
+        // whereas the nested-loop branch walks any shape. Requiring the *first*
+        // segment to be an array meant a path whose only array sits deeper
+        // (Observation.code.coding.code — code is 0..1, coding is the array) bailed
+        // out and emitted nothing, leaving HL7 to report the missing element alone.
+        if (!topIsArray && !hasIntermediateArray) {
+            // A choice-slice path is emitted even when no level is a known array.
+            // `Medication.ingredient` is 0..* in the base but the KBV differential
+            // constrains only its `min`, so the merged field carries no max and
+            // `isArray` reads false — the check bailed and HL7 reported
+            // "…itemCodeableConcept.text: minimum required = 1" alone. `elementsAt`
+            // flattens an array level and passes a single object through unchanged,
+            // so it is right either way and does not depend on that flag.
+            if (!choiceSliceResolved)
+                return;
+            const walk = resolvedParts.slice(0, -1).map(p => `'${p}'`).join(', ');
+            result.push(`
+  // Nested required field: ${rel} (min=1)
+  for (const _nrEl of elementsAt(resource, [${walk}])) {
+    const _nrLeaf = at(_nrEl, '${leafFieldName(resolvedParts)}');
+    if (_nrLeaf === undefined || _nrLeaf === null) {
+      errors.push("Missing required member: '${leafFieldName(resolvedParts)}'");
+    }
+  }`);
+            return;
+        }
         const leafField = resolvedParts[resolvedParts.length - 1];
         // Check if the leaf field itself is an array — if so, don't flag Array values as absent
         const fullLeafPath = resolvedParts.join('.');
@@ -148,17 +370,88 @@ export function buildNestedRequiredValidations(fields, arrayFieldPaths) {
 /**
  * Build fixed value validations (fixedValue on fields).
  */
-export function buildFixedValueValidations(fields, _arrayFieldPaths) {
+/**
+ * Emit a fixed-value check for an element below the resource root.
+ *
+ * Uses HL7's wording, whose `#Type.path` fragment is what attributes the finding
+ * to the pinned leaf: a bare message would land on `constraint` instead of
+ * `reference`. Array parents are walked so each member is checked.
+ */
+function emitNestedFixedValue(result, rel, field, arrayFieldPaths, profileUrl, baseResourceType) {
+    const fixedValue = field.fixedValue;
+    if (typeof fixedValue !== 'string' && typeof fixedValue !== 'number' && typeof fixedValue !== 'boolean')
+        return;
+    // A pin declared on a slice applies only to that slice's members. field.name
+    // carries no slice identity, so emitting it against the base element applied one
+    // slice's pin to every member: AuditEvent.agent:user.requestor is fixed to true,
+    // and checking it on all agents failed agent:client and agent:server, which
+    // legitimately carry false. Same rule the forbidden-field builder follows.
+    // Slice qualifiers appear in elementId for most fields and in name for some, so
+    // both are checked — relying on elementId alone let a Parameters part slice
+    // through.
+    const hasSliceQualifier = [field.elementId || '', field.name || '', rel]
+        .some(candidate => candidate.split('.').some(segment => segment.includes(':')));
+    if (hasSliceQualifier)
+        return;
+    const isArrayPath = (p) => arrayFieldPaths.has(p) || arrayFieldPaths.has(p.split(':')[0]);
+    const segments = rel.split('.');
+    const parents = segments.slice(0, -1);
+    const leaf = segments[segments.length - 1];
+    let expr = 'resource';
+    const open = [];
+    let indent = '    ';
+    parents.forEach((segment, i) => {
+        const pathToHere = parents.slice(0, i + 1).join('.');
+        if (isArrayPath(pathToHere)) {
+            const loopVar = `_fvParent${i}`;
+            open.push(`${indent}for (const ${loopVar} of arr(at(${expr}, '${segment}'))) {`);
+            indent += '  ';
+            expr = loopVar;
+        }
+        else {
+            expr = `at(${expr}, '${segment}')`;
+        }
+    });
+    const members = field.isArray ? `arr(at(${expr}, '${leaf}'))` : `[at(${expr}, '${leaf}')]`;
+    const literal = JSON.stringify(fixedValue);
+    const anchor = `${(profileUrl || '').replace(/'/g, "\\'")}#${baseResourceType || 'Resource'}.${rel}`;
+    const body = `${indent}for (const _fvValue of ${members}) {
+${indent}  if (_fvValue !== undefined && _fvValue !== null && _fvValue !== ${literal}) {
+${indent}    errors.push("Value is '" + _fvValue + "' but is fixed to '${String(fixedValue).replace(/"/g, '\\"')}' in the profile ${anchor}");
+${indent}  }
+${indent}}`;
+    const closes = open.map((_l, i) => '  '.repeat(open.length - i + 1) + '}').join('\n');
+    result.push(`
+  // Fixed value constraint for ${rel}
+  {
+${[...open, body, closes].filter(Boolean).join('\n')}
+  }`);
+}
+export function buildFixedValueValidations(fields, arrayFieldPaths, profileUrl, baseResourceType) {
     const result = [];
     fields
         .filter((field) => field.fixedValue !== undefined)
         .forEach((field) => {
         const relFull = field.name || '';
-        const rel = relFull.replace(/^[^.]+\./, '').replace(/\[x\]/g, '');
+        let rel = relFull.replace(/^[^.]+\./, '');
         if (!rel)
             return;
+        // A choice element is read through the property named for its type. Stripping
+        // `[x]` produced `resource.value`, which no resource carries and which the
+        // emitted interface — now naming the concrete property — rejects outright.
+        if (rel.endsWith('[x]')) {
+            const narrowedTo = narrowedChoiceType(field);
+            if (!narrowedTo)
+                return;
+            rel = choicePropertyName(rel.slice(0, -'[x]'.length), narrowedTo);
+        }
+        rel = rel.replace(/\[x\]/g, '');
         const pathParts = rel.split('.');
         if (pathParts.length > 1 && pathParts[0] !== 'meta') {
+            // A fixed value below the root was dropped entirely. cdex pins
+            // Task.owner.reference to '#practitionerrole', and HL7 reported the
+            // mismatch while we reported nothing.
+            emitNestedFixedValue(result, rel, field, arrayFieldPaths, profileUrl, baseResourceType);
             return;
         }
         const humanRel = rel || relFull;
@@ -227,6 +520,20 @@ export function buildProhibitedFieldValidations(fields, arrayFieldPaths, fieldPa
             // Skip if ANY segment has a slice qualifier — the constraint is
             // slice-scoped (e.g. name:Geburtsname.given) and must not be emitted
             // as a global prohibition.
+            //
+            // TODO(parity): this correctly avoids a global prohibition but emits nothing
+            // at all, so slice-scoped max=0 goes unchecked. A complex extension sets its
+            // own value[x] to max=0 — sub-extensions or a value, never both — and we miss
+            // it: on DTRStdQuestionnaire, HL7 reports "Extension.value[x]: max allowed =
+            // 0, but found 1" and "Extension.extension: minimum required = 2, but only
+            // found 0" for item.extension:contextExpression while we report neither.
+            //
+            // Fixing it needs a slice-scoped emission, not a relaxed guard: iterate the
+            // extensions matching the slice's url and assert the absence of any value*
+            // property. It cannot name one property, because a forbidden choice narrows
+            // to no type — which is why the choice resolution elsewhere in this file
+            // skips it too. Removing this guard instead would reintroduce the regression
+            // where AuditEvent.agent:user.requestor was demanded of every agent.
             const segments = field.elementId.split('.');
             if (segments.some(seg => seg.includes(':')))
                 return false;
@@ -260,7 +567,7 @@ export function buildProhibitedFieldValidations(fields, arrayFieldPaths, fieldPa
         if (pathParts.length === 1) {
             result.push(`
   // Prohibited field: ${resourceType}.${rel} (max=0)
-  if (_bRes.${rel} !== undefined) {
+  if (at(resource, '${rel}') !== undefined) {
     errors.push("${resourceType}.${rel}: max allowed = 0, but found 1");
   }`);
         }
@@ -277,7 +584,7 @@ export function buildProhibitedFieldValidations(fields, arrayFieldPaths, fieldPa
                 : `'${leafField}'`;
             result.push(`
   // Prohibited field: ${fullPath} (max=0)
-  for (const _el of arr(_bRes.${arrayParent})) {
+  for (const _el of arr(at(resource, '${arrayParent}'))) {
     if (at(_el, ${atPath}) !== undefined) {
       errors.push("${fullPath}: max allowed = 0, but found 1");
     }
@@ -315,8 +622,11 @@ export function buildPrimitiveFormatValidations(fields) {
                 const propName = `${rel}${suffix}`;
                 result.push(`
   // ${fhirType} format validation for ${propName} (choice type)
-  if (typeof _bRes.${propName} === 'string' && !${info.regex}.test(_bRes.${propName})) {
-    errors.push("Not a valid ${info.label} format: '" + _bRes.${propName} + "'");
+  {
+    const _fmtValue = at(resource, '${propName}');
+    if (typeof _fmtValue === 'string' && !${info.regex}.test(_fmtValue)) {
+      errors.push("Not a valid ${info.label} format: '" + _fmtValue + "'");
+    }
   }`);
             }
         }
@@ -327,8 +637,11 @@ export function buildPrimitiveFormatValidations(fields) {
             const { regex, label } = PRIMITIVE_FORMAT_REGEX[fhirType];
             result.push(`
   // ${fhirType} format validation for ${rel}
-  if (typeof _bRes.${rel} === 'string' && !${regex}.test(_bRes.${rel})) {
-    errors.push("Not a valid ${label} format: '" + _bRes.${rel} + "'");
+  {
+    const _fmtValue = at(resource, '${rel}');
+    if (typeof _fmtValue === 'string' && !${regex}.test(_fmtValue)) {
+      errors.push("Not a valid ${label} format: '" + _fmtValue + "'");
+    }
   }`);
         }
     });
@@ -341,6 +654,16 @@ const FHIR_PRIMITIVE_TYPES = new Set([
     'time', 'instant', 'code', 'id', 'oid', 'markdown', 'base64Binary',
     'uuid', 'positiveInt', 'unsignedInt', 'integer64', 'xhtml',
 ]);
+/**
+ * FHIR primitives that serialize as a JSON number.
+ *
+ * integer64 is deliberately absent: R5 serializes it as a *string* to survive
+ * JavaScript's 53-bit safe integer range, so requiring a number would reject
+ * conformant data.
+ */
+const NUMERIC_PRIMITIVES = new Set([
+    'decimal', 'integer', 'positiveInt', 'unsignedInt',
+]);
 /** Check whether a FHIR type serializes as a JSON primitive (string/number/bool). */
 function isFhirPrimitive(fieldType) {
     if (FHIR_PRIMITIVE_TYPES.has(fieldType))
@@ -366,8 +689,72 @@ const CONTAINER_TYPES = new Set([
  *
  * Only top-level (depth-1) non-sliced fields are checked.
  */
-export function buildStructuralTypeValidations(fields, _arrayFieldPaths) {
+/**
+ * A numeric or boolean primitive below a repeating element must still hold the right
+ * JSON kind.
+ *
+ * The flat pass deliberately skips any path with an array ancestor, because a path
+ * walk cannot descend one — so `ingredient.strength.numerator.value` went unchecked
+ * and HL7 reported "The value 'Example value' is not a valid decimal" alone. This
+ * emits the loop that pass declined to guess at.
+ *
+ * Both of HL7's headings are pushed: the value wording classifies as `unclassified`
+ * and the parse wording as `constraint`, so emitting only the first leaves
+ * `constraint` looking like an HL7-only finding.
+ */
+function buildArrayNestedPrimitiveKindValidations(fields, arrayFieldPaths, result) {
+    const isArrayPath = (p) => arrayFieldPaths.has(p) || arrayFieldPaths.has(p.split(':')[0]);
+    const seen = new Set();
+    for (const field of fields) {
+        if (field.sliceName || field.isArray)
+            continue;
+        const rel = (field.name || '').replace(/^[^.]+\./, '');
+        if (!rel || !rel.includes('.') || rel.includes('[x]') || seen.has(rel))
+            continue;
+        const fieldType = field.type || field.baseTypeCode;
+        const jsonKind = NUMERIC_PRIMITIVES.has(fieldType || '') ? 'number'
+            : fieldType === 'boolean' ? 'boolean'
+                : undefined;
+        if (!jsonKind)
+            continue;
+        const segments = rel.split('.');
+        const parents = segments.slice(0, -1);
+        const leaf = segments[segments.length - 1];
+        // The flat pass already covers a path with no array on the way down.
+        if (!parents.some((_p, i) => isArrayPath(parents.slice(0, i + 1).join('.'))))
+            continue;
+        seen.add(rel);
+        let expr = 'resource';
+        const open = [];
+        let indent = '    ';
+        parents.forEach((segment, i) => {
+            if (isArrayPath(parents.slice(0, i + 1).join('.'))) {
+                const loopVar = `_pkEl${i}`;
+                open.push(`${indent}for (const ${loopVar} of arr(at(${expr}, '${segment}'))) {`);
+                indent += '  ';
+                expr = loopVar;
+            }
+            else {
+                expr = `at(${expr}, '${segment}')`;
+            }
+        });
+        const closes = open.map((_l, i) => '  '.repeat(open.length - i + 1) + '}').join('\n');
+        const body = `${indent}const _pkValue = at(${expr}, '${leaf}');
+${indent}if (_pkValue !== undefined && _pkValue !== null && typeof _pkValue !== '${jsonKind}') {
+${indent}  errors.push("The value '" + String(_pkValue) + "' is not a valid ${fieldType}");
+${indent}  errors.push("Error parsing JSON: the primitive value must be a ${jsonKind}");
+${indent}}`;
+        result.push(`
+  // Structural type check: ${rel} must be a JSON ${jsonKind} (${fieldType})
+  {
+${[...open, body, closes].filter(Boolean).join('\n')}
+  }`);
+    }
+}
+export function buildStructuralTypeValidations(fields, arrayFieldPaths) {
     const result = [];
+    buildNestedObjectTypeValidations(fields, arrayFieldPaths, result);
+    buildArrayNestedPrimitiveKindValidations(fields, arrayFieldPaths, result);
     for (const field of fields) {
         // Skip sliced fields — handled by slice validator
         if (field.sliceName)
@@ -380,27 +767,86 @@ export function buildStructuralTypeValidations(fields, _arrayFieldPaths) {
         if (fullPath.includes('[x]'))
             continue;
         const rel = fullPath.replace(/^[^.]+\./, '');
-        if (!rel || rel.includes('.'))
-            continue; // only top-level fields
+        if (!rel)
+            continue;
+        // A nested primitive is still worth checking, and only the primitive kind check
+        // below handles one: HL7 reports "The value 'Example value' is not a valid
+        // decimal" on Medication.amount.numerator.value, three levels down, where we
+        // reported nothing. The array and object checks stay top-level only, since both
+        // would need iteration to descend correctly.
+        const isNested = rel.includes('.');
+        if (isNested) {
+            // Any array on the way down needs a loop, not a path walk. Skipped rather than
+            // guessed at, so a repeating ancestor never yields a check against the array
+            // object itself.
+            // arrayFieldPaths is keyed on the *relative* path. Building the key from the
+            // full path never matched, so Bundle.entry.search.score was emitted as
+            // at(resource, 'entry', 'search', 'score') — a walk into an array, which
+            // yields undefined and checks nothing.
+            const segments = rel.split('.');
+            const hasArrayAncestor = segments.some((_seg, i) => arrayFieldPaths.has(segments.slice(0, i + 1).join('.')));
+            if (hasArrayAncestor)
+                continue;
+            if (!NUMERIC_PRIMITIVES.has(field.type || '') && field.type !== 'boolean')
+                continue;
+        }
         const fieldType = field.type || field.baseTypeCode;
         if (!fieldType)
             continue;
         // ── Array structural check ─────────────────────────────────────────
-        if (field.isArray) {
+        if (field.isArray && !isNested) {
             result.push(`
   // Structural type check: ${rel} must be a JSON Array
-  if (_bRes.${rel} !== undefined && _bRes.${rel} !== null && !Array.isArray(_bRes.${rel})) {
-    errors.push("The property ${rel} must be a JSON Array, not an Object (at " + (_bRes.resourceType || "Resource") + ")");
+  {
+    const _stValue = at(resource, '${rel}');
+    if (_stValue !== undefined && _stValue !== null && !Array.isArray(_stValue)) {
+      const _stType = at(resource, 'resourceType');
+      errors.push("The property ${rel} must be a JSON Array, not an Object (at " + (typeof _stType === 'string' ? _stType : "Resource") + ")");
+    }
+  }`);
+        }
+        // ── Primitive JSON kind check ──────────────────────────────────────
+        // A numeric or boolean FHIR primitive must not arrive as a string. We checked
+        // that complex types are objects but never that a decimal holds a number, so
+        // HL7 reported "The value 'Example value' is not a valid decimal" and "the
+        // primitive value must be a number" where we said nothing.
+        //
+        // Both headings, as HL7 reports them: the value wording classifies as
+        // `unclassified` and the parse wording as `constraint`, so emitting only the
+        // first left `constraint` attributed to HL7 alone for a defect we had detected.
+        //
+        // Only the kinds JSON distinguishes are checked. Date, code and the rest all
+        // serialize as strings, and their formats already have dedicated checks
+        // elsewhere; asserting `typeof === 'string'` on them would add nothing.
+        const jsonKind = NUMERIC_PRIMITIVES.has(fieldType) ? 'number'
+            : fieldType === 'boolean' ? 'boolean'
+                : undefined;
+        if (jsonKind && !field.isArray) {
+            // Segments, not a dotted key: at() walks its varargs, so at(resource, 'a.b')
+            // would look for a property literally named "a.b" and always find nothing.
+            const accessorArgs = rel.split('.').map(seg => `'${seg}'`).join(', ');
+            result.push(`
+  // Structural type check: ${rel} must be a JSON ${jsonKind} (${fieldType})
+  {
+    const _stValue = at(resource, ${accessorArgs});
+    if (_stValue !== undefined && _stValue !== null && typeof _stValue !== '${jsonKind}') {
+      errors.push("The value '" + String(_stValue) + "' is not a valid ${fieldType}");
+      errors.push("Error parsing JSON: the primitive value must be a ${jsonKind}");
+    }
   }`);
         }
         // ── Complex type as Object check ───────────────────────────────────
-        if (!isFhirPrimitive(fieldType) && !CONTAINER_TYPES.has(fieldType)) {
+        if (!isNested && !isFhirPrimitive(fieldType) && !CONTAINER_TYPES.has(fieldType)) {
             // Complex types must be objects when present — not primitive strings/numbers
             if (!field.isArray) {
                 result.push(`
   // Structural type check: ${rel} must be an Object, not a Primitive
-  if (_bRes.${rel} !== undefined && _bRes.${rel} !== null && typeof _bRes.${rel} !== 'object') {
-    errors.push("The property ${rel} must be an Object, not a Primitive property (at " + (_bRes.resourceType || "Resource") + ".${rel})");
+  {
+    const _stValue = at(resource, '${rel}');
+    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})");
+    }
   }`);
             }
         }