babelfhir-ts 1.5.19 → 1.5.21

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

@@ -0,0 +1,146 @@
+/**
+ * Closed slicing enforcement.
+ *
+ * `slicing.rules = 'closed'` means an instance element matching none of the declared
+ * slices is an error. Nothing enforced it: `slicingRules` was read in the interface
+ * emitter through an `as unknown as` cast and never written by any parser, so every
+ * slicing looked open. HL7 reports these as
+ *   "This element does not match any known slice defined in the profile <url>
+ *    and slicing is CLOSED: <path>"
+ * and they were the whole `entry` category of the remaining random-parity failures
+ * (davinci-dtr, kbv-erp — issue #138).
+ *
+ * Two discriminator shapes are enforced:
+ *   - `{value, url}` on an extension slot — the member's url must be declared
+ *   - `{type, $this}` on a choice element — the chosen type must be declared
+ *
+ * Deliberately limited to slicings introduced at an unsliced path. A slicing declared
+ * *inside* another slice (`Medication.extension:Kategorie.value[x]`) shares its
+ * unsliced name with its siblings, so the field model cannot tell the sets apart:
+ * merging them applies one slice's allowed types to every member and reports a
+ * conformant resource. Enforcing those needs slice-scoped traversal and is left off
+ * rather than approximated.
+ */
+import { stripVersionFromCanonicalUrl } from '../../core/utils.js';
+const CHOICE_SUFFIX = '[x]';
+/** The url an instance of this extension slice carries (pinned `url` child, else profile). */
+function instanceUrl(slice, fields) {
+    const sliceElemId = (slice.elementId || slice.name).replace(/^[^.]+\./, '');
+    const sliceFullId = slice.sliceName && !sliceElemId.includes(':')
+        ? `${sliceElemId}:${slice.sliceName}`
+        : sliceElemId;
+    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;
+}
+/**
+ * The property name a choice slice occupies.
+ *
+ * A choice slice is conventionally named after the property (`valueCoding`), so the
+ * slice name is used when it already starts with the base property; the declared
+ * type is the fallback (`value[x]` + type `Coding` → `valueCoding`).
+ */
+function choiceProperty(baseProp, slice) {
+    if (slice.sliceName?.startsWith(baseProp))
+        return slice.sliceName;
+    const code = slice.typeOptions?.[0]?.code ?? slice.baseTypeCode ?? slice.type;
+    if (!code)
+        return undefined;
+    return `${baseProp}${code.charAt(0).toUpperCase()}${code.slice(1)}`;
+}
+/** Classify a closed slicing, or undefined when it is not one this module enforces. */
+function classify(leaf) {
+    if (leaf === 'extension' || leaf === 'modifierExtension')
+        return 'extension-url';
+    if (leaf.endsWith(CHOICE_SUFFIX))
+        return 'choice-type';
+    return undefined;
+}
+/**
+ * Bind `_csElem` to every element at `segments`, flattening array hops.
+ *
+ * Always the flattening walk, never a plain `at()`: the field model's array flags do
+ * not always agree with the instance (Medication.ingredient is 0..* yet was read as a
+ * single element), and `elementsAt` is correct for both shapes.
+ */
+function walk(segments, body) {
+    const pathArgs = segments.map(s => `'${s}'`).join(', ');
+    return `\n  for (const _csElem of elementsAt(resource, [${pathArgs}])) {${body}\n  }`;
+}
+/**
+ * Emit closed-slicing checks for every element that introduces a closed slicing.
+ */
+export function generateClosedSlicingValidations(fields, profileUrl, baseResourceType) {
+    const out = [];
+    const seen = new Set();
+    for (const field of fields) {
+        if (field.slicingRules !== 'closed' || field.sliceName)
+            continue;
+        // Address the slicing by its element id so slice qualifiers stay visible.
+        const elemId = (field.elementId || field.name).replace(/^[^.]+\./, '');
+        if (!elemId || seen.has(elemId))
+            continue;
+        // A slicing nested inside another slice cannot be addressed from the root.
+        if (elemId.includes(':'))
+            continue;
+        const segments = elemId.split('.');
+        const leaf = segments[segments.length - 1];
+        const kind = classify(leaf);
+        if (!kind)
+            continue;
+        // A choice segment above the leaf is not a JSON property name, so the walk
+        // cannot reach past it.
+        if (segments.slice(0, -1).some(s => s.endsWith(CHOICE_SUFFIX)))
+            continue;
+        const slices = fields.filter(f => f.sliceName && f.name === field.name);
+        if (slices.length === 0)
+            continue;
+        const fhirPath = `${baseResourceType ?? 'Resource'}.${elemId}`;
+        const profileRef = profileUrl ?? (baseResourceType ?? '');
+        const message = `This element does not match any known slice defined in the profile ${profileRef} and slicing is CLOSED: ${fhirPath}`;
+        if (kind === 'extension-url') {
+            const urls = slices.map(s => instanceUrl(s, fields)).filter((u) => !!u);
+            // Every slice must be identifiable, or a conformant member gets reported.
+            if (urls.length !== slices.length)
+                continue;
+            const allowed = `[${[...new Set(urls)].map(u => `"${u}"`).join(', ')}]`;
+            // A member with no url matches no slice either, and HL7 reports it: every
+            // discriminator here is `<canonical> in url`, so an absent url satisfies none
+            // of them. Firing only on a *present* url meant the member KBV's random
+            // Medication carries — `{extension:[…]}` with no url at all — went unreported
+            // while HL7 named all four slices it failed to match. The missing url itself
+            // is a separate finding (Extension.url: minimum required = 1) that both
+            // validators already agree on; this is the slicing violation on top of it.
+            out.push(`
+  // Closed slicing on ${fhirPath}: only the declared extension urls are allowed${walk(segments, `
+    const _csUrl = at(_csElem, 'url');
+    if (typeof _csUrl !== 'string' || !${allowed}.includes(_csUrl)) {
+      errors.push("${message}" + (typeof _csUrl === 'string' ? " (url = " + _csUrl + ")" : " (no url)"));
+    }`)}`);
+            seen.add(elemId);
+            continue;
+        }
+        // choice-type: the slot is `foo[x]`, so an instance writes `fooCoding` etc.
+        const baseProp = leaf.slice(0, -CHOICE_SUFFIX.length);
+        const props = slices.map(s => choiceProperty(baseProp, s)).filter((p) => !!p);
+        if (props.length !== slices.length)
+            continue;
+        const allowedProps = `[${[...new Set(props)].map(p => `"${p}"`).join(', ')}]`;
+        // The choice lives on the parent element — `foo[x]` is not a property name.
+        const body = `
+    const _csKey = Object.keys(node(_csElem)).find((k) => k.startsWith("${baseProp}") && k !== "${baseProp}");
+    if (_csKey !== undefined && !${allowedProps}.includes(_csKey)) {
+      errors.push("${message}.ofType(" + _csKey.slice(${baseProp.length}).toLowerCase() + ")");
+    }`;
+        const parentSegments = segments.slice(0, -1);
+        out.push(`
+  // Closed slicing on ${fhirPath}: only the declared types are allowed${parentSegments.length === 0
+            ? `\n  {\n    const _csElem = resource;${body}\n  }`
+            : walk(parentSegments, body)}`);
+        seen.add(elemId);
+    }
+    return out;
+}

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

