babelfhir-ts 1.5.20 → 1.5.21

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

@@ -2,6 +2,20 @@
  * 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 { buildSubExtensionScope, renderScopeHops } from './subExtensionScope.js';
+/**
+ * Read pre-resolved Extension SD metadata for a canonical.
+ *
+ * The map is keyed by the version-stripped canonical because a slice names its
+ * extension in two spellings — `type.profile` with a `|x.y.z` suffix, the pinned
+ * `url` child without one — and either may reach this lookup. Reading with the
+ * raw url missed every versioned entry, and a miss is indistinguishable from an
+ * unreadable SD, so the emitter silently skipped the slice.
+ */
+export function lookupExtensionMetadata(metadata, extensionUrl) {
+    return metadata?.get(stripVersionFromCanonicalUrl(extensionUrl));
+}
 export function generateValueSetValidation(slice, baseName, relPath, errorPath, sliceLabel, varName, min, minText, getValueSetForBinding, valueSetImports, fields, out) {
     const vsInfo = getValueSetForBinding(slice.binding.uri);
     const vsInfoFull = vsInfo && !('systemOnly' in vsInfo && vsInfo.systemOnly) ? vsInfo : undefined;
@@ -216,17 +230,12 @@ export function generateExistsExtensionValidation(slice, relPath, errorPath, sli
         const remainingAccessor = remaining.includes('.') ? remaining.split('.').join('?.') : remaining;
         out.push(`
   // Required slice validation for ${relPath}:${sliceLabel} (exists extension discriminator, nested in array)
-  if (${safeAccessor(arrayParent)} && Array.isArray(${safeAccessor(arrayParent)})) {
-    for (const _el of ${safeAccessor(arrayParent)}) {
-      const _arr = elements(at(_el, ${remainingAccessor.split('?.').map(s => `'${s}'`).join(', ')}));
-      if (Array.isArray(_arr)) {
-        const ${varName}Matched = _arr.filter((item) =>
-          elements(at(item, 'extension')).some((ext) => ext.url === "${extensionUrl}")
-        );
-        if (${varName}Matched.length < ${min}) {
-          errors.push("No elements matched required slice: '${errorPath}:${sliceLabel}'");
-        }
-      }
+  for (const _el of arr(${safeAccessor(arrayParent)})) {
+    const ${varName}Matched = elements(at(_el, ${remainingAccessor.split('?.').map(s => `'${s}'`).join(', ')})).filter((item) =>
+      elements(at(item, 'extension')).some((ext) => ext.url === "${extensionUrl}")
+    );
+    if (${varName}Matched.length < ${min}) {
+      errors.push("No elements matched required slice: '${errorPath}:${sliceLabel}'");
     }
   }`);
         return;
@@ -278,12 +287,17 @@ export function detectExtensionUrlSlice(slice, relPath, fields) {
 }
 export function generateExtensionUrlSliceValidation(slice, relPath, errorPath, sliceLabel, varName, min, extensionUrl, fieldPathMap, arrayFieldPaths, out, ctx) {
     const baseFieldIsArray = isArrayPath(relPath, fieldPathMap, arrayFieldPaths);
-    const extMeta = ctx?.extensionMetadata?.get(extensionUrl);
+    const extMeta = lookupExtensionMetadata(ctx?.extensionMetadata, extensionUrl);
     // Narrow extension metadata value types with profile-level constraints.
     // The profile differential may restrict value[x] types more strictly than
     // the extension SD (e.g., extension allows [boolean, url] but profile allows only [url]).
+    //
+    // An empty type list is not a list to narrow: it means the extension is complex and
+    // forbids a value outright. The profile still carries the inherited value[x] element
+    // with its full base type list, so narrowing would read that as "any of ~50 types
+    // allowed" and cancel the prohibition.
     let effectiveMeta = extMeta;
-    if (extMeta && ctx?.fields && slice.elementId) {
+    if (extMeta && extMeta.valueTypes.length > 0 && ctx?.fields && slice.elementId) {
         const sliceElemId = slice.elementId.replace(/^[^.]+\./, '');
         const valueChild = ctx.fields.find(f => {
             if (!f.elementId || !f.typeOptions?.length)
@@ -296,22 +310,55 @@ export function generateExtensionUrlSliceValidation(slice, relPath, errorPath, s
             effectiveMeta = { ...extMeta, valueTypes: profileTypes };
         }
     }
+    // An optional slice asserts no count, but a present instance must still conform.
+    // Omitting the assertion rather than emitting `length < 0` keeps a branch that can
+    // never fire out of the generated output.
+    const countAssertion = min > 0
+        ? `
+    if (${varName}Matches.length < ${min}) {
+      errors.push("Slice '${errorPath}:${sliceLabel}': a matching slice is required, but not found");
+    }`
+        : '';
+    const headline = min > 0 ? 'Required' : 'Optional';
+    // With no count to assert and no resolved metadata there is nothing to check, and
+    // the block would filter a list and discard it. That happens whenever the
+    // extension SD could not be read, so emit only when the slice earns it.
+    if (min === 0 && !generateExtensionValueChecks('_probe', extensionUrl, effectiveMeta, ctx, '')) {
+        return;
+    }
+    // A sub-extension of another extension slice needs the parent walked and filtered
+    // first; the generic paths below address it from the resource root and cannot.
+    const subScope = ctx?.fields
+        ? buildSubExtensionScope(slice, ctx.fields)
+        : null;
+    if (subScope) {
+        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 body = renderScopeHops(subScope, (container, indent) => {
+            const matches = `${varName}Matches`;
+            let inner = `\n${indent}const ${matches} = elements(at(${container}, '${leafProp}')).filter((item) => item.url === "${extensionUrl}");`;
+            if (min > 0) {
+                inner += `\n${indent}if (${matches}.length < ${min}) {`;
+                inner += `\n${indent}  errors.push("Slice '${scopedErrorPath}': a matching slice is required, but not found");`;
+                inner += `\n${indent}}`;
+            }
+            inner += generateExtensionValueChecks(matches, extensionUrl, effectiveMeta, ctx, indent);
+            return inner;
+        });
+        out.push(`
+  // ${headline} extension slice validation for ${scopedErrorPath} (sub-extension, scoped to its parent slice)${body}`);
+        return;
+    }
     const nested = findArrayAncestor(relPath, fieldPathMap, arrayFieldPaths);
     if (nested) {
         const { arrayParent, remaining } = nested;
         const remainingAccessor = remaining.includes('.') ? remaining.split('.').join('?.') : remaining;
         out.push(`
-  // Required extension slice validation for ${relPath}:${sliceLabel} (url discriminator, nested in array)
-  if (${safeAccessor(arrayParent)} && Array.isArray(${safeAccessor(arrayParent)})) {
-    for (const _el of ${safeAccessor(arrayParent)}) {
-      const _extArr = elements(at(_el, ${remainingAccessor.split('?.').map(s => `'${s}'`).join(', ')}));
-      if (Array.isArray(_extArr)) {
-        const ${varName}Matches = _extArr.filter((item) => item.url === "${extensionUrl}");
-        if (${varName}Matches.length < ${min}) {
-          errors.push("Slice '${errorPath}:${sliceLabel}': a matching slice is required, but not found");
-        }${generateExtensionValueChecks(varName + 'Matches', extensionUrl, effectiveMeta, ctx, '        ')}
-      }
-    }
+  // ${headline} extension slice validation for ${relPath}:${sliceLabel} (url discriminator, nested in array)
+  for (const _el of arr(${safeAccessor(arrayParent)})) {
+    const ${varName}Matches = elements(at(_el, ${remainingAccessor.split('?.').map(s => `'${s}'`).join(', ')})).filter((item) => item.url === "${extensionUrl}");${countAssertion}${generateExtensionValueChecks(varName + 'Matches', extensionUrl, effectiveMeta, ctx, '    ')}
   }`);
         return;
     }
@@ -319,41 +366,159 @@ export function generateExtensionUrlSliceValidation(slice, relPath, errorPath, s
         const pathParts = relPath.split('.');
         const parentPath = pathParts.length > 1 ? pathParts.slice(0, -1).join('.') : null;
         const parentGuard = parentPath ? `${safeAccessor(parentPath)} && ` : '';
-        const elseGuard = parentPath ? `else if (${safeAccessor(parentPath)})` : 'else';
+        // The absent branch asserts the slice is missing. For min=0 that is simply false,
+        // and on an empty resource the element is never an array, so it fired every time:
+        // this is what cost empty parity 613/613 -> 599/613 across mcode, ndh, pas and
+        // physical-activity. Two earlier attempts patched only the nested path above and
+        // never reached this one.
+        const absentBranch = min > 0
+            ? ` ${parentPath ? `else if (${safeAccessor(parentPath)})` : 'else'} {
+    errors.push("Slice '${errorPath}:${sliceLabel}': a matching slice is required, but not found");
+  }`
+            : '';
+        const arrayCountAssertion = min > 0
+            ? `
+    if (${varName}Elements.length < ${min}) {
+      errors.push("Slice '${errorPath}:${sliceLabel}': a matching slice is required, but not found");
+    }`
+            : '';
         out.push(`
-  // Required extension slice validation for ${relPath}:${sliceLabel} (url discriminator)
+  // ${headline} extension slice validation for ${relPath}:${sliceLabel} (url discriminator)
   if (${parentGuard}Array.isArray(${safeAccessor(relPath)})) {
     const ${varName}Elements = ${safeList(relPath)}.filter((item) =>
       item.url === "${extensionUrl}"
-    );
-    if (${varName}Elements.length < ${min}) {
-      errors.push("Slice '${errorPath}:${sliceLabel}': a matching slice is required, but not found");
-    }${generateExtensionValueChecks(varName + 'Elements', extensionUrl, effectiveMeta, ctx, '    ')}
-  } ${elseGuard} {
-    errors.push("Slice '${errorPath}:${sliceLabel}': a matching slice is required, but not found");
-  }`);
+    );${arrayCountAssertion}${generateExtensionValueChecks(varName + 'Elements', extensionUrl, effectiveMeta, ctx, '    ')}
+  }${absentBranch}`);
     }
-    else {
+    else if (min > 0) {
         out.push(`
   // Required extension slice validation for ${relPath}:${sliceLabel} (url discriminator)
   if (!${safeAccessor(relPath)} || (${safeAccessor(relPath)} as { url?: string }).url !== "${extensionUrl}") {
     errors.push("Slice '${errorPath}:${sliceLabel}': a matching slice is required, but not found");
   }`);
     }
+    // A non-array optional slice has nothing to assert: its only check was that the
+    // slice is present, which min=0 does not require.
 }
 // ── Extension value type + binding validation helper ─────────────────────
 /** Map FHIR type code → JSON property name suffix (e.g., 'code' → 'Code'). */
 function valuePropertySuffix(typeCode) {
     return typeCode.charAt(0).toUpperCase() + typeCode.slice(1);
 }
+/** A ValueSet resolved to an emitted validator function, or nothing to check against. */
+function resolveBindingValueSet(binding, ctx) {
+    if (!binding || !ctx)
+        return undefined;
+    if (binding.strength !== 'required' && binding.strength !== 'extensible')
+        return undefined;
+    const vsInfo = ctx.getValueSetForBinding(binding.uri);
+    // A system-only ValueSet cannot decide membership of a code, only of its system.
+    if (!vsInfo || ('systemOnly' in vsInfo && vsInfo.systemOnly))
+        return undefined;
+    const full = vsInfo;
+    ctx.valueSetImports.set(full.sanitizedName, `./valuesets/ValueSet-${full.sanitizedName}.js`);
+    return full;
+}
+/**
+ * Check a sub-extension's value against its bound ValueSet.
+ *
+ * `elemVar` is `unknown`, so the value is reached through `at()` and only the shape
+ * actually read is asserted. Codings are the case KBV needs — the Payor extension
+ * binds `Extension.extension:Kostentraegertyp.value[x]:valueCoding` required — and
+ * primitives and CodeableConcepts are handled alongside so one helper covers the
+ * shapes an extension value can take.
+ */
+function subExtensionBindingCheck(sub, vs, elemVar, indent) {
+    const lines = [];
+    const notFound = (valueExpr) => `errors.push("The value provided ('" + ${valueExpr} + "') was not found in the value set '${vs.displayName}' (${sub.binding.uri})");`;
+    if (sub.valueTypes.includes('Coding')) {
+        lines.push(`${indent}const _seCode = at(${elemVar}, 'valueCoding', 'code');`);
+        lines.push(`${indent}if (typeof _seCode === 'string' && !${vs.validatorFn}(_seCode)) {`);
+        lines.push(`${indent}  ${notFound('_seCode')}`);
+        lines.push(`${indent}}`);
+    }
+    else if (sub.valueTypes.includes('CodeableConcept')) {
+        lines.push(`${indent}const _seCodings = codings(at(${elemVar}, 'valueCodeableConcept'));`);
+        lines.push(`${indent}if (_seCodings.length > 0 && !_seCodings.some((c) => !!c.code && ${vs.validatorFn}(c.code))) {`);
+        lines.push(`${indent}  errors.push("None of the codings in the extension value are from the value set '${vs.displayName}' (${sub.binding.uri})");`);
+        lines.push(`${indent}}`);
+    }
+    else {
+        // Primitive: whichever value* property is present carries the code.
+        lines.push(`${indent}const _seEntry = Object.entries(node(${elemVar})).find(([k]) => k.startsWith("value"));`);
+        lines.push(`${indent}if (_seEntry && typeof _seEntry[1] === 'string' && !${vs.validatorFn}(_seEntry[1])) {`);
+        lines.push(`${indent}  ${notFound('_seEntry[1]')}`);
+        lines.push(`${indent}}`);
+    }
+    return lines.join('\n');
+}
+/**
+ * Checks on the sub-extensions of a matched complex extension.
+ *
+ * `_ext` is the matched member; its own `extension` array holds the sub-extensions.
+ * Emits the cardinality on `Extension.extension`, the presence of each required
+ * slice, and the bound ValueSet of each slice that declares one — all in HL7's
+ * wording so parity attributes them to the same fields.
+ */
+function generateSubExtensionChecks(extMeta, ctx, indent) {
+    const subs = extMeta.subExtensions ?? [];
+    const min = extMeta.subExtensionMin ?? 0;
+    const lines = [];
+    if (min > 0) {
+        lines.push(`${indent}const _seAll = elements(at(_ext, 'extension'));`);
+        lines.push(`${indent}if (_seAll.length < ${min}) {`);
+        lines.push(`${indent}  errors.push("Extension.extension: minimum required = ${min}, but only found " + _seAll.length);`);
+        lines.push(`${indent}}`);
+    }
+    for (const sub of subs) {
+        const needsPresence = sub.min > 0;
+        const vs = resolveBindingValueSet(sub.binding, ctx);
+        if (!needsPresence && !vs)
+            continue;
+        const varName = `_se_${sub.sliceName.replace(/[^a-zA-Z0-9_]/g, '_')}`;
+        lines.push(`${indent}const ${varName} = elements(at(_ext, 'extension')).filter((e) => e.url === "${sub.url}");`);
+        if (needsPresence) {
+            lines.push(`${indent}if (${varName}.length < ${sub.min}) {`);
+            lines.push(`${indent}  errors.push("Slice 'Extension.extension:${sub.sliceName}': a matching slice is required, but not found");`);
+            lines.push(`${indent}}`);
+        }
+        if (vs) {
+            lines.push(`${indent}for (const _seElem of ${varName}) {`);
+            lines.push(subExtensionBindingCheck(sub, vs, '_seElem', indent + '  '));
+            lines.push(`${indent}}`);
+        }
+    }
+    return lines.length ? '\n' + lines.join('\n') : '';
+}
 /**
  * Generate inline JS code that validates extension value type and binding
  * for each matched extension in the given array variable.
  * Returns an empty string when no metadata is available.
  */
 function generateExtensionValueChecks(matchedArrayVar, extensionUrl, extMeta, ctx, indent) {
-    if (!extMeta || extMeta.valueTypes.length === 0)
+    // No entry means the extension SD could not be read, so nothing can be concluded.
+    if (!extMeta)
         return '';
+    // An entry with no permitted types means the opposite of unknown: the extension
+    // is complex, pins value[x] to max=0, and carries sub-extensions instead. A value
+    // of any type is forbidden, and since no single property can be named — every
+    // `value*` variant is disallowed — the check is on the presence of any of them.
+    if (extMeta.valueTypes.length === 0) {
+        const forbidUrl = ctx?.profileUrl || extensionUrl;
+        // HL7 reports one defect under two headings — the cardinality breach and the
+        // empty allowed-type list — and parity classifies them into different fields
+        // ('value' and 'constraint'), so emitting only the first left `constraint`
+        // showing as HL7-only on a finding we had already detected.
+        return `
+${indent}// Complex extension: value[x] is max=0, so no value* property is allowed
+${indent}for (const _ext of ${matchedArrayVar}) {
+${indent}  const _forbidden = Object.keys(node(_ext)).find((k) => k.startsWith("value"));
+${indent}  if (_forbidden) {
+${indent}    errors.push("Extension.value[x]: max allowed = 0, but found 1 (${forbidUrl})");
+${indent}    errors.push("The Extension '${extensionUrl}' definition allows for the types [] but found type " + _forbidden.slice(5));
+${indent}  }${generateSubExtensionChecks(extMeta, ctx, indent + '  ')}
+${indent}}`;
+    }
     const lines = [];
     const allowedProps = extMeta.valueTypes.map(t => `"value${valuePropertySuffix(t)}"`);
     const allowedSet = `[${allowedProps.join(', ')}]`;

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

@@ -31,17 +31,37 @@ export function generateSliceValidations(ctx) {
     slicesByBase.forEach((slices, baseName) => {
         slices.forEach(slice => {
             const min = typeof slice.min === "number" ? slice.min : (slice.isOptional ? 0 : 1);
+            // An optional extension slice is still validated when an instance is present.
+            // Only this shape is admitted below at min=0, mirroring the isExtensionUrlOnly
+            // test inside the body, so every other slice kind keeps its existing gate and
+            // no other emitter is reached with a count it cannot assert.
+            const isOptionalExtensionUrlSlice = min === 0 && isUrlDiscriminatedExtensionSlice(slice, baseName, fields);
             // An optional slice still needs its profiled resource validated. HL7 checks a
             // present entry whether or not the slice itself is required, so skipping the
             // whole slice on min=0 lost every finding inside it — DTR's qpackage output
             // Parameters pins parameter:packagebundle.resource to a Bundle profile with
             // min=0, and none of that Bundle's requirements were being checked.
             if (min === 0) {
+                const emittedBefore = sliceValidations.length;
                 generateOptionalProfiledSliceDelegation(slice, baseName, fields, sliceValidations, ctx);
-                return;
+                const alreadyDelegated = sliceValidations.length > emittedBefore;
+                // An extension slice carries on into the body, where the url discriminator
+                // branch emits its value[x] type and max=0 checks. Returning here left
+                // DTRStdQuestionnaire's item.extension:contextExpression unvalidated: it is
+                // min=0, so nothing about a present instance was ever checked.
+                //
+                // Only when the delegation emitted nothing, though. A top-level extension
+                // slice naming a profile gets a discriminator validation from the call above,
+                // and continuing into the body added a second check over the same slice — so
+                // one finding was reported twice and parity broke on both empty and random
+                // resources across us-core, mcode, ndh and pas. Falling through is for the
+                // slices the delegation declines, which is why the earlier attempt looked
+                // safe on the profiles I sampled: theirs are nested, and
+                // generateOptionalProfiledSliceDelegation returns early on a dotted path.
+                if (!isOptionalExtensionUrlSlice || alreadyDelegated)
+                    return;
             }
-            // Only validate required slices (min > 0)
-            if (min > 0) {
+            if (min > 0 || isOptionalExtensionUrlSlice) {
                 let relPath = baseName.replace(/^[^.]+\./, "");
                 // Skip value[x] slices that are nested within parent elements.
                 if (relPath.includes('.') && relPath.includes('value[x]')) {
@@ -126,7 +146,7 @@ export function generateSliceValidations(ctx) {
                         const fId = (f.elementId || f.name).replace(/^[^.]+\./, '');
                         return fId.substring(sliceElemId.length + 1).split('.')[0];
                     });
-                    generatePatternCodingValidation(slice, relPath, errorPath, sliceLabel, varName, min, fields, sliceValidations, requiredSubFields);
+                    generatePatternCodingValidation(slice, relPath, errorPath, sliceLabel, varName, min, fields, sliceValidations, requiredSubFields, ctx.baseResourceType, ctx.profileUrl);
                 }
                 else if (childFieldsWithFixedValue.length > 0) {
                     // For extension slices where the only fixedValue child is 'url', prefer the
@@ -261,16 +281,19 @@ function generateCrossSliceExclusivityValidations(slicesByBase, fields, fieldPat
             return;
         if (!isArrayPath(relPath, fieldPathMap, arrayFieldPaths))
             return;
+        // `elements()`, not the raw accessor: a multi-segment path compiles to
+        // `at(resource, …)`, which is `unknown`, and an enclosing `Array.isArray()`
+        // does not narrow a fresh call expression — so `for…of` on it fails to
+        // typecheck. The matchers read `_el.coding`, so the list must stay element-
+        // typed rather than going through `arr()`.
         let code = `\n  // Cross-slice exclusivity validation for ${relPath}`;
-        code += `\n  if (Array.isArray(${safeAccessor(relPath)})) {`;
-        code += `\n    for (const _el of ${safeAccessor(relPath)}) {`;
-        code += `\n      const _matchedSlices: string[] = [];`;
+        code += `\n  for (const _el of ${safeList(relPath)}) {`;
+        code += `\n    const _matchedSlices: string[] = [];`;
         for (const m of matchers) {
-            code += `\n      if (${m.matchExpr}) _matchedSlices.push("${m.label}");`;
+            code += `\n    if (${m.matchExpr}) _matchedSlices.push("${m.label}");`;
         }
-        code += `\n      if (_matchedSlices.length > 1) {`;
-        code += `\n        errors.push("Element matches more than one slice - " + _matchedSlices.join(", "));`;
-        code += `\n      }`;
+        code += `\n    if (_matchedSlices.length > 1) {`;
+        code += `\n      errors.push("Element matches more than one slice - " + _matchedSlices.join(", "));`;
         code += `\n    }`;
         code += `\n  }`;
         out.push(code);
@@ -411,7 +434,7 @@ function generatePatternCodeableConceptValidation(slice, relPath, errorPath, sli
   }`);
     }
 }
-function generatePatternCodingValidation(slice, relPath, errorPath, sliceLabel, varName, min, fields, out, requiredSubFields) {
+function generatePatternCodingValidation(slice, relPath, errorPath, sliceLabel, varName, min, fields, out, requiredSubFields, baseResourceType, profileUrl) {
     const pattern = slice.patternConstraint;
     const hasCode = 'code' in pattern;
     const hasSystem = 'system' in pattern;
@@ -431,6 +454,40 @@ function generatePatternCodingValidation(slice, relPath, errorPath, sliceLabel,
       }`)
             .join('')
         : '';
+    // Fixed values pinned on the slice's own children.
+    //
+    // This validator only ever checked that a required child was *present*, so a
+    // pinned value went unenforced: KBV_PR_ERP_Medication_Compounding fixes
+    // code.coding:verordnungskategorieCode.code to 'rezeptur' and we reported
+    // 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 fixedChildChecks = fields
+        .filter(f => {
+        if (typeof f.fixedValue !== 'string' && typeof f.fixedValue !== 'number' && f.fixedValue !== true)
+            return false;
+        const fId = (f.elementId || f.name).replace(/^[^.]+\./, '');
+        if (!fId.startsWith(sliceIdRel + '.'))
+            return false;
+        const rel = fId.substring(sliceIdRel.length + 1);
+        // Direct children only; a deeper pin needs per-level descent this loop
+        // does not do, and a sub-slice has its own validator.
+        return !rel.includes('.') && !rel.includes(':');
+    })
+        .map(f => {
+        const fId = (f.elementId || f.name).replace(/^[^.]+\./, '');
+        const child = fId.substring(sliceIdRel.length + 1);
+        const expected = String(f.fixedValue).replace(/'/g, "\\'");
+        // The fragment must end at the pinned child so parity attributes this to
+        // the same field HL7 does.
+        const profileRef = `${profileUrl ? `${profileUrl}#` : ''}${resType}.${sliceIdRel}.${child}`;
+        return `
+      if ((matched as Record<string, unknown>).${child} !== undefined && String((matched as Record<string, unknown>).${child}) !== '${expected}') {
+        errors.push("Value is '" + (matched as Record<string, unknown>).${child} + "' but is fixed to '${expected}' in the profile ${profileRef}");
+      }`;
+    })
+        .join('');
     const pathParts = relPath.split('.');
     let isNestedInArray = false;
     let arrayParentPath = '';
@@ -464,8 +521,9 @@ function generatePatternCodingValidation(slice, relPath, errorPath, sliceLabel,
             }
         }
     }
-    const subFieldBlock = subFieldChecks ? `
-    for (const matched of ${varName}Elements) {${subFieldChecks}
+    const matchedChecks = subFieldChecks + fixedChildChecks;
+    const subFieldBlock = matchedChecks ? `
+    for (const matched of ${varName}Elements) {${matchedChecks}
     }` : '';
     if (isNestedInArray && arrayParentPath) {
         const remainingPath = relPath.substring(arrayParentPath.length + 1);
@@ -562,3 +620,29 @@ function generateSelfFixedValueSliceValidation(slice, relPath, errorPath, sliceL
     errors.push("Slice '${errorPath}:${sliceLabel}': a matching slice is required, but not found");
   }`);
 }
+/**
+ * Whether a slice's only pinned direct child is `url` — the shape of an extension
+ * slice discriminated by its canonical.
+ *
+ * Deliberately identical to the isExtensionUrlOnly test inside the generator body,
+ * so that admitting a min=0 slice past the required-slice gate admits exactly the
+ * ones that then take the extension-url branch. Any other slice kind reaching a
+ * count-based emitter with min=0 would produce an assertion that cannot fire.
+ */
+function isUrlDiscriminatedExtensionSlice(slice, baseName, fields) {
+    // The body tests hasPatternCodeableConcept and hasPatternCoding *before* any
+    // extension branch, so a slice carrying a pattern reaches a pattern branch and
+    // would emit pattern checks under a minimum of zero. Two regressions came from
+    // admitting those.
+    if (slice.patternConstraint !== undefined)
+        return false;
+    if (slice.binding?.codes?.length)
+        return false;
+    // The body detector, not a hand-rolled copy. My first version required a pinned
+    // `url` child, which DTRStdQuestionnaire's item.extension:contextExpression does
+    // not have — it names its canonical through type.profile, so detectExtensionUrlSlice
+    // reads it from profileUrls. The predicate said no, the slice bailed, and nothing
+    // about a present instance was checked.
+    const relPath = baseName.replace(/^[^.]+\./, '');
+    return detectExtensionUrlSlice(slice, relPath, fields) !== undefined;
+}

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

@@ -0,0 +1,100 @@
+/**
+ * Addressing a sub-extension slice — an extension slice nested inside another.
+ *
+ * Split out of sliceExtensionValidation.ts to keep it under the 650 LOC gate, and
+ * because this is a self-contained concern: turning a slice's element id into the
+ * runtime walk that reaches the elements *containing* it.
+ */
+import { stripVersionFromCanonicalUrl } from '../../core/utils.js';
+/**
+ * The url an *instance* of this extension slice carries.
+ *
+ * `detectExtensionUrlSlice` answers a different question — which canonical names the
+ * slice — and prefers `type.profile`, which may be version-pinned (`…|4.0.0`). An
+ * instance never writes the version, so matching on that form finds nothing. The
+ * pinned `url` child is what the instance actually carries; fall back to the profile
+ * canonical with the version stripped.
+ */
+export function instanceUrlForSlice(slice, fields) {
+    const sliceElementId = (slice.elementId || slice.name).replace(/^[^.]+\./, '');
+    const sliceFullId = slice.sliceName && !sliceElementId.includes(':')
+        ? `${sliceElementId}:${slice.sliceName}`
+        : sliceElementId;
+    for (const f of fields) {
+        const childId = (f.elementId || f.name).replace(/^[^.]+\./, '');
+        if (childId === sliceFullId + '.url' && typeof f.fixedValue === 'string')
+            return f.fixedValue;
+    }
+    return slice.profileUrls?.length ? stripVersionFromCanonicalUrl(slice.profileUrls[0]) : undefined;
+}
+/**
+ * Build the walk down to the elements that *contain* a sub-extension slice.
+ *
+ * Only for a slice nested inside another extension slice
+ * (`item.extension:contextExpression.extension:label`). The generic path builds one
+ * `at(_el, 'extension', 'extension')` hop, which returns undefined the moment it
+ * meets the `extension` array — so the check read nothing and its `length < min`
+ * assertion fired on every parent element instead. It also ignored the parent slice
+ * entirely, applying contextExpression's requirements to every extension on the item.
+ *
+ * Returns null when the slice is not of that shape, leaving the existing paths alone.
+ */
+export function buildSubExtensionScope(slice, fields) {
+    const elemId = (slice.elementId || '').replace(/^[^.]+\./, '');
+    if (!elemId)
+        return null;
+    const segments = elemId.split('.');
+    // The slice itself is the last segment; everything before it is the container walk.
+    const containerSegments = segments.slice(0, -1);
+    const slicedAncestors = containerSegments.filter(s => {
+        const [prop, sliceName] = s.split(':');
+        return sliceName && (prop === 'extension' || prop === 'modifierExtension');
+    });
+    if (slicedAncestors.length === 0)
+        return null;
+    const hops = [];
+    for (let i = 0; i < containerSegments.length; i++) {
+        const [prop, sliceName] = containerSegments[i].split(':');
+        let url;
+        if (sliceName) {
+            const ancestorId = containerSegments.slice(0, i + 1).join('.');
+            const ancestor = fields.find(f => (f.elementId || '').replace(/^[^.]+\./, '') === ancestorId);
+            // Without a resolvable url the hop cannot be scoped, and an unscoped walk is
+            // what this function exists to avoid — bail rather than guess.
+            if (!ancestor)
+                return null;
+            url = instanceUrlForSlice(ancestor, fields);
+            if (!url)
+                return null;
+        }
+        hops.push({ prop, url });
+    }
+    return hops;
+}
+/**
+ * Render a scope walk as nested for-loops, innermost body supplied by the caller.
+ *
+ * Unfiltered hops go through `elementsAt`, which drops absent and null intermediates
+ * and flattens arrays. Reading a single element into a one-item list instead would
+ * carry `undefined` into the body, where a `length < min` assertion fires on it.
+ */
+export function renderScopeHops(hops, body) {
+    let code = '';
+    let indent = '  ';
+    let current = 'resource';
+    hops.forEach((hop, i) => {
+        const next = `_scope${i}`;
+        const list = hop.url
+            ? `elements(at(${current}, '${hop.prop}')).filter((e) => e.url === "${hop.url}")`
+            : `elementsAt(${current}, ['${hop.prop}'])`;
+        code += `\n${indent}for (const ${next} of ${list}) {`;
+        indent += '  ';
+        current = next;
+    });
+    code += body(current, indent);
+    for (let i = hops.length - 1; i >= 0; i--) {
+        indent = indent.slice(2);
+        code += `\n${indent}}`;
+    }
+    return code;
+}

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

@@ -174,7 +174,19 @@ export function buildForbiddenFieldConstraintEntries(fields) {
                 human: `${concretePath}: max allowed = 0, but found 1`,
                 severity: 'error',
             },
-            fieldPath: concreteParts[concreteParts.length - 1],
+            // The full path, not the last segment. The expression above is written
+            // relative to the resource root, and the emitter wraps an expression in
+            // `${fieldPath}.all(...)` unless the expression already navigates from
+            // fieldPath. With a bare last segment it never did, so a max=0 on
+            // Medication.amount.numerator.value became
+            //
+            //     value.all(amount.numerator.value.exists().not())
+            //
+            // and Medication has no `value` element: the collection is empty, FHIRPath
+            // all() on empty is true, and the constraint could never fire. Two of the
+            // three kbv-erp random-parity failures were this, with HL7 reporting the
+            // violation we had already written down and then scoped into oblivion.
+            fieldPath: concretePath,
             isChoiceType: false,
         });
     });