babelfhir-ts 1.5.19 → 1.5.21

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

@@ -4,7 +4,9 @@
  * (patternCodeableConcept, patternCoding, BackboneElement, binding, ValueSet).
  */
 import { addDiagnostic } from '../../core/sdDiagnostics.js';
-import { safeAccessor, safeList, sliceElseBranch, rewritePrimitiveExtensionPath, isArrayPath, collectWithinSliceMaxChildren, generateWithinSliceMaxChecks } from './sliceValidatorUtils.js';
+import { INLINE_RESOURCE_SLOTS } from './validatorFieldBuilders.js';
+import { safeAccessor, safeList, sliceElseBranch, rewritePrimitiveExtensionPath, isArrayPath, resolveNestedPatternChild } 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';
 /**
@@ -29,8 +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);
-            // Only validate required slices (min > 0)
-            if (min > 0) {
+            // 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);
+                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;
+            }
+            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]')) {
@@ -68,7 +99,10 @@ export function generateSliceValidations(ctx) {
                     ('system' in slice.patternConstraint || 'code' in slice.patternConstraint) &&
                     !('coding' in slice.patternConstraint);
                 const sliceElementId = (slice.elementId || slice.name).replace(/^[^.]+\./, '');
-                const childFieldsWithPattern = fields.filter(f => {
+                // A slice pinning a coded child discriminates on that pin, which takes
+                // precedence over the child's own (wider) binding.
+                const nestedPatternChild = resolveNestedPatternChild(slice);
+                const childFieldsWithPattern = nestedPatternChild ? [nestedPatternChild] : fields.filter(f => {
                     if (!f.elementId)
                         return false;
                     const hasPattern = !!f.patternConstraint;
@@ -112,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
@@ -164,6 +198,19 @@ export function generateSliceValidations(ctx) {
                             if (refResourceType) {
                                 generateReferenceProfileDiscriminatorValidation(slice, relPath, errorPath, sliceLabel, varName, min, refResourceType, sliceValidations, fields, ctx.baseResourceType);
                             }
+                            else if (slice.fixedValue !== undefined && !isChoiceTypeSlice) {
+                                generateSelfFixedValueSliceValidation(slice, relPath, errorPath, sliceLabel, varName, min, sliceValidations);
+                            }
+                            else if (slice.profileUrls?.length && ctx.datatypeProfilePins?.get(slice.profileUrls[0])) {
+                                // A {profile, $this} slice against a datatype profile: the profile's
+                                // own pinned element is what distinguishes its members.
+                                generateDatatypeProfileSliceValidation(relPath, errorPath, sliceLabel, varName, min, ctx.datatypeProfilePins.get(slice.profileUrls[0]), sliceValidations);
+                            }
+                            else if (INLINE_RESOURCE_SLOTS.has(relPath) && detectSelfTypeDiscriminator(slice)) {
+                                // An inline-resource slot sliced by {type, $this}: the member is the
+                                // resource, so its resourceType decides membership.
+                                generateSelfTypeSliceValidation(slice, relPath, errorPath, sliceLabel, varName, min, detectSelfTypeDiscriminator(slice), sliceValidations);
+                            }
                             else {
                                 sliceValidations.push(`
   // Slice validation for ${relPath}:${sliceLabel} skipped: no pattern/value discriminator found
@@ -234,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);
@@ -384,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;
@@ -404,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 = '';
@@ -437,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);
@@ -522,296 +607,42 @@ function generatePatternCodingValidation(slice, relPath, errorPath, sliceLabel,
  * generates code that delegates validation of that sub-resource to the profiled
  * validator, similar to how generateProfileDiscriminatorValidation handles Bundle entries.
  */
