babelfhir-ts 1.6.7 → 1.6.8

package/README.md

@@ -46,7 +46,7 @@
 - **Type-safe extension handling** with proper slicing and nested extension support
 - **Random data builders** for testing and development (when class generation is enabled)
 - **Zero manual mapping**—consume any FHIR package or Implementation Guide directly from registries
-- **Fast and lightweight**—the CLI pulls no FHIRPath engine of its own; generated packages declare `fhirpath` as a *peer* dependency (`>=4.9.1 <6`), so the host app owns the version
+- **Fast and lightweight**—the CLI pulls no FHIRPath engine of its own; generated packages declare `fhirpath` as a *peer* dependency (`>=5.2.0 <6`), so the host app owns the version
 - **Type-safe FHIR client** — generated client extends [`@babelfhir-ts/client-r4`](https://www.npmjs.com/package/@babelfhir-ts/client-r4) / [`client-r4b`](https://www.npmjs.com/package/@babelfhir-ts/client-r4b) / [`client-r5`](https://www.npmjs.com/package/@babelfhir-ts/client-r5) with profile-specific methods (e.g., `.uSCorePatientProfile()`, `.pASClaim()`) on top of base resource accessors
 - **Install any FHIR profile as a node module**—use `babelfhir-ts install` to add Implementation Guides (FHIR Packages) directly to your project
 

package/out/src/generator/core/generatedPackageDeps.js

@@ -86,8 +86,17 @@ export const EMITTED_RANGES = {
      * Capped below 6.0.0: majors do break consumers here. 5.x added an `exports`
      * map, which is why the emitted import carries an explicit
      * `/fhir-context/<model>/index.js` filename.
+     *
+     * The floor moved to 5.2.0 with htmlChecks(). R4 writes txt-1 and txt-2 as
+     * `htmlChecks()` on Narrative.div, and an unimplemented function throws out of the
+     * whole evaluation rather than returning false — so on an older engine a resource
+     * carrying a narrative lost every other finding too, not just the narrative check.
+     * This repo supplied the function through fhirpath's userInvocationTable until
+     * 5.2.0 implemented it (HL7/fhirpath.js#147). The supplied copy is gone, so an
+     * engine below 5.2.0 would take those findings down with it: the floor is what
+     * keeps that from reaching a consumer silently.
      */
-    fhirpath: '>=4.9.1 <6.0.0',
+    fhirpath: '>=5.2.0 <6.0.0',
     /**
      * Schema runtime for `--schema zod` output.
      *
@@ -111,8 +120,29 @@ export const EMITTED_RANGES = {
      * drop them.
      */
     prefab: '^0.3.0',
-    /** Generated FHIR client base package (`@babelfhir-ts/client-<slug>`). */
-    client: '^0.2.0',
+    /**
+     * Generated FHIR client base package (`@babelfhir-ts/client-<slug>`).
+     *
+     * The emitted client is a thin profile-typed layer over this package —
+     * `FhirReadClient`/`FhirWriteClient` are extended, `BundleParser` is extended —
+     * so the range here decides which transport every generated package actually
+     * runs on. `^0.2.0` on a `0.x` version resolves to `>=0.2.0 <0.3.0`, so it did
+     * not merely set a floor: it CAPPED every consumer below 0.3.0, and 0.3.0 is
+     * where the writer started parsing the `OperationOutcome` of a rejected write.
+     * On 0.2.x a failed save reports `PUT Consent/123: 400 Bad Request` and
+     * discards the server's account of why — the unresolvable reference, the failed
+     * invariant, the scope it would not accept.
+     *
+     * The cap also multiplied installs: an app depending on both a generated
+     * package and `@babelfhir-ts/client-r4@^0.3` gets 0.2.x nested under every
+     * generated package alongside its own 0.3.x, so two copies of the client (and
+     * of SmartAuth) run in one bundle.
+     *
+     * Safe to raise by construction: `fhir-client.js` is byte-identical between
+     * 0.2.6 and 0.3.2 and `index.js` only ADDS `hasId`, so nothing the emitted
+     * layer calls changed shape. Capped below 0.4.0 as usual for a 0.x line.
+     */
+    client: '^0.3.2',
     /** Shared base zod schemas (`@babelfhir-ts/zod`). */
     zodBase: '^0.2.0',
     /** DICOMweb helpers (`@babelfhir-ts/dicomweb`). */

package/out/src/generator/core/utils.js

@@ -22,6 +22,37 @@ export function stripVersionFromCanonicalUrl(url) {
  * returns a string: the split form is an indexing expression, which is only
  * `string | undefined` to the compiler even though it can never be empty.
  */
+/**
+ * Whether a name is shaped like a FHIR resource type.
+ *
+ * `Resource` and `DomainResource` are excluded on purpose: they name every resource
+ * rather than one, so a check that accepts them rejects nothing.
+ */
+export function looksLikeResourceTypeName(name) {
+    if (!name)
+        return false;
+    if (name === 'Resource' || name === 'DomainResource')
+        return false;
+    return /^[A-Z][A-Za-z]+$/.test(name);
+}
+/**
+ * The resource type a profile URL constrains, or undefined when it cannot be known.
+ *
+ * The registry comes first, the URL's last segment second. Three emitters resolved
+ * this independently and two of them read the segment first, which is wrong in a way
+ * that only shows on IG profiles: the last segment of
+ * `.../StructureDefinition/MyPatientProfile` is shaped exactly like a resource type,
+ * so the heuristic answered `MyPatientProfile` while the registry knew `Patient`. The
+ * segment is a fallback for URLs the registry never saw, not a first guess.
+ */
+export function resourceTypeForProfileUrl(url, profileUrlToType) {
+    const bare = stripVersionFromCanonicalUrl(url);
+    const registered = profileUrlToType?.get(bare) ?? profileUrlToType?.get(url);
+    if (looksLikeResourceTypeName(registered))
+        return registered;
+    const lastSegment = bare.split('/').pop() ?? '';
+    return looksLikeResourceTypeName(lastSegment) ? lastSegment : undefined;
+}
 export function stripSliceSuffix(path) {
     if (!path)
         return path;

package/out/src/generator/emitters/requiredBindings.js

@@ -0,0 +1,124 @@
+/**
+ * Which required-strength ValueSet bindings are enforceable, and against what.
+ *
+ * The validator and the zod schema are compared against each other on every parity
+ * run, so they have to agree on which bindings they check. They did not: the
+ * validator walked any depth and accepted `code`, `Coding`, `CodeableConcept`,
+ * `Quantity`, `string` and `uri`, while the zod builder took only depth-1
+ * `CodeableConcept`/`Coding` and inlined the code list. Every binding below the root
+ * was reported by one side and not the other — 146 of the 285 disagreements on that
+ * board, and the single largest class by a wide margin.
+ *
+ * The rule is written down here, and the zod builder now follows it: same selection,
+ * same ValueSet resolution, same wording. The validator still carries its own copy of
+ * the filter, because its builder threads each field through path building, choice
+ * suffixing and nested-array handling that would have to move with it — a refactor
+ * worth doing on its own, against the parity board, not folded into this change.
+ * Until then this module is the statement of the rule and the zod side's single
+ * source for it; changing the validator's filter means changing both.
+ */
+import { stripVersionFromCanonicalUrl } from '../core/utils.js';
+import { sanitizeValueSetName } from './valueset/valueSetGenerator.js';
+/** Types FHIR permits a binding on. */
+const BINDABLE_TYPES = ['code', 'Coding', 'CodeableConcept', 'Quantity', 'string', 'uri'];
+export function resolveRequiredBindingValueSet(bindingUri, valueSets) {
+    if (!bindingUri || !valueSets)
+        return undefined;
+    let vs = valueSets.get(bindingUri);
+    let resolvedUri = bindingUri;
+    if (!vs && bindingUri.includes('|')) {
+        resolvedUri = stripVersionFromCanonicalUrl(bindingUri);
+        vs = valueSets.get(resolvedUri);
+    }
+    if (!vs)
+        return undefined;
+    const displayName = resolvedUri.split('/').pop() || vs.name;
+    if (vs.concepts.length === 0) {
+        if (vs.systems && vs.systems.length > 0) {
+            return { systemOnly: true, displayName, systems: vs.systems };
+        }
+        return undefined;
+    }
+    const sanitizedName = sanitizeValueSetName(vs.name);
+    return {
+        sanitizedName,
+        displayName,
+        validatorFn: `isValid${sanitizedName}Code`,
+        importPath: `./valuesets/ValueSet-${sanitizedName}.js`,
+        uri: stripVersionFromCanonicalUrl(bindingUri),
+    };
+}
+/** The leaf kind for a bindable type, or undefined when the type carries no code. */
+export function bindingLeafKind(type) {
+    if (!type)
+        return undefined;
+    // string and uri hold the code in the element's own value, exactly like `code`.
+    if (type === 'code' || type === 'string' || type === 'uri')
+        return 'code';
+    if (type === 'Quantity')
+        return 'code';
+    if (type === 'Coding' || type === 'CodeableConcept')
+        return 'codings';
+    return undefined;
+}
+/**
+ * Select the fields whose required binding is worth checking.
+ *
+ * Mirrors what the validator's binding builder already accepted, so widening one
+ * side cannot introduce a finding the other never makes:
+ *   - required strength with a binding URI
+ *   - a bindable type
+ *   - not a slice, unless the slice name encodes a choice variant (`value[x]:valueCode`),
+ *     which maps to a concrete property
+ *   - no `[x]` above the leaf: stripping it leaves a property that does not exist
+ */
+export function selectRequiredBindingTargets(fields, rootPrefix) {
+    const targets = [];
+    const seen = new Set();
+    for (const field of fields) {
+        if (field.binding?.strength !== 'required' || !field.binding.uri)
+            continue;
+        if (field.max === 0)
+            continue;
+        if (field.sliceName) {
+            const elemId = field.elementId || field.name || '';
+            if (!elemId.includes('[x]:'))
+                continue;
+        }
+        const declaredType = field.type || field.baseTypeCode;
+        if (!declaredType || !BINDABLE_TYPES.includes(declaredType))
+            continue;
+        const kind = bindingLeafKind(declaredType);
+        if (!kind)
+            continue;
+        const relRaw = (field.name || '').replace(new RegExp(`^${rootPrefix}\\.`), '');
+        if (!relRaw || relRaw === field.name)
+            continue;
+        const segments = relRaw.split('.');
+        if (segments.slice(0, -1).some(segment => segment.includes('[x]')))
+            continue;
+        const leaf = segments[segments.length - 1];
+        if (!leaf)
+            continue;
+        // A choice leaf becomes its concrete property: value[x] + Coding → valueCoding.
+        const path = leaf.includes('[x]')
+            ? [...segments.slice(0, -1), leaf.replace('[x]', declaredType.charAt(0).toUpperCase() + declaredType.slice(1))]
+            : segments;
+        if (path.some(segment => segment.includes('[x]') || segment.includes(':')))
+            continue;
+        const key = `${path.join('.')}|${field.binding.uri}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        targets.push({ field, path, kind });
+    }
+    return targets;
+}
+/** The finding both emitters report when no coding in the element is in the ValueSet. */
+export function codingsNotInValueSetMessage(displayName, uri) {
+    return `None of the codings provided are in the value set '${displayName}' (${uri}), and a coding from this value set is required)`;
+}
+/** The finding both emitters report when a single code is not in the ValueSet. */
+export function codeNotInValueSetMessage(displayName, uri) {
+    return `does not exist in the value set '${displayName}' (${uri}), but the binding is of strength 'required'`;
+}

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

@@ -21,8 +21,15 @@
  * conformant resource. Enforcing those needs slice-scoped traversal and is left off
  * rather than approximated.
  */
-import { stripVersionFromCanonicalUrl } from '../../core/utils.js';
+import { resourceTypeForProfileUrl, stripVersionFromCanonicalUrl } from '../../core/utils.js';
 const CHOICE_SUFFIX = '[x]';
+/**
+ * The resource-type shape, for the *generated* guard.
+ *
+ * looksLikeResourceTypeName is the emitter-side twin; this is the same rule written
+ * for the emitted file, which has no access to our helpers.
+ */
+const RESOURCE_TYPE_SHAPE = '/^[A-Z][A-Za-z]+$/';
 /** 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(/^[^.]+\./, '');
@@ -52,6 +59,38 @@ function choiceProperty(baseProp, slice) {
         return undefined;
     return `${baseProp}${code.charAt(0).toUpperCase()}${code.slice(1)}`;
 }
+/** Whether this element holds a Reference, so its slices are told apart by target. */
+function isReferenceElement(field) {
+    if (field.type === 'Reference' || field.baseTypeCode === 'Reference')
+        return true;
+    return (field.typeOptions ?? []).some(option => option.code === 'Reference');
+}
+/**
+ * The resource types a Reference slice accepts, or undefined when any target is
+ * unresolvable.
+ *
+ * A target names a profile, not a type: `.../vitals/StructureDefinition/body-weight`
+ * is an Observation, and only the package registry knows that. A core URL carries the
+ * type in its last segment. Anything left unresolved returns undefined, which takes
+ * the whole slicing out of enforcement rather than judging against a partial set.
+ */
+function referenceTargetTypes(slice, profileUrlToType) {
+    const targets = (slice.typeOptions ?? [])
+        .filter(option => option.code === 'Reference')
+        .flatMap(option => option.targetProfileUrls ?? []);
+    if (targets.length === 0)
+        return undefined;
+    const types = [];
+    for (const target of targets) {
+        // Undefined covers both an unresolvable target and one open to any resource,
+        // and either leaves the allowed set incomplete.
+        const resolved = resourceTypeForProfileUrl(target, profileUrlToType);
+        if (!resolved)
+            return undefined;
+        types.push(resolved);
+    }
+    return [...new Set(types)];
+}
 /** Classify a closed slicing, or undefined when it is not one this module enforces. */
 function classify(leaf) {
     if (leaf === 'extension' || leaf === 'modifierExtension')
@@ -74,7 +113,7 @@ function walk(segments, body) {
 /**
  * Emit closed-slicing checks for every element that introduces a closed slicing.
  */
-export function generateClosedSlicingValidations(fields, profileUrl, baseResourceType) {
+export function generateClosedSlicingValidations(fields, profileUrl, baseResourceType, profileUrlToType) {
     const out = [];
     const seen = new Set();
     for (const field of fields) {
@@ -91,7 +130,7 @@ export function generateClosedSlicingValidations(fields, profileUrl, baseResourc
         const leaf = segments.at(-1);
         if (!leaf)
             continue;
-        const kind = classify(leaf);
+        const kind = classify(leaf) ?? (isReferenceElement(field) ? 'reference-target' : undefined);
         if (!kind)
             continue;
         // A choice segment above the leaf is not a JSON property name, so the walk
@@ -104,6 +143,45 @@ export function generateClosedSlicingValidations(fields, profileUrl, baseResourc
         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 === 'reference-target') {
+            // A `resolve()` discriminator tells slices apart by what the reference points
+            // at, which needs the target. The target type does not: a slicing whose slices
+            // all accept Observation cannot hold a `Patient/x`, resolvable or not, and HL7
+            // reports exactly that — vital-signs-panel.hasMember was the whole `entry`
+            // category of the vitals random-parity gap.
+            //
+            // Only the type is judged, never the identity. Reference.type when present,
+            // else the `Type/id` prefix of a relative literal reference; an absolute URL,
+            // a `urn:uuid:` or a contained `#id` yields no type and is left alone. That is
+            // narrower than the reference-target check in validatorTemplates, which stays
+            // silent on any unresolved reference: there the finding IS resolution, here the
+            // finding is slice membership, and a closed slicing rules out a wrong type
+            // without resolving anything.
+            const perSlice = slices.map(s => referenceTargetTypes(s, profileUrlToType));
+            // One unresolvable slice and the allowed set is incomplete, so a conformant
+            // member could be reported. Same all-or-nothing rule as the other two kinds.
+            if (perSlice.some(types => !types))
+                continue;
+            const allowed = [...new Set(perSlice.flat())];
+            if (allowed.length === 0)
+                continue;
+            const allowedList = `[${allowed.map(t => `"${t}"`).join(', ')}]`;
+            out.push(`
+  // Closed slicing on ${fhirPath}: only references to ${allowed.join(', ')} can match a slice${walk(segments, `
+    const _csRefType = at(_csElem, 'type');
+    const _csRefStr = at(_csElem, 'reference');
+    const _csPrefix = typeof _csRefStr === 'string' && _csRefStr.indexOf('/') > 0
+      ? _csRefStr.slice(0, _csRefStr.indexOf('/'))
+      : undefined;
+    const _csTarget = typeof _csRefType === 'string' && _csRefType.length > 0
+      ? _csRefType
+      : (typeof _csPrefix === 'string' && ${RESOURCE_TYPE_SHAPE}.test(_csPrefix) ? _csPrefix : undefined);
+    if (_csTarget !== undefined && !${allowedList}.includes(_csTarget)) {
+      errors.push("${message} (target = " + _csTarget + ")");
+    }`)}`);
+            seen.add(elemId);
+            continue;
+        }
         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.

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

@@ -115,7 +115,97 @@ export function collectFixedValueSliceChildren(sliceElementId, fields, discrimin
     }
     return result;
 }
-export function generateBackboneElementValidation(slice, relPath, errorPath, sliceLabel, varName, min, fields, childFieldsWithPattern, out, profileName) {
+/**
+ * Collect fixed-value descendants one level below a slice's direct children.
+ *
+ * The pinned element of a profiled backbone slice is usually a grandchild, not a
+ * child: `component:SystolicBP.value[x]:valueQuantity.code` is fixed to `mm[Hg]`,
+ * and `collectFixedValueSliceChildren` skips it because the relative path has a dot.
+ * The root-level builder skips it too, deliberately — a pin declared on a slice
+ * must apply only to that slice's members, and it has no slice identity to filter
+ * on (see the `hasSliceQualifier` guard in validatorFieldBuilders). So nothing
+ * checked it, and HL7's `Value is '/min' but is fixed to 'mm[Hg]'` was the whole
+ * `code` category of the vitals random-parity gap.
+ *
+ * Emitted inside the matched-element loop, which is what keeps the pin scoped to
+ * the slice that declares it.
+ *
+ * Two relative shapes reach a grandchild:
+ *   `valueQuantity.code`            a plain child, then its leaf
+ *   `value[x]:valueQuantity.code`   a type slice on a choice, then its leaf
+ */
+export function collectNestedFixedValueSliceChildren(sliceElementId, fields, discriminatorProp) {
+    const result = [];
+    const seen = new Set();
+    for (const f of fields) {
+        const childId = f.elementId || f.name;
+        if (!childId.startsWith(sliceElementId + '.'))
+            continue;
+        if (f.fixedValue === undefined)
+            continue;
+        if (typeof f.fixedValue !== 'string' && typeof f.fixedValue !== 'number' && typeof f.fixedValue !== 'boolean')
+            continue;
+        const relativePath = childId.substring(sliceElementId.length + 1);
+        const parts = relativePath.split('.');
+        if (parts.length !== 2)
+            continue;
+        const [parentSegment, leafSegment] = parts;
+        if (!parentSegment || !leafSegment)
+            continue;
+        // A leaf that is itself sliced needs its own scope, and a choice leaf has no
+        // single property name to read.
+        if (leafSegment.includes(':') || leafSegment.endsWith('[x]'))
+            continue;
+        // `value[x]:valueQuantity` writes the typed property; a plain child writes itself.
+        const parentProp = parentSegment.includes('[x]:')
+            ? parentSegment.split(':')[1]
+            : parentSegment.includes(':') ? undefined : parentSegment.replace(/\[x\]$/, '');
+        if (!parentProp)
+            continue;
+        if (parentProp === discriminatorProp)
+            continue;
+        const key = `${parentProp}.${leafSegment}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        const parentField = fields.find(pf => (pf.elementId || pf.name) === `${sliceElementId}.${parentSegment}`);
+        result.push({
+            parentProp,
+            isParentArray: parentField?.isArray ?? false,
+            prop: leafSegment,
+            fixedValue: f.fixedValue,
+            elementPath: childId,
+        });
+    }
+    return result;
+}
+/** Emit the fixed-value checks for a slice's grandchildren, inside the matched-element loop. */
+export function generateNestedFixedValueChecks(nested, profileRef) {
+    return nested.map(n => {
+        const expected = typeof n.fixedValue === 'string' ? JSON.stringify(n.fixedValue) : String(n.fixedValue);
+        const display = String(n.fixedValue).replace(/"/g, '\\"');
+        const anchor = `${profileRef}#${n.elementPath}`;
+        const report = `errors.push("Value is '" + _fx.${n.prop} + "' but is fixed to '${display}' in the profile ${anchor}");`;
+        const guard = `_fx.${n.prop} !== undefined && _fx.${n.prop} !== null && String(_fx.${n.prop}) !== ${expected}`;
+        if (n.isParentArray) {
+            return `
+      for (const _fxItem of elements(at(_m, '${n.parentProp}'))) {
+        const _fx = node(_fxItem);
+        if (${guard}) {
+          ${report}
+        }
+      }`;
+        }
+        return `
+      if (_m.${n.parentProp} !== undefined && _m.${n.parentProp} !== null) {
+        const _fx = node(at(_m, '${n.parentProp}'));
+        if (${guard}) {
+          ${report}
+        }
+      }`;
+    }).join('');
+}
+export function generateBackboneElementValidation(slice, relPath, errorPath, sliceLabel, varName, min, fields, childFieldsWithPattern, out, profileName, profileUrl) {
     const sliceElementId = slice.elementId || slice.name;
     const discriminatorChild = childFieldsWithPattern.find(f => {
         const fElementId = f.elementId || f.name;
@@ -181,6 +271,7 @@ export function generateBackboneElementValidation(slice, relPath, errorPath, sli
     const resourceType = profileName || firstSegment(sliceElementId);
     const requiredChildren = collectRequiredSliceChildren(sliceElementId, fields, discriminatorProp, resourceType, relPath);
     const nestedChildren = collectNestedRequiredSliceChildren(sliceElementId, fields, discriminatorProp, resourceType, relPath);
+    const nestedFixed = collectNestedFixedValueSliceChildren(sliceElementId, fields, discriminatorProp);
     const directChecksInner = requiredChildren.map(c => c.isChoiceType
         ? `\n      if (!Object.keys(_m).some(k => k.startsWith('${c.prop}'))) {
         errors.push("${c.errorPath}: minimum required = 1, but only found 0");
@@ -210,11 +301,12 @@ export function generateBackboneElementValidation(slice, relPath, errorPath, sli
         }
       }`;
     }).join('');
+    const nestedFixedChecksInner = generateNestedFixedValueChecks(nestedFixed, profileUrl || resourceType);
     const maxChildren = collectWithinSliceMaxChildren(slice, fields);
     const maxChecksCode = generateWithinSliceMaxChecks(maxChildren, `${varName}Elements`, resourceType, relPath, sliceLabel);
-    const childChecksCode = (requiredChildren.length > 0 || nestedChildren.length > 0
+    const childChecksCode = (requiredChildren.length > 0 || nestedChildren.length > 0 || nestedFixed.length > 0
         ? `\n    for (const _matched of ${varName}Elements) {
-      const _m = node(_matched);${directChecksInner}${nestedChecksInner}
+      const _m = node(_matched);${directChecksInner}${nestedChecksInner}${nestedFixedChecksInner}
     }`
         : '') + maxChecksCode;
     const pathParts = relPath.split('.');
@@ -266,7 +358,7 @@ export function generateBackboneElementValidation(slice, relPath, errorPath, sli
  * the child .name has fixedString: "sourceIdentifier".
  * Generates: resource.parameter.filter(item => item.name === "sourceIdentifier")
  */
-export function generateFixedValueSliceValidation(slice, relPath, errorPath, sliceLabel, varName, min, fields, childFieldsWithFixedValue, out, profileName) {
+export function generateFixedValueSliceValidation(slice, relPath, errorPath, sliceLabel, varName, min, fields, childFieldsWithFixedValue, out, profileName, profileUrl) {
     const sliceElementId = slice.elementId || slice.name;
     // The caller only reaches here with a fixed-value child, but an empty list would
     // otherwise read its discriminator off undefined.
@@ -288,6 +380,7 @@ export function generateFixedValueSliceValidation(slice, relPath, errorPath, sli
     const resourceType = profileName || firstSegment(sliceElementId);
     const requiredChildren = collectRequiredSliceChildren(sliceElementId, fields, discriminatorProp, resourceType, relPath);
     const nestedChildren = collectNestedRequiredSliceChildren(sliceElementId, fields, discriminatorProp, resourceType, relPath);
+    const nestedFixed = collectNestedFixedValueSliceChildren(sliceElementId, fields, discriminatorProp);
     const fixedChildren = collectFixedValueSliceChildren(sliceElementId, fields, discriminatorProp);
     const directChecksInner = requiredChildren.map(c => c.isChoiceType
         ? `\n      if (!Object.keys(_m).some(k => k.startsWith('${c.prop}'))) {
@@ -325,11 +418,12 @@ export function generateFixedValueSliceValidation(slice, relPath, errorPath, sli
         errors.push("Value is '" + _m.${c.prop} + "' but is fixed to '${display}' in the profile ${resourceType}#${c.elementPath}");
       }`;
     }).join('');
+    const nestedFixedChecksInner = generateNestedFixedValueChecks(nestedFixed, profileUrl || resourceType);
     const maxChildren = collectWithinSliceMaxChildren(slice, fields);
     const maxChecksCode = generateWithinSliceMaxChecks(maxChildren, `${varName}Elements`, resourceType, relPath, sliceLabel);
-    const childChecksCode = (requiredChildren.length > 0 || nestedChildren.length > 0 || fixedChildren.length > 0
+    const childChecksCode = (requiredChildren.length > 0 || nestedChildren.length > 0 || fixedChildren.length > 0 || nestedFixed.length > 0
         ? `\n    for (const _matched of ${varName}Elements) {
-      const _m = node(_matched);${directChecksInner}${nestedChecksInner}${fixedChecksInner}
+      const _m = node(_matched);${directChecksInner}${nestedChecksInner}${fixedChecksInner}${nestedFixedChecksInner}
     }`
         : '') + maxChecksCode;
     // Detect if this slice is nested inside a parent array (e.g., component.code inside component[])

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

@@ -6,7 +6,7 @@
  * 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, firstSegment } from '../../core/utils.js';
+import { resourceTypeForProfileUrl, stripVersionFromCanonicalUrl, firstSegment } 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)
@@ -153,17 +153,8 @@ export function detectReferenceProfileDiscriminator(slice, profileUrlToType) {
     const targetUrl = refType?.targetProfileUrls?.[0];
     if (!targetUrl)
         return undefined;
-    // 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;
+    // Registry first, URL segment second — see resourceTypeForProfileUrl.
+    return resourceTypeForProfileUrl(targetUrl, profileUrlToType);
 }
 /**
  * Generate slice validation for Reference-typed slices discriminated by target profile.

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

@@ -171,13 +171,13 @@ export function generateSliceValidations(ctx) {
                         generateExtensionUrlSliceValidation(slice, relPath, errorPath, sliceLabel, varName, min, extUrl, fieldPathMap, arrayFieldPaths, sliceValidations, ctx);
                     }
                     else {
-                        generateFixedValueSliceValidation(slice, relPath, errorPath, sliceLabel, varName, min, fields, childFieldsWithFixedValue, sliceValidations, ctx.baseResourceType);
+                        generateFixedValueSliceValidation(slice, relPath, errorPath, sliceLabel, varName, min, fields, childFieldsWithFixedValue, sliceValidations, ctx.baseResourceType, ctx.profileUrl);
                         // Delegate validation to profiled sub-resource validators (e.g., Parameters.parameter.resource → Bundle profile)
                         generateProfiledChildDelegation(slice, relPath, childFieldsWithFixedValue, sliceValidations, ctx);
                     }
                 }
                 else if (childFieldsWithPattern.length > 0) {
-                    generateBackboneElementValidation(slice, relPath, errorPath, sliceLabel, varName, min, fields, childFieldsWithPattern, sliceValidations, ctx.baseResourceType);
+                    generateBackboneElementValidation(slice, relPath, errorPath, sliceLabel, varName, min, fields, childFieldsWithPattern, sliceValidations, ctx.baseResourceType, ctx.profileUrl);
                 }
                 else if (hasBindingCodes) {
                     generateBindingCodesValidation(slice, baseName, relPath, errorPath, sliceLabel, varName, min, minText, fields, sliceValidations);

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

@@ -11,6 +11,32 @@ const FHIRPATH_KEYWORDS = new Set([
     'mod', 'month', 'months', 'not', 'or', 'second', 'seconds', 'true', 'week',
     'weeks', 'xor', 'year', 'years',
 ]);
+/**
+ * A constraint declared on a slice applies only to that slice's members.
+ *
+ * The scope is derived from field.name, which carries no slice identity, so every
+ * slice's invariants were being applied to the whole base element. US Core pins
+ * Practitioner.identifier:NPI to ten digits and :NCSBN to eight, so a conformant
+ * NPI necessarily failed the NCSBN rule and we reported an error HL7 does not.
+ *
+ * Returns a predicate matching the value the slice pins, so the constraint reaches
+ * only its own members. Slices discriminated by something other than a scalar
+ * (a CodeableConcept's coding array, say) yield undefined and are left alone
+ * rather than guessed at.
+ */
+export function buildSliceConstraintFilter(field) {
+    const elementId = field.elementId || '';
+    if (!elementId.split('.').some(segment => segment.includes(':')))
+        return undefined;
+    const pattern = field.patternConstraint;
+    if (!pattern || typeof pattern !== 'object')
+        return undefined;
+    for (const [key, value] of Object.entries(pattern)) {
+        if (typeof value === 'string')
+            return `${key} = '${value.replace(/'/g, "\\'")}'`;
+    }
+    return undefined;
+}
 /**
  * Delimit any keyword segment of a FHIRPath navigation path.
  *

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

@@ -9,34 +9,8 @@ import { buildNestedRequiredValidations, buildFixedValueValidations, buildProhib
 import { buildBindingValidations } from './validatorBindingBuilder.js';
 import { generateBundleRefValidation, generateContainedRefValidation, generateExtensionStructuralValidation, generateAggregationRefValidation, buildReferenceTargetTypeValidation, buildBundleEntryResolution } from './validatorTemplates.js';
 import { HELPER_NAMES } from './validatorRuntime.js';
-import { isBaseElementInvariant, scopeConstraintExpression } from './validatorExpressions.js';
+import { buildSliceConstraintFilter, isBaseElementInvariant, scopeConstraintExpression } from './validatorExpressions.js';
 const log = logger.withTag('validator');
-/**
- * A constraint declared on a slice applies only to that slice's members.
- *
- * The scope is derived from field.name, which carries no slice identity, so every
- * slice's invariants were being applied to the whole base element. US Core pins
- * Practitioner.identifier:NPI to ten digits and :NCSBN to eight, so a conformant
- * NPI necessarily failed the NCSBN rule and we reported an error HL7 does not.
- *
- * Returns a predicate matching the value the slice pins, so the constraint reaches
- * only its own members. Slices discriminated by something other than a scalar
- * (a CodeableConcept's coding array, say) yield undefined and are left alone
- * rather than guessed at.
- */
-function buildSliceConstraintFilter(field) {
-    const elementId = field.elementId || '';
-    if (!elementId.split('.').some(segment => segment.includes(':')))
-        return undefined;
-    const pattern = field.patternConstraint;
-    if (!pattern || typeof pattern !== 'object')
-        return undefined;
-    for (const [key, value] of Object.entries(pattern)) {
-        if (typeof value === 'string')
-            return `${key} = '${value.replace(/'/g, "\\'")}'`;
-    }
-    return undefined;
-}
 /** Coded types whose membership a terminology server can decide. */
 const CODED_BINDING_TYPES = new Set(['code', 'Coding', 'CodeableConcept']);
 /**
@@ -247,7 +221,7 @@ export function generateValidateProfileFunction(interfaceName, fields, valueSets
         valueSetImports, profileUrl, profileName: interfaceName, baseResourceType,
         profileUrlToName, validatorImports, extensionMetadata, profileUrlToType, datatypeProfilePins,
     });
-    const closedSlicingValidations = generateClosedSlicingValidations(fields, profileUrl, baseResourceType);
+    const closedSlicingValidations = generateClosedSlicingValidations(fields, profileUrl, baseResourceType, profileUrlToType);
     const primitiveFormatValidations = buildPrimitiveFormatValidations(fields);
     const structuralTypeValidations = [
         ...buildStructuralTypeValidations(fields, arrayFieldPaths),
@@ -379,8 +353,9 @@ export function generateValidateProfileFunction(interfaceName, fields, valueSets
         // Filter $this on choice-type fields — fhirpath scoping differs from HL7.
         if (c.isChoiceType && /\$this\b/.test(expr))
             return false;
-        // txt-1/txt-2 (htmlChecks) are not filtered: htmlChecks is supplied through
-        // fhirpath's userInvocationTable, and as() over a collection is normalised to
+        // txt-1/txt-2 (htmlChecks) are not filtered: fhirpath.js implements htmlChecks
+        // as of 5.2.0, which the peer range now requires, and as() over a collection is
+        // normalised to
         // ofType() below.
         //
         // dom-3 is implemented natively in generateContainedRefValidation instead.
@@ -522,11 +497,9 @@ ${body}
     // `at`/`arr` are value imports: they replace the `as any` element probing that
     // would otherwise appear throughout the emitted body.
     const optionsImport = 'import type { ValidatorOptions } from \'./ValidatorOptions.js\';\n'
-        + `import { ${HELPER_NAMES.join(', ')}, fhirpathUserFunctions } from './ValidatorOptions.js';\n\n`;
+        + `import { ${HELPER_NAMES.join(', ')} } from './ValidatorOptions.js';\n\n`;
     const fhirpathOptionsLines = [
         '    preciseMath: true,',
-        // Supplies htmlChecks(), which fhirpath.js does not implement.
-        '    userInvocationTable: fhirpathUserFunctions,',
         '    traceFn: options?.traceFn ?? (() => {}),',
         '    ...(options?.signal ? { signal: options.signal } : {}),',
         '    ...(options?.httpHeaders ? { httpHeaders: options.httpHeaders } : {}),',

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

@@ -238,53 +238,6 @@ export function asResource<T>(value: unknown): T {
   return value as T;
 }
 
-/**
- * The XHTML element subset FHIR permits in Narrative.div (R4 Narrative).
- * Anything outside this set — script, style, object, embed, iframe, form,
- * input — is what txt-1 exists to reject.
- */
-const NARRATIVE_ELEMENTS = new Set([
-  'a', 'abbr', 'acronym', 'b', 'bdo', 'big', 'blockquote', 'br', 'caption',
-  'cite', 'code', 'col', 'colgroup', 'dd', 'dfn', 'div', 'dl', 'dt', 'em',
-  'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'hr', 'i', 'img', 'li', 'ol', 'p',
-  'pre', 'q', 'samp', 'small', 'span', 'strong', 'sub', 'sup', 'table',
-  'tbody', 'td', 'tfoot', 'th', 'thead', 'tr', 'tt', 'ul', 'var',
-]);
-
-/** Void elements that carry meaning without text content. */
-const NARRATIVE_VOID_ELEMENTS = /<\\s*(?:img|br|hr)\\b/i;
-
-/**
- * txt-1 / txt-2: the narrative must hold some non-whitespace content and use
- * only the permitted XHTML subset, with no event-handler attributes.
- *
- * fhirpath.js does not implement \`htmlChecks()\`, and an unimplemented function
- * throws out of the whole evaluation, so every profile carrying txt-1 lost all of
- * its findings. Supplying the function is what keeps the invariant evaluated.
- */
-export function narrativeHtmlChecks(values: readonly unknown[]): boolean {
-  for (const value of values) {
-    if (typeof value !== 'string') continue;
 
-    // Only the permitted elements, opening or closing.
-    for (const match of value.matchAll(/<\\s*\\/?\\s*([a-zA-Z][a-zA-Z0-9]*)/g)) {
-      if (!NARRATIVE_ELEMENTS.has(match[1].toLowerCase())) return false;
-    }
-    // No inline event handlers (onclick, onload, …).
-    if (/\\son[a-zA-Z]+\\s*=/.test(value)) return false;
-    // Some non-whitespace content, unless a void element carries it.
-    const text = value.replace(/<[^>]*>/g, '').replace(/&[a-zA-Z#0-9]+;/g, ' ');
-    if (text.trim().length === 0 && !NARRATIVE_VOID_ELEMENTS.test(value)) return false;
-  }
-  return true;
-}
-
-/**
- * FHIRPath functions fhirpath.js lacks, supplied via its userInvocationTable.
- * Passed as \`userInvocationTable\` in the evaluation options.
- */
-export const fhirpathUserFunctions = {
-  htmlChecks: { fn: narrativeHtmlChecks, arity: { 0: [] } },
-};
 `;
 }

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

@@ -1,4 +1,4 @@
-import { stripVersionFromCanonicalUrl } from '../../core/utils.js';
+import { resourceTypeForProfileUrl } from '../../core/utils.js';
 /**
  * Emit the reference target-type check for one profile.
  *
@@ -13,13 +13,6 @@ import { stripVersionFromCanonicalUrl } from '../../core/utils.js';
  * ignores and misses the `urn:uuid:` ones it reports.
  */
 export function buildReferenceTargetTypeValidation(fields, profileUrlToType) {
-    const resolveTargetType = (url) => {
-        const bare = stripVersionFromCanonicalUrl(url);
-        const lastSegment = bare.split('/').pop() || '';
-        if (/^[A-Z][A-Za-z]+$/.test(lastSegment))
-            return lastSegment;
-        return profileUrlToType?.get(bare) ?? profileUrlToType?.get(url);
-    };
     const rows = [];
     const seen = new Set();
     for (const field of fields) {
@@ -33,14 +26,13 @@ export function buildReferenceTargetTypeValidation(fields, profileUrlToType) {
             .flatMap(option => option.targetProfileUrls ?? []);
         if (targets.length === 0)
             continue;
-        const resolved = targets.map(resolveTargetType);
         // An unresolved target, or one permitting any resource, leaves the allowed set
-        // unknown — nothing can be rejected against it.
+        // unknown — nothing can be rejected against it. Both come back undefined from
+        // the shared resolver.
+        const resolved = targets.map(url => resourceTypeForProfileUrl(url, profileUrlToType));
         if (resolved.some(type => !type))
             continue;
         const allowed = [...new Set(resolved)];
-        if (allowed.includes('Resource') || allowed.includes('DomainResource'))
-            continue;
         seen.add(rel);
         rows.push(`    { path: ${JSON.stringify(rel.split('.'))}, allowed: ${JSON.stringify(allowed)} },`);
     }

package/out/src/generator/emitters/zod/zodRefinementBuilder.js

@@ -2,9 +2,9 @@
  * Zod refinement builder for pattern constraints, slice cardinalities, FHIRPath invariants,
  * and required ValueSet bindings.
  */
-import { sanitizeValueSetName } from '../valueset/valueSetGenerator.js';
-import { scopeConstraintExpression } from '../validator/validatorExpressions.js';
-import { stripSliceSuffix, stripVersionFromCanonicalUrl } from '../../core/utils.js';
+import { codeNotInValueSetMessage, codingsNotInValueSetMessage, resolveRequiredBindingValueSet, selectRequiredBindingTargets, } from '../requiredBindings.js';
+import { buildSliceConstraintFilter, isBaseElementInvariant, scopeConstraintExpression } from '../validator/validatorExpressions.js';
+import { stripSliceSuffix } from '../../core/utils.js';
 /** Escape double-quote characters in refinement messages */
 function escStr(s) {
     return s.replace(/"/g, '\\"');
@@ -75,6 +75,14 @@ emitInvariants = false) {
         }
     }
     // 2. Required slice cardinality
+    //
+    // Reaches any depth. This took depth-1 paths only, so a slice on a nested array —
+    // ExplanationOfBenefit.item.adjudication:adjudicationamounttype, required by every
+    // carin-bb EOB profile — was checked by the validator alone. The path is walked with
+    // elementsAt, which flattens every array hop between the root and the sliced
+    // element, and the check is guarded on the outermost segment being present: the
+    // validator skips a missing parent too, leaving its absence to the required-field
+    // checks rather than reporting it twice.
     const slicesByBase = new Map();
     for (const field of allFields) {
         if (!field.sliceName)
@@ -84,47 +92,118 @@ emitInvariants = false) {
             slicesByBase.set(base, []);
         slicesByBase.get(base).push(field);
     }
+    /**
+     * The child a BackboneElement slice is told apart by.
+     *
+     * A slice on a backbone pins its discriminator one level down —
+     * `adjudication:adjudicationamounttype` is identified by `category` — so the pattern
+     * has to be read off the member's child, not the member. Matching the member itself
+     * found nothing and reported a required slice missing on a conformant resource.
+     */
+    const discriminatorChildOf = (slice) => {
+        const sliceId = slice.elementId || slice.name;
+        const children = [];
+        for (const candidate of allFields) {
+            const childId = candidate.elementId || candidate.name;
+            if (!childId.startsWith(sliceId + '.'))
+                continue;
+            const rel = childId.slice(sliceId.length + 1);
+            if (rel.includes('.') || rel.includes(':') || rel.includes('[x]'))
+                continue;
+            children.push({ prop: rel, field: candidate });
+        }
+        // Same order the validator's slice dispatch uses: a pinned value, then a pattern,
+        // then binding codes. Taking the first child that had any of them picked
+        // `identifier.use`, whose binding is not the discriminator, over
+        // `identifier.type`, whose pattern is — and every conformant identifier then
+        // failed to match, so a satisfied slice was reported missing.
+        return children.find(c => c.field.fixedValue !== undefined)
+            ?? children.find(c => !!c.field.patternConstraint)
+            ?? children.find(c => !!c.field.binding?.codes?.length);
+    };
+    /** Codings of the member, or of the child that carries the discriminator. */
+    const memberCodings = (disc) => disc ? `codings(at(item, '${disc}'))` : 'codings(item)';
     for (const [baseName, slices] of slicesByBase) {
         const relPath = baseName.replace(/^[^.]+\./, '');
-        if (relPath.includes('.'))
+        if (!relPath || relPath === baseName)
             continue;
-        if (relPath.includes('[x]'))
+        const segments = relPath.split('.');
+        if (segments.some(segment => segment.includes('[x]') || segment.includes(':')))
             continue;
-        if (!directFieldNames.has(stripSliceSuffix(relPath)))
+        const [firstSegment] = segments;
+        if (!firstSegment || !directFieldNames.has(stripSliceSuffix(firstSegment)))
             continue;
+        const pathLiteral = `[${segments.map(seg => JSON.stringify(seg)).join(', ')}]`;
+        // Present-parent guard, and for depth 1 exactly the Array.isArray check this
+        // section already used.
+        const guard = `!Array.isArray(at(d, '${firstSegment}'))`;
         for (const slice of slices) {
             const min = typeof slice.min === 'number' ? slice.min : (slice.isOptional ? 0 : 1);
             if (min <= 0)
                 continue;
             const sliceLabel = slice.sliceName || 'slice';
+            const message = `Required slice '${escStr(relPath)}:${escStr(sliceLabel)}' not satisfied`;
+            const disc = slice.patternConstraint || slice.binding?.codes?.length
+                ? undefined
+                : discriminatorChildOf(slice);
+            const discProp = disc?.prop;
+            const pattern = (slice.patternConstraint ?? disc?.field.patternConstraint);
+            const bindingCodes = slice.binding?.codes?.length ? slice.binding.codes : disc?.field.binding?.codes;
+            const emit = (predicate) => {
+                refinements.push(`.refine(d => ${guard} || elementsAt(d, ${pathLiteral}).filter((item) => ${predicate}).length >= ${min}, `
+                    + `{ message: "${escStr(message)}", when: () => true })`);
+            };
             // patternCodeableConcept discriminator
-            if (slice.patternConstraint && typeof slice.patternConstraint === 'object' && 'coding' in slice.patternConstraint) {
-                const pattern = slice.patternConstraint;
-                const codings = pattern.coding.filter((c) => c !== null && typeof c === 'object' && 'code' in c);
-                if (codings.length > 0) {
-                    const checks = codings
-                        .map(c => {
-                        return c.system
-                            ? `codings(item).some((cd) => cd.system === "${c.system}" && cd.code === "${c.code}")`
-                            : `codings(item).some((cd) => cd.code === "${c.code}")`;
-                    })
+            if (pattern && typeof pattern === 'object' && 'coding' in pattern) {
+                const patternCodings = pattern.coding.filter((c) => c !== null && typeof c === 'object' && 'code' in c);
+                if (patternCodings.length > 0) {
+                    const checks = patternCodings
+                        .map(c => (c.system
+                        ? `${memberCodings(discProp)}.some((cd) => cd.system === "${c.system}" && cd.code === "${c.code}")`
+                        : `${memberCodings(discProp)}.some((cd) => cd.code === "${c.code}")`))
                         .join(' || ');
-                    refinements.push(`.refine(d => !Array.isArray(at(d, '${relPath}')) || arr(at(d, '${relPath}')).filter((item) => ${checks}).length >= ${min}, { message: "Required slice '${escStr(relPath)}:${escStr(sliceLabel)}' not satisfied", when: () => true })`);
+                    emit(checks);
                 }
             }
             // patternCoding discriminator
-            if (slice.patternConstraint && typeof slice.patternConstraint === 'object' && 'system' in slice.patternConstraint && 'code' in slice.patternConstraint && !('coding' in slice.patternConstraint)) {
-                const pat = slice.patternConstraint;
-                refinements.push(`.refine(d => !Array.isArray(at(d, '${relPath}')) || codings(at(d, '${relPath}')).filter((c) => c.system === "${pat.system}" && c.code === "${pat.code}").length >= ${min}, { message: "Required slice '${escStr(relPath)}:${escStr(sliceLabel)}' not satisfied", when: () => true })`);
+            if (pattern && typeof pattern === 'object' && 'system' in pattern && 'code' in pattern && !('coding' in pattern)) {
+                emit(`${memberCodings(discProp)}.some((cd) => cd.system === "${pattern.system}" && cd.code === "${pattern.code}")`);
+            }
+            // Fixed-value discriminator child: matched by equality, as the validator's
+            // fixed-value slice strategy does.
+            const discFixed = disc?.field.fixedValue;
+            if (!pattern && discProp && discFixed !== undefined
+                && (typeof discFixed === 'string' || typeof discFixed === 'number' || typeof discFixed === 'boolean')) {
+                emit(`at(item, '${discProp}') === ${JSON.stringify(discFixed)}`);
+                continue;
             }
             // Binding codes discriminator
-            if (!slice.patternConstraint && slice.binding?.codes && slice.binding.codes.length > 0) {
-                const codes = slice.binding.codes.map(c => JSON.stringify(c.code));
-                const codesSet = `[${codes.join(', ')}]`;
-                refinements.push(
-                // A binding-discriminated slice member is either a coded element or a
-                // bare code string, so fall back to the member itself.
-                `.refine(d => !Array.isArray(at(d, '${relPath}')) || arr(at(d, '${relPath}')).filter((item) => { const _code = coding(item).code ?? item; return typeof _code === 'string' && ${codesSet}.includes(_code); }).length >= ${min}, { message: "Required slice '${escStr(relPath)}:${escStr(sliceLabel)}' not satisfied", when: () => true })`);
+            if (!pattern && bindingCodes && bindingCodes.length > 0) {
+                if (discProp) {
+                    // The shape the validator emits for a binding-discriminated backbone slice:
+                    // every coding on the discriminator child is considered, and the system is
+                    // part of the match. Reading one coding through coding() and comparing the
+                    // code alone reported total:adjudicationamounttype missing on five carin-bb
+                    // EOB profiles that satisfy it.
+                    const pairs = bindingCodes
+                        .map(c => (c.system
+                        ? `(cd.system === ${JSON.stringify(c.system)} && cd.code === ${JSON.stringify(c.code)})`
+                        : `cd.code === ${JSON.stringify(c.code)}`))
+                        .join(' || ');
+                    emit(`codings(at(item, '${discProp}')).some((cd) => ${pairs})`);
+                }
+                else {
+                    const codesSet = `[${bindingCodes.map(c => JSON.stringify(c.code)).join(', ')}]`;
+                    emit(
+                    // Every coding on the member, which is how the validator matches it
+                    // (`item.coding?.some(...)`). Reading one coding through coding() and then
+                    // falling back to the member itself matched neither a CodeableConcept nor a
+                    // multi-coding Coding, so us-core's Condition reported category:us-core
+                    // missing on a resource that carries problem-list-item. A bare code string
+                    // is still a legal member, hence the second arm.
+                    `codings(item).some((cd) => cd.code !== undefined && ${codesSet}.includes(cd.code)) `
+                        + `|| (typeof item === 'string' && ${codesSet}.includes(item))`);
+                }
             }
         }
     }
@@ -134,16 +213,22 @@ emitInvariants = false) {
         if (!field.constraints || field.constraints.length === 0)
             continue;
         const rel = field.name.replace(/^[^.]+\./, '');
+        // A constraint declared on a slice applies to that slice's members only. Without
+        // the filter, us-core's NCSBN rule — an eight-digit board ID — was evaluated
+        // against every Practitioner.identifier and failed the ten-digit NPI, a violation
+        // the validator does not report because it scopes the same constraint with
+        // `identifier.where(system = '…NCSBNID')`.
+        const sliceFilter = buildSliceConstraintFilter(field);
         for (const c of field.constraints) {
             if (c.severity !== 'error')
                 continue;
-            constraintsWithPath.push({ constraint: c, fieldPath: rel });
+            constraintsWithPath.push({ constraint: c, fieldPath: rel, sliceFilter });
         }
     }
     // Deduplicate by expression + path
     const seen = new Set();
     const uniqueConstraints = constraintsWithPath.filter(c => {
-        const key = `${c.constraint.expression}|${c.fieldPath}`;
+        const key = `${c.constraint.expression}|${c.fieldPath}|${c.sliceFilter ?? ''}`;
         if (seen.has(key))
             return false;
         seen.add(key);
@@ -152,6 +237,7 @@ emitInvariants = false) {
     // Categorize constraints into supported (potentially translatable to JS)
     // and unsupported (require a FHIRPath engine). As we add FHIRPath→JS translation,
     // constraints move from unsupported to supported and get emitted as refinements.
+    const sliceFilters = new Map();
     const unsupportedConstraints = [];
     const supportedConstraints = [];
     for (const c of uniqueConstraints) {
@@ -162,9 +248,15 @@ emitInvariants = false) {
             expression: expr,
             fieldPath: c.fieldPath,
         };
+        sliceFilters.set(`${expr}|${c.fieldPath}`, c.sliceFilter);
         const isUnsupported = /(text\.div\b|\.all\(div\b|\$[A-Z]|value\.[A-Z])/.test(expr) ||
             /\bresolve\b/.test(expr) || /\bmemberOf\b/.test(expr) ||
-            (/\$this\b/.test(expr) && c.fieldPath.includes('[x]'));
+            (/\$this\b/.test(expr) && c.fieldPath.includes('[x]')) ||
+            // ele-1 and ext-1 below the root: the validator drops these at depth, because
+            // fhirpath.js and HL7 disagree on how they evaluate there, and a schema that keeps
+            // them reports a violation the validator never makes — us-core's CarePlan failed on
+            // "All FHIR elements must have a @value or children" from one side only.
+            (c.fieldPath.split('.').length > 1 && isBaseElementInvariant(expr));
         if (isUnsupported) {
             unsupportedConstraints.push(meta);
         }
@@ -188,7 +280,9 @@ emitInvariants = false) {
     supportedConstraints.forEach((meta, i) => {
         if (!emitInvariants)
             return;
-        const scoped = scopeConstraintExpression(meta.expression, meta.fieldPath);
+        const scoped = scopeConstraintExpression(meta.expression, meta.fieldPath, {
+            sliceFilter: sliceFilters.get(`${meta.expression}|${meta.fieldPath}`),
+        });
         if (!scoped)
             return;
         const human = escStr(meta.human).replace(/[\r\n]+/g, ' ');
@@ -224,74 +318,40 @@ emitInvariants = false) {
             refinements.push(`.refine(d => at(d, 'meta', '${subField}') !== undefined, { message: "meta.${subField} must be present", when: () => true })`);
         }
     }
-    // 5. Required ValueSet bindings on CodeableConcept / Coding fields
-    // When a field has binding.strength === 'required' and we have resolved codes,
-    // emit a refinement that checks at least one coding.code is in the allowed set.
-    for (const field of allFields) {
-        const parts = field.name.split('.');
-        if (parts.length !== 2 || parts[0] !== rootPrefix)
-            continue;
-        if (field.sliceName)
-            continue;
-        const type = field.type || field.baseTypeCode || '';
-        if (type !== 'CodeableConcept' && type !== 'Coding')
-            continue;
-        if (field.binding?.strength !== 'required')
-            continue;
-        const rel = parts[1];
-        if (!rel)
-            continue;
-        // Skip choice-type placeholders (code[x], value[x], etc.) — the binding applies
-        // to the resolved variant (e.g. codeCodeableConcept) which we cannot reliably
-        // identify here. Emitting d.code[x] would produce invalid TypeScript.
-        if (rel.includes('[x]'))
-            continue;
-        if (!directFieldNames.has(rel))
+    // 5. Required ValueSet bindings
+    //
+    // Selection, ValueSet resolution and wording all come from ../requiredBindings, the
+    // same module the validator's binding builder uses, so the two sides check the same
+    // elements and phrase the finding identically. This used to take only depth-1
+    // CodeableConcept/Coding fields with the code list inlined, which left every nested
+    // binding — AuditEvent.entity.role, AuditEvent.source.type — reported by the
+    // validator alone.
+    //
+    // The path is walked with elementsAt, which flattens array hops, so a binding under
+    // a repeating backbone is reached the same way the validator reaches it. The code
+    // list is not copied in: the emitted ValueSet module already exports the predicate
+    // both sides call.
+    for (const target of selectRequiredBindingTargets(allFields, rootPrefix)) {
+        const vs = resolveRequiredBindingValueSet(target.field.binding?.uri, valueSets);
+        // A ValueSet with no enumerated concepts is checked against a terminology server
+        // by the validator, which a schema cannot do while parsing. Both stay silent.
+        if (!vs || 'systemOnly' in vs)
             continue;
-        // Resolve codes: prefer field.binding.codes, then fall back to parsed ValueSets
-        let codes;
-        let vsDisplayName = '';
-        if (field.binding.codes && field.binding.codes.length > 0) {
-            codes = field.binding.codes.map(c => c.code);
-            vsDisplayName = field.binding.uri?.split('/').pop() || 'ValueSet';
-        }
-        else if (field.binding.uri && valueSets) {
-            const vsUri = stripVersionFromCanonicalUrl(field.binding.uri);
-            const vs = valueSets.get(vsUri) || valueSets.get(field.binding.uri);
-            if (vs && vs.concepts.length > 0 && vs.concepts.length <= 200) {
-                codes = vs.concepts.map(c => c.code);
-                vsDisplayName = vs.name || vsUri.split('/').pop() || 'ValueSet';
-                // Import the ValueSet type so the codes are available at runtime
-                const sanitizedName = sanitizeValueSetName(vs.name);
-                bindingVsImports.set(sanitizedName, `./valuesets/ValueSet-${sanitizedName}.js`);
-            }
-        }
-        if (!codes || codes.length === 0)
+        bindingVsImports.set(vs.validatorFn, vs.importPath);
+        const pathLiteral = `[${target.path.map(p => JSON.stringify(p)).join(', ')}]`;
+        if (target.kind === 'codings') {
+            const message = codingsNotInValueSetMessage(vs.displayName, vs.uri);
+            refinements.push(`.refine(d => elementsAt(d, ${pathLiteral}).every((_v) => codings(_v).length === 0 `
+                + `|| codings(_v).some((c) => c.code !== undefined && ${vs.validatorFn}(c.code))), `
+                + `{ message: "${escStr(message)}", when: () => true })`);
             continue;
-        const codesLiteral = `[${codes.map(c => JSON.stringify(c)).join(', ')}]`;
-        const msgBase = `None of the codings provided are in the value set '${escStr(vsDisplayName)}' (${escStr(field.binding.uri || '')})`;
-        // `allowed` is a string[], so each candidate code is narrowed to a string
-        // before the lookup rather than asserted through an `any`.
-        const isAllowed = (codeExpr) => `${codeExpr} !== undefined && ${codesLiteral}.includes(${codeExpr})`;
-        if (type === 'CodeableConcept') {
-            if (field.isArray) {
-                // Array of CodeableConcept: each entry must have at least one valid coding
-                refinements.push(`.refine(d => { const _value = at(d, '${rel}'); if (!Array.isArray(_value)) return true; return arr(_value).every((cc) => codings(cc).some((c) => ${isAllowed('c.code')})); }, { message: "${escStr(msgBase)}", when: () => true })`);
-            }
-            else {
-                // Single CodeableConcept: coding must include at least one valid code
-                refinements.push(`.refine(d => { const _value = at(d, '${rel}'); if (!_value) return true; return codings(_value).some((c) => ${isAllowed('c.code')}); }, { message: "${escStr(msgBase)}", when: () => true })`);
-            }
-        }
-        else {
-            // Coding field
-            if (field.isArray) {
-                refinements.push(`.refine(d => { const _value = at(d, '${rel}'); if (!Array.isArray(_value)) return true; return codings(_value).every((c) => ${isAllowed('c.code')}); }, { message: "${escStr(msgBase)}", when: () => true })`);
-            }
-            else {
-                refinements.push(`.refine(d => { const _value = at(d, '${rel}'); if (!_value) return true; const _c = coding(_value); return ${isAllowed('_c.code')}; }, { message: "${escStr(msgBase)}", when: () => true })`);
-            }
         }
+        // A `code` leaf holds the code itself; Quantity and Coding carry it on `.code`.
+        const message = codeNotInValueSetMessage(vs.displayName, vs.uri);
+        refinements.push(`.refine(d => elementsAt(d, ${pathLiteral}).every((_v) => { `
+            + `const _c = typeof _v === "string" ? _v : at(_v, 'code'); `
+            + `return typeof _c !== "string" || ${vs.validatorFn}(_c); }), `
+            + `{ message: "Code ${escStr(message)}", when: () => true })`);
     }
     return { refinements, supportedConstraints, unsupportedConstraints, valueSetImports: bindingVsImports, invariantEvaluators };
 }

package/out/src/generator/emitters/zod/zodSchemaGenerator.js

@@ -12,7 +12,7 @@ import { mergeFields, capitalize, stripSliceSuffix, firstSegment, stripVersionFr
 import { buildRefinements } from './zodRefinementBuilder.js';
 /** Map FHIR primitive types to Zod schema calls */
 /** Runtime helpers a refinement may reference, imported from ValidatorOptions. */
-const ZOD_REFINEMENT_HELPERS = ['at', 'arr', 'coding', 'codings'];
+const ZOD_REFINEMENT_HELPERS = ['at', 'arr', 'coding', 'codings', 'elementsAt'];
 const ZOD_PRIMITIVE_MAP = {
     any: 'z.string()',
     string: 'z.string()',
@@ -262,10 +262,6 @@ emitInvariants = false) {
             lines.push(`import { ${imp}Schema } from "./${imp}.zod.js";`);
         }
     }
-    // Add ValueSet imports
-    for (const [vsTypeName, vsPath] of valueSetImports) {
-        lines.push(`import { ${vsTypeName} } from "${vsPath}";`);
-    }
     // Collect refinements (pattern constraints, slice cardinality, FHIRPath invariants, required bindings)
     // Only emit refinements for Resource profiles (not DataType profiles like Identifier, Coding)
     // because DataType random() methods don't produce pattern-aware data.
@@ -279,6 +275,13 @@ emitInvariants = false) {
             valueSetImports.set(name, importPath);
         }
     }
+    // Emitted after the refinements are built, not before: a binding refinement is what
+    // registers the predicate it calls, and writing the import lines first left every
+    // one of those calls unresolved — the generated schema referenced
+    // isValidHttpVerbCode with no import for it and the package stopped compiling.
+    for (const [vsTypeName, vsPath] of valueSetImports) {
+        lines.push(`import { ${vsTypeName} } from "${vsPath}";`);
+    }
     // Refinements read dynamic property paths through the same runtime helpers the
     // generated validators use, rather than casting the parsed object to `any`.
     // ValidatorOptions.ts is written into every output directory, so the relative
@@ -354,6 +357,17 @@ emitInvariants = false) {
 function buildZodType(field, valueSets, valueSetImports, complexTypeImports, baseTypeImports) {
     // Normalize type through the version rules (e.g. http://hl7.org/fhirpath/System.String → string)
     const rawType = field.type || 'string';
+    // An unstated type stays unconstrained. The parser leaves `any` where the element
+    // declares no type, chiefly a recursive backbone: FHIR writes those with
+    // contentReference and nothing else, so Parameters.parameter.part points back at
+    // Parameters.parameter. mapTypeToTS turns `any` into `string` for the interface
+    // emitter, where it is harmless, and the schema then rejected every conformant
+    // instance — cdex's submit-attachment and mhd's PatchParameters both failed with
+    // `expected string, received object`, a finding the validator never makes because it
+    // knows the type is unknown. Whatever else applies to the element is emitted
+    // separately as a refinement.
+    if (rawType === 'any')
+        return 'z.unknown()';
     const fhirType = getRules().mapTypeToTS(rawType);
     // Only apply ValueSet enum bindings to primitive/code-type fields.
     // Complex types like CodeableConcept/Coding have bindings that constrain

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "babelfhir-ts",
-  "version": "1.6.7",
+  "version": "1.6.8",
   "description": "BabelFHIR-TS: generate TypeScript interfaces, validators, and helper classes from FHIR R4/R4B/R5 StructureDefinitions (profiles) directly inside package archives.",
   "type": "module",
   "main": "out/src/main.js",
@@ -96,7 +96,7 @@
     "@vitest/ui": "^4.1.10",
     "cross-env": "^10.1.0",
     "eslint": "^10.8.0",
-    "fhirpath": "^5.1.0",
+    "fhirpath": "^5.2.0",
     "globals": "^17.9.0",
     "rimraf": "^6.1.3",
     "semver": "^7.8.5",