@@ -0,0 +1,450 @@
+/**
+ * Delegating slice members to other generated validators.
+ *
+ * A slice can pin its resource, or a reference's target, to another profile. These
+ * emitters match the members and hand each one to that profile's generated
+ * validator, which is what keeps findings inside a nested resource from being
+ * lost. Split out of sliceValidatorGenerator, which had grown past the size limit.
+ */
+import { stripVersionFromCanonicalUrl } from '../../core/utils.js';
+import { safeAccessor, safeList, collectWithinSliceMaxChildren, generateWithinSliceMaxChecks } from './sliceValidatorUtils.js';
+export function generateProfiledChildDelegation(slice, relPath, childFieldsWithFixedValue, out, ctx) {
+    if (!ctx.profileUrlToName || !ctx.validatorImports)
+        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}')), _delegateOptions);
+              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}')), _delegateOptions);
+        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.
+ */
+export 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.
+ */
+/**
+ * Required slice discriminated by `$this` where the slice element itself carries
+ * `fixed[x]` — the value in the array *is* the discriminator.
+ *
+ * The canonical case is a profile pinning its own identity, which German IGs do
+ * on nearly every resource:
+ *
+ *   Composition.meta.profile              slicing: value on $this, min 1
+ *   Composition.meta.profile:erpProfile   min 1, fixedCanonical: '…|1.4'
+ *
+ * Every other strategy keys off a *child* element (pattern coding, child
+ * fixedValue, binding, extension url), so this shape fell through to
+ * "no pattern/value discriminator found" and emitted no check at all. HL7 reports
+ * `Slice 'Composition.meta.profile:erpProfile': a matching slice is required, but
+ * not found`, we reported nothing, and kbv-erp scored 0/2 on both parity metrics
+ * for exactly that one field.
+ *
+ * The fixed value is compared verbatim, version suffix included: a canonical
+ * pinned to `|1.4` is not satisfied by the unversioned URL, and HL7 agrees.
+ */
+export function generateReferenceProfileDiscriminatorValidation(slice, relPath, errorPath, sliceLabel, varName, min, targetResourceType, out, fields, baseResourceType) {
+    // Build within-slice child max constraint checks (e.g., max=0 forbidden fields)
+    const maxChildren = fields ? collectWithinSliceMaxChildren(slice, fields) : [];
+    const resType = baseResourceType || (slice.elementId || slice.name).split('.')[0];
+    const childMaxChecks = generateWithinSliceMaxChecks(maxChildren, `_${varName}Refs`, resType, relPath, sliceLabel);
+    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 {
+    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.
+ *
+ * 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.
+ */
+/**
+ * Delegate an optional slice's profiled resource without asserting the slice is
+ * present.
+ *
+ * Reuses the profile-discriminator path with min=0, which emits the member match
+ * and delegation but no cardinality error — the slice is allowed to be absent, and
+ * only its contents are in question.
+ */
+export function generateOptionalProfiledSliceDelegation(slice, baseName, fields, out, ctx) {
+    const relPath = baseName.replace(/^[^.]+\./, '');
+    // Nested and choice-type slices need the scoping the required path builds up;
+    // this narrow route only covers a top-level repeating element.
+    if (!relPath || relPath.includes('.') || relPath.includes('[x]'))
+        return;
+    const match = detectProfileDiscriminator(slice, fields, ctx.profileUrlToType);
+    if (!match)
+        return;
+    const sliceLabel = slice.sliceName || 'slice';
+    const varName = sliceLabel.replace(/[^a-zA-Z0-9_]/g, '_');
+    generateProfileDiscriminatorValidation(slice, relPath, relPath, sliceLabel, varName, 0, match, out, ctx);
+}
+/**
+ * A slice discriminated by `{type, $this}` on a slot holding inline resources.
+ *
+ * cdex slices Task.contained that way, with contained:practitionerrole typed
+ * PractitionerRole and contained:patient typed Patient. The member *is* the
+ * resource, so membership is decided by its resourceType — unlike the Bundle case,
+ * where the type sits on the slice's `.resource` child.
+ *
+ * field.type is often the profile alias (cdex-practitionerrole), so the concrete
+ * type is taken from baseTypeCode or typeOptions in preference to it.
+ */
+export function detectSelfTypeDiscriminator(slice) {
+    const isResourceTypeName = (name) => !!name && /^[A-Z][A-Za-z]+$/.test(name) && name !== 'Resource' && name !== 'DomainResource';
+    const candidates = [
+        slice.baseTypeCode,
+        ...(slice.typeOptions ?? []).map(option => option.code),
+        slice.type,
+    ];
+    return candidates.find(isResourceTypeName);
+}
+/**
+ * Emit the cardinality check for a `{type, $this}` slice.
+ *
+ * Deliberately does not delegate to the slice's profile: that would validate the
+ * contained resource against it and add findings whose agreement with HL7 is
+ * unverified. This covers the missing membership check only.
+ */
+export function generateSelfTypeSliceValidation(slice, relPath, errorPath, sliceLabel, varName, min, resourceType, out) {
+    void slice;
+    out.push(`
+  // Required slice validation for ${relPath}:${sliceLabel} (type discriminator → ${resourceType})
+  {
+    const _${varName}Typed = elements(${safeAccessor(relPath)}).filter(
+      (item) => at(item, 'resourceType') === '${resourceType}'
+    );
+    if (_${varName}Typed.length < ${min}) {
+      errors.push("Slice '${errorPath}:${sliceLabel}': a matching slice is required, but not found");
+    }
+  }`);
+}
+/**
+ * Emit the cardinality check for a slice discriminated by `{profile, $this}` against
+ * a datatype profile.
+ *
+ * The slice names a profile rather than a value, so the profile's pinned element is
+ * what distinguishes its members — sdc's useContext:library resolves to
+ * UsageContext.code pinned to usage-context-type|workflow. Without this the slice
+ * was unmatchable and HL7's missing-slice finding had no counterpart.
+ */
+export function generateDatatypeProfileSliceValidation(relPath, errorPath, sliceLabel, varName, min, pin, out) {
+    const target = `at(item, '${pin.path}')`;
+    // A Coding carries system/code itself; a CodeableConcept wraps them in .coding.
+    const predicate = pin.shape === 'coding'
+        ? [
+            pin.system ? `coding(${target}).system === '${pin.system}'` : '',
+            `coding(${target}).code === '${pin.code}'`,
+        ].filter(Boolean).join(' && ')
+        : `codings(${target}).some((c) => ${[
+            pin.system ? `c.system === '${pin.system}'` : '',
+            `c.code === '${pin.code}'`,
+        ].filter(Boolean).join(' && ')})`;
+    out.push(`
+  // Required slice validation for ${relPath}:${sliceLabel} (profile discriminator → ${pin.path} pinned to ${pin.code})
+  {
+    const _${varName}Profiled = elements(${safeAccessor(relPath)}).filter((item) => ${predicate});
+    if (_${varName}Profiled.length < ${min}) {
+      errors.push("Slice '${errorPath}:${sliceLabel}': a matching slice is required, but not found");
+    }
+  }`);
+}
+export 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.
+ */
+export 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;
+    const delegateNames = [];
+    if (ctx.profileUrlToName && ctx.validatorImports) {
+        for (const pUrl of profileUrls) {
+            // A type.profile on an entry slice is often version-pinned
+            // (…/dtr-questionnaireresponse|2.2.0) while the map is keyed by the bare
+            // canonical, so the versioned form has to fall back to the stripped one.
+            // Without it the slice emitted its cardinality check but never delegated,
+            // and every finding inside the entry's own profile went unreported.
+            const name = ctx.profileUrlToName.get(pUrl)
+                ?? ctx.profileUrlToName.get(stripVersionFromCanonicalUrl(pUrl));
+            if (name && name !== ctx.profileName) {
+                if (!delegateInterfaceName)
+                    delegateInterfaceName = name;
+                // Every candidate is collected, not just the first: an entry slice may allow
+                // several profiles, and conformance to any one of them is enough.
+                if (!delegateNames.includes(name)) {
+                    delegateNames.push(name);
+                    ctx.validatorImports.set(name, `./${name}.js`);
+                }
+            }
+        }
+    }
+    // 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 (delegateNames.length > 1) {
+        // Several profiles are allowed, so conforming to any one of them is enough.
+        // Reporting the first candidate's findings unconditionally invented errors for an
+        // entry that legitimately matched a later choice. When none matches, HL7 adds two
+        // summaries alongside the individual findings, which is mirrored here.
+        const choices = profileUrls.join(', ');
+        code += `
+    for (const _e of _${varName}Entries) {
+      if (at(_e, 'resource')) {
+        const _${varName}Candidates = [
+${delegateNames.map(name => `          await validate${name}(asResource(at(_e, 'resource')), _delegateOptions),`).join('\n')}
+        ];
+        const _${varName}Conforming = _${varName}Candidates.find((c) => c.errors.length === 0);
+        if (_${varName}Conforming) {
+          warnings.push(..._${varName}Conforming.warnings);
+        } else {
+          errors.push("The entry resource did not match any of the allowed profiles (Type ${resourceType}: ${choices})");
+          errors.push("Unable to find a match for the specified profile among choices: ${choices}");
+          errors.push(..._${varName}Candidates[0].errors);
+          warnings.push(..._${varName}Candidates[0].warnings);
+        }
+      }
+    }`;
+    }
+    else if (delegateInterfaceName) {
+        code += `
+    for (const _e of _${varName}Entries) {
+      if (at(_e, 'resource')) {
+        const _sub = await validate${delegateInterfaceName}(asResource(at(_e, 'resource')), _delegateOptions);
+        errors.push(..._sub.errors);
+        warnings.push(..._sub.warnings);
+      }
+    }`;
+    }
+    code += `
+  }`;
+    out.push(code);
+}