-function generateProfiledChildDelegation(slice, relPath, childFieldsWithFixedValue, out, ctx) {
-    if (!ctx.profileUrlToName || !ctx.validatorImports)
+function generateSelfFixedValueSliceValidation(slice, relPath, errorPath, sliceLabel, varName, min, out) {
+    const fixed = slice.fixedValue;
+    if (fixed === undefined)
         return;
-    const sliceElemId = (slice.elementId || slice.name).replace(/^[^.]+\./, '');
-    // Find child fields of this slice that have profile URLs (profiled sub-resources)
-    const profiledChildren = ctx.fields.filter(f => {
-        const fId = (f.elementId || f.name).replace(/^[^.]+\./, '');
-        if (!fId.startsWith(sliceElemId + '.'))
-            return false;
-        const relativePath = fId.substring(sliceElemId.length + 1);
-        if (relativePath.includes('.') || relativePath.includes(':'))
-            return false;
-        return f.profileUrls && f.profileUrls.length > 0;
-    });
-    if (profiledChildren.length === 0)
-        return;
-    // Get discriminator info to build the filter expression
-    const discriminatorChild = childFieldsWithFixedValue[0];
-    const childFieldId = (discriminatorChild.elementId || discriminatorChild.name).replace(/^[^.]+\./, '');
-    let discriminatorProp = '';
-    if (childFieldId.startsWith(sliceElemId + '.')) {
-        discriminatorProp = childFieldId.substring(sliceElemId.length + 1).split('.')[0];
-    }
-    if (!discriminatorProp)
-        return;
-    const fixedVal = typeof discriminatorChild.fixedValue === 'string'
-        ? `"${discriminatorChild.fixedValue}"`
-        : String(discriminatorChild.fixedValue);
-    const sliceLabel = slice.sliceName || 'slice';
-    for (const profiledChild of profiledChildren) {
-        const childRelPath = ((profiledChild.elementId || profiledChild.name).replace(/^[^.]+\./, '')).substring(sliceElemId.length + 1);
-        // Skip choice-type children (value[x]) — these are datatype values (e.g., Signature),
-        // not nested FHIR resources. Delegation only applies to concrete resource children.
-        if (childRelPath.includes('[x]'))
-            continue;
-        for (const pUrl of profiledChild.profileUrls) {
-            const delegateName = ctx.profileUrlToName.get(pUrl);
-            if (!delegateName || delegateName === ctx.profileName)
-                continue;
-            ctx.validatorImports.set(delegateName, `./${delegateName}.js`);
-            const varName = (slice.sliceName || 'slice').replace(/[^a-zA-Z0-9_]/g, '_');
-            // Derive expected resourceType for the profiled child. When the child type is
-            // 'Resource' (generic), try the profile URL last segment or delegate name suffix.
-            const childType = profiledChild.baseTypeCode || profiledChild.type;
-            let expectedResType;
-            if (childType && childType !== 'Resource' && /^[A-Z][a-zA-Z]+$/.test(childType)) {
-                expectedResType = childType;
-            }
-            else if (ctx.profileUrlToType) {
-                // Use the profileUrlToType map to get the expected resource type from the profile
-                expectedResType = ctx.profileUrlToType.get(pUrl);
-            }
-            if (!expectedResType) {
-                const seg = pUrl.split('/').pop() || '';
-                if (/^[A-Z][a-zA-Z]+$/.test(seg))
-                    expectedResType = seg;
-            }
-            // Build a resourceType guard to avoid false positives on wrong types
-            const rtGuard = expectedResType
-                ? ` && at(_p, '${childRelPath}', 'resourceType') === "${expectedResType}"`
-                : '';
-            // When resource type doesn't match, emit errors matching HL7 behavior:
-            // - Type mismatch error → field: resource
-            // - For Parameters: unknown resource type → field: unclassified
-            // - For Parameters: inv-1 (parameter must have value/resource/part) → field: constraint
-            const isParameters = ctx.baseResourceType === 'Parameters';
-            let rtMismatchCheck = '';
-            if (expectedResType) {
-                const mismatchErrors = [
-                    `errors.push("Specified profile type was '${expectedResType}' in profile '${pUrl}', but found type '" + (at(_p, '${childRelPath}', 'resourceType') || "Resource") + "'");`,
-                ];
-                if (isParameters) {
-                    mismatchErrors.push(`errors.push("Contained resource does not appear to be a FHIR resource (unknown name '" + at(_p, '${childRelPath}', 'resourceType') + "')");`, `errors.push("A parameter must have one and only one of (value, resource, part)");`);
-                }
-                rtMismatchCheck = `\n        if (at(_p, '${discriminatorProp}') === ${fixedVal} && at(_p, '${childRelPath}') && at(_p, '${childRelPath}', 'resourceType') !== "${expectedResType}") {\n          ${mismatchErrors.join('\n          ')}\n        }`;
-            }
-            // Detect if sliced path goes through an array ancestor (e.g., parameter.part where parameter is array)
-            const pathParts = relPath.split('.');
-            let arrayParentPath = '';
-            for (let i = 0; i < pathParts.length - 1; i++) {
-                const partialPath = pathParts.slice(0, i + 1).join('.');
-                const parentField = ctx.fields.find(f => {
-                    const fRelPath = f.name.replace(/^[^.]+\./, '');
-                    return fRelPath === partialPath;
-                });
-                if (parentField && parentField.isArray) {
-                    arrayParentPath = partialPath;
-                    break;
-                }
-            }
-            if (arrayParentPath) {
-                const remainingPath = relPath.substring(arrayParentPath.length + 1);
-                out.push(`
-  // Profiled sub-resource delegation for ${relPath}:${sliceLabel}.${childRelPath} → ${delegateName}
-  {
-    if (resource.${arrayParentPath} && Array.isArray(resource.${arrayParentPath})) {
-      for (const _parentItem of resource.${arrayParentPath}) {
-        const _pi = node(_parentItem);
-        const _nestedArr = _pi?.${remainingPath};
-        if (_nestedArr && Array.isArray(_nestedArr)) {
-          for (const _p of _nestedArr) {
-            if (at(_p, '${discriminatorProp}') === ${fixedVal} && at(_p, '${childRelPath}')${rtGuard}) {
-              const _sub = await validate${delegateName}(asResource(at(_p, '${childRelPath}')), options);
-              errors.push(..._sub.errors);
-              warnings.push(..._sub.warnings);
-            }${rtMismatchCheck ? rtMismatchCheck.replace(/\n {8}/g, '\n            ') : ''}
-          }
-        }
-      }
-    }
-  }`);
-            }
-            else {
-                out.push(`
-  // Profiled sub-resource delegation for ${relPath}:${sliceLabel}.${childRelPath} → ${delegateName}
-  {
-    const _${varName}Params = elements(${safeAccessor(relPath)});
-    for (const _p of _${varName}Params) {
-      if (at(_p, '${discriminatorProp}') === ${fixedVal} && at(_p, '${childRelPath}')${rtGuard}) {
-        const _sub = await validate${delegateName}(asResource(at(_p, '${childRelPath}')), options);
-        errors.push(..._sub.errors);
-        warnings.push(..._sub.warnings);
-      }${rtMismatchCheck}
-    }
-  }`);
-            }
-            break; // Only delegate to first resolved profile
-        }
-    }
-}
-// ── Reference profile discriminator support (Reference.type matching) ─────
-/**
- * Detect whether a slice on a Reference-typed field uses a `profile` discriminator
- * on `$this.resolve()`. Returns the target resource type if discoverable.
- * E.g., MessageHeader.focus:admit-notification with targetProfile → Encounter.
- */
-function detectReferenceProfileDiscriminator(slice, profileUrlToType) {
-    if (!slice.typeOptions?.length)
-        return undefined;
-    const refType = slice.typeOptions.find(t => t.code === 'Reference');
-    if (!refType?.targetProfileUrls?.length)
-        return undefined;
-    const targetUrl = refType.targetProfileUrls[0];
-    // 1. Authoritative: resolve from profileUrlToType map
-    if (profileUrlToType) {
-        const resolved = profileUrlToType.get(targetUrl);
-        if (resolved && /^[A-Z][a-zA-Z]+$/.test(resolved))
-            return resolved;
-    }
-    // 2. Heuristic: last URL segment if it looks like a resource type
-    const lastSeg = targetUrl.split('/').pop() || '';
-    if (/^[A-Z][a-zA-Z]+$/.test(lastSeg))
-        return lastSeg;
-    return undefined;
-}
-/**
- * Generate slice validation for Reference-typed slices discriminated by target profile.
- * Matches references by `Reference.type` field or reference string path prefix.
- */
-function generateReferenceProfileDiscriminatorValidation(slice, relPath, errorPath, sliceLabel, varName, min, targetResourceType, out, fields, baseResourceType) {
-    // Build within-slice child max constraint checks (e.g., max=0 forbidden fields)
-    const maxChildren = fields ? collectWithinSliceMaxChildren(slice, fields) : [];
-    const resType = baseResourceType || (slice.elementId || slice.name).split('.')[0];
-    const childMaxChecks = generateWithinSliceMaxChecks(maxChildren, `_${varName}Refs`, resType, relPath, sliceLabel);
+    // The sliced element is a primitive here ($this is the value), so a plain
+    // equality count over arr() is the whole check — no element shape to inspect.
+    const literal = JSON.stringify(fixed);
     out.push(`
-  // Required Reference-profile slice validation for ${relPath}:${sliceLabel} (target → ${targetResourceType})
-  if (Array.isArray(${safeAccessor(relPath)})) {
-    const _${varName}Refs = ${safeList(relPath)}.filter((e) =>
-      e?.type === '${targetResourceType}' ||
-      (typeof e?.reference === 'string' && (e.reference.startsWith('${targetResourceType}/') || new RegExp('/${targetResourceType}/').test(e.reference)))
-    );
-    if (_${varName}Refs.length < ${min}) {
-      errors.push("Slice '${errorPath}:${sliceLabel}': a matching slice is required, but not found");
-    }${childMaxChecks}
-  } else if (${safeAccessor(relPath)} && !Array.isArray(${safeAccessor(relPath)})) {
-    const _ref = ${safeAccessor(relPath)} as { type?: string; reference?: string } | undefined;
-    const _isMatch = _ref?.type === '${targetResourceType}' ||
-      (typeof _ref?.reference === 'string' && (_ref.reference.startsWith('${targetResourceType}/') || new RegExp('/${targetResourceType}/').test(_ref.reference)));
-    if (!_isMatch) {
-      errors.push("Slice '${errorPath}:${sliceLabel}': a matching slice is required, but not found");
-    }
-  } else {
+  // Required slice validation for ${relPath}:${sliceLabel} ($this fixed value)
+  if (arr(${safeAccessor(relPath)}).filter((item) => item === ${literal}).length < ${min}) {
     errors.push("Slice '${errorPath}:${sliceLabel}': a matching slice is required, but not found");
   }`);
 }
 /**
- * Detect whether a slice uses a `profile` discriminator on a `.resource` child.
- * Returns the expected resourceType and profile URLs if found, undefined otherwise.
+ * Whether a slice's only pinned direct child is `url` — the shape of an extension
+ * slice discriminated by its canonical.
  *
- * Heuristic: the child field `<sliceElementId>.resource` with `profileUrls`
- * indicates a profile-based entry slice.  The resource type is derived from
- * `profileUrlToType` (authoritative), the profile URL last segment, or the
- * child field type code.
+ * 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 detectProfileDiscriminator(slice, fields, profileUrlToType) {
-    const sliceElemId = (slice.elementId || slice.name).replace(/^[^.]+\./, '');
-    const resourceChild = fields.find(f => {
-        const fId = (f.elementId || f.name).replace(/^[^.]+\./, '');
-        return fId === `${sliceElemId}.resource`;
-    });
-    if (!resourceChild?.profileUrls?.length)
-        return undefined;
-    const profileUrls = resourceChild.profileUrls;
-    // 1. Authoritative: resolve resource type from profileUrlToType map
-    if (profileUrlToType) {
-        for (const pUrl of profileUrls) {
-            const resolvedType = profileUrlToType.get(pUrl);
-            if (resolvedType && /^[A-Z][a-zA-Z]+$/.test(resolvedType)) {
-                return { resourceType: resolvedType, profileUrls };
-            }
-        }
-    }
-    // 2. Try to extract from profile URL last segment (core profiles)
-    const profileUrl = profileUrls[0];
-    const lastSegment = profileUrl.split('/').pop() || '';
-    if (/^[A-Z][a-zA-Z]+$/.test(lastSegment)) {
-        return { resourceType: lastSegment, profileUrls };
-    }
-    // 3. Slice name if it looks like a resource type
-    const sliceName = slice.sliceName || '';
-    if (/^[A-Z][a-zA-Z]+$/.test(sliceName)) {
-        return { resourceType: sliceName, profileUrls };
-    }
-    // 4. Fallback: derive from the child's type code or typeOptions
-    const childType = resourceChild.baseTypeCode || resourceChild.type;
-    if (childType && /^[A-Z][a-zA-Z]+$/.test(childType)) {
-        return { resourceType: childType, profileUrls };
-    }
-    const typeOpt = resourceChild.typeOptions?.find(t => /^[A-Z][a-zA-Z]+$/.test(t.code));
-    if (typeOpt) {
-        return { resourceType: typeOpt.code, profileUrls };
-    }
-    return undefined;
-}
-/**
- * Generate slice validation for profile-discriminated entry slices.
- * Matches Bundle entries by `entry[i].resource.resourceType`, enforces min/max,
- * and delegates to the profiled validator when the profile URL is in profileUrlToName.
- */
-function generateProfileDiscriminatorValidation(slice, relPath, errorPath, sliceLabel, varName, min, match, out, ctx) {
-    const { resourceType, profileUrls } = match;
-    const max = typeof slice.max === 'number' && slice.max !== Infinity ? slice.max : undefined;
-    const parentPath = relPath.includes('.') ? relPath.split('.').slice(0, -1).join('.') : '';
-    const accessor = parentPath ? `at(resource, ${parentPath.split('.').map(s => `'${s}'`).join(', ')})` : `resource.${relPath}`;
-    // For top-level entry slices, access resource.entry directly
-    const arrayAccessor = relPath === 'entry' || !relPath.includes('.') ? `resource.${relPath}` : accessor;
-    // Resolve profiled validator for delegation
-    let delegateInterfaceName;
-    if (ctx.profileUrlToName && ctx.validatorImports) {
-        for (const pUrl of profileUrls) {
-            const name = ctx.profileUrlToName.get(pUrl);
-            if (name && name !== ctx.profileName) {
-                delegateInterfaceName = name;
-                ctx.validatorImports.set(name, `./${name}.js`);
-                break;
-            }
-        }
-    }
-    // When delegating, annotate the array so .resource is accessible without casts
-    const entriesType = '';
-    let code = `
-  // Required slice validation for ${relPath}:${sliceLabel} (profile discriminator → ${resourceType})
-  {
-    const _${varName}Entries${entriesType} = elements(${arrayAccessor}).filter(
-      (e) => at(e, 'resource', 'resourceType') === '${resourceType}'
-    );`;
-    if (min > 0) {
-        code += `
-    if (_${varName}Entries.length < ${min}) {
-      errors.push("Slice '${errorPath}:${sliceLabel}': a matching slice is required, but not found");
-    }`;
-    }
-    if (max !== undefined) {
-        code += `
-    if (_${varName}Entries.length > ${max}) {
-      errors.push("${errorPath}:${sliceLabel}: max allowed = ${max}, but found " + _${varName}Entries.length);
-    }`;
-    }
-    // Delegate to profiled validator for each matched entry
-    if (delegateInterfaceName) {
-        code += `
-    for (const _e of _${varName}Entries) {
-      if (at(_e, 'resource')) {
-        const _sub = await validate${delegateInterfaceName}(asResource(at(_e, 'resource')), options);
-        errors.push(..._sub.errors);
-        warnings.push(..._sub.warnings);
-      }
-    }`;
-    }
-    code += `
-  }`;
-    out.push(code);
+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;
 }