babelfhir-ts 1.6.10 → 1.6.12

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

@@ -0,0 +1,24 @@
+/**
+ * Canonical-URL string handling, with no dependencies of its own.
+ *
+ * A leaf on purpose. This lived in `utils.ts`, which imports the FHIR version
+ * context, so `constants.ts` calling it pulled the whole generator graph in
+ * behind a config module: constants → utils → versionContext → types →
+ * createRules / fetchUtils → constants. Node evaluates that cycle in an order
+ * that leaves `TS` and `USER_AGENT` uninitialized whenever `constants.ts` is the
+ * entry point, which is exactly what a script importing it directly does — so
+ * `scripts/check-ig-versions.ts` failed on import with `Cannot access 'TS'
+ * before initialization` while the CLI, entered through `main.ts`, was fine.
+ *
+ * Keep this module free of imports so both layers can depend on it.
+ */
+/**
+ * A canonical URL with any version suffix removed:
+ * `http://…/ValueSet/foo|4.0.1` -> `http://…/ValueSet/foo`.
+ */
+export function stripVersionFromCanonicalUrl(url) {
+    if (!url)
+        return url;
+    const pipeIndex = url.indexOf('|');
+    return pipeIndex >= 0 ? url.substring(0, pipeIndex) : url;
+}

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

@@ -6,7 +6,7 @@
  * maintenance trivial.
  */
 import { createRequire } from 'module';
-import { stripVersionFromCanonicalUrl } from './utils.js';
+import { stripVersionFromCanonicalUrl } from './canonicalUrl.js';
 import { fileURLToPath } from 'url';
 import path from 'path';
 const require = createRequire(import.meta.url);

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

@@ -2,18 +2,11 @@ import fs from "fs";
 import path from "path";
 import { logger } from "../../logger.js";
 import { ctx } from '../fhir/versionContext.js';
-/**
- * Strips the version suffix from a FHIR canonical URL.
- * FHIR canonical URLs use '|' to separate the URL from the version.
- * Example: "http://hl7.org/fhir/StructureDefinition/translation|5.3.0-ballot-tc1"
- *       -> "http://hl7.org/fhir/StructureDefinition/translation"
- */
-export function stripVersionFromCanonicalUrl(url) {
-    if (!url)
-        return url;
-    const pipeIndex = url.indexOf('|');
-    return pipeIndex >= 0 ? url.substring(0, pipeIndex) : url;
-}
+// Defined in a leaf module so `constants.ts` can call it without importing this
+// one — see canonicalUrl.ts. Re-exported here because 20+ call sites import it
+// from utils, and used below in this file too.
+import { stripVersionFromCanonicalUrl } from "./canonicalUrl.js";
+export { stripVersionFromCanonicalUrl };
 /**
  * An element path with any slice suffix removed: `identifier:NPI` -> `identifier`.
  *

package/out/src/generator/emitters/class/enrichResourceHandlers.js

@@ -317,11 +317,16 @@ export function generateEnrichResourceEnd() {
       }
     }
 
+    // No display on the RxNorm fallback. 'Amoxicillin 250mg' was paired with
+    // 1049502, which RxNorm defines as an oxycodone product, and the HL7 validator
+    // answered "Wrong Display Name ... Valid display is one of 5 choices". A Coding
+    // without a display is conformant, and an unverifiable display is a liability:
+    // when the binding does resolve, the display comes from the expansion instead.
     // Medication — isik-med-1: code.exists() or ingredient.exists()
     if (/^Medication$/i.test(baseResource)) {
       if (!('code' in base) && !('ingredient' in base)) {
-        const resolved = resolveBindingCode('code', '${TS.RXNORM}', '1049502', 'Amoxicillin 250mg');
-        base.code = resolved || { coding: [{ system: '${TS.RXNORM}', code: '1049502', display: 'Amoxicillin 250mg' }] };
+        const resolved = resolveBindingCode('code', '${TS.RXNORM}', '1049502');
+        base.code = resolved || { coding: [{ system: '${TS.RXNORM}', code: '1049502' }] };
       }
     }
 
@@ -330,8 +335,8 @@ export function generateEnrichResourceEnd() {
       if (!('status' in base)) base.status = 'active';
       if (!('intent' in base)) base.intent = 'order';
       if (!('medicationCodeableConcept' in base) && !('medicationReference' in base)) {
-        const resolved = resolveBindingCode('medicationCodeableConcept', '${TS.RXNORM}', '1049502', 'Amoxicillin 250mg');
-        base.medicationCodeableConcept = resolved || { coding: [{ system: '${TS.RXNORM}', code: '1049502', display: 'Amoxicillin 250mg' }] };
+        const resolved = resolveBindingCode('medicationCodeableConcept', '${TS.RXNORM}', '1049502');
+        base.medicationCodeableConcept = resolved || { coding: [{ system: '${TS.RXNORM}', code: '1049502' }] };
       }
       if (!('subject' in base)) base.subject = { reference: 'Patient/' + randomId() };
       // requester required when intent='order' (us-core-21 constraint)
@@ -342,8 +347,8 @@ export function generateEnrichResourceEnd() {
     if (/MedicationDispense/i.test(baseResource)) {
       if (!('status' in base)) base.status = 'completed';
       if (!('medicationCodeableConcept' in base) && !('medicationReference' in base)) {
-        const resolved = resolveBindingCode('medicationCodeableConcept', '${TS.RXNORM}', '1049502', 'Amoxicillin 250mg');
-        base.medicationCodeableConcept = resolved || { coding: [{ system: '${TS.RXNORM}', code: '1049502', display: 'Amoxicillin 250mg' }] };
+        const resolved = resolveBindingCode('medicationCodeableConcept', '${TS.RXNORM}', '1049502');
+        base.medicationCodeableConcept = resolved || { coding: [{ system: '${TS.RXNORM}', code: '1049502' }] };
       }
       if (!('subject' in base)) base.subject = { reference: 'Patient/' + randomId() };
       if (!('performer' in base)) base.performer = [{ actor: { reference: 'Practitioner/' + randomId() } }];

package/out/src/generator/emitters/class/sliceElementGenerator.js

@@ -4,6 +4,7 @@
  * Extracted helpers live in sliceElementDefaults.ts.
  */
 import { logger } from '../../../logger.js';
+import { ctx } from '../../fhir/versionContext.js';
 import { capitalise, deriveIdentifierConfig } from './classHeuristics.js';
 import { TS, EXAMPLE_ID_SYSTEM, RESOURCE_SKELETONS, compositionSkeleton, bundleEntry, matchSkeletonBySliceName, } from '../../core/constants.js';
 import { getDefaultValueForType, getTypePlaceholder, objectToCodeExpression, } from './sliceElementDefaults.js';
@@ -260,9 +261,14 @@ export function generateSliceElement(slice, elementType) {
                 }
                 const STRUCTURAL_BACKBONE_FIELDS = new Set(['extension', 'modifierExtension', 'part', 'contains']);
                 const rawType = child.type;
-                const effectiveType = (!rawType || rawType === 'any') && STRUCTURAL_BACKBONE_FIELDS.has(childPath)
+                // A child whose own type the differential does not restate still has one in
+                // the base datatype. Falling back to 'string' gave Identifier.system, a uri,
+                // the literal "placeholder", and the HL7 validator rightly answered
+                // "Identifier.system must be an absolute reference, not a local reference".
+                const declaredType = rawType || ctx().dataTypes[elementType]?.[childPath]?.type;
+                const effectiveType = (!declaredType || declaredType === 'any') && STRUCTURAL_BACKBONE_FIELDS.has(childPath)
                     ? 'BackboneElement'
-                    : (rawType || 'string');
+                    : (declaredType || 'string');
                 const placeholder = getTypePlaceholder(effectiveType);
                 if (placeholder !== undefined) {
                     if (!child.isRequired && (placeholder === '{ }' || placeholder === '{}')) {

package/out/src/generator/emitters/prefab/prefabRuntimeAssets.js

@@ -20,7 +20,7 @@ export interface CodeableConceptLike { text?: string; coding?: CodingLike[] }
 export interface ReferenceLike { reference?: string; display?: string; type?: string; identifier?: IdentifierLike }
 export interface QuantityLike { value?: number; unit?: string; code?: string; comparator?: string }
 export interface PeriodLike { start?: string; end?: string }
-export interface IdentifierLike { use?: string; system?: string; value?: string }
+export interface IdentifierLike { use?: string; system?: string; value?: string; type?: CodeableConceptLike }
 export interface AddressLike { line?: string[]; city?: string; state?: string; postalCode?: string; country?: string; text?: string; use?: string }
 export interface ContactPointLike { system?: string; value?: string; use?: string }
 export interface AttachmentLike { contentType?: string; url?: string; data?: string; title?: string }
@@ -30,8 +30,14 @@ export interface RangeLike { low?: QuantityLike; high?: QuantityLike }
 export function formatHumanName(n?: NameLike): string | undefined {
   if (!n) return undefined;
   if (n.text) return n.text;
-  const given = (n.given ?? []).join(' ');
-  const full = [given, n.family].filter(Boolean).join(' ').trim();
+  // prefix and suffix are part of the name, not decoration: dropping them
+  // renders "Jane Doe" for a record that says "Dr. Jane Doe MD".
+  const full = [
+    (n.prefix ?? []).join(' '),
+    (n.given ?? []).join(' '),
+    n.family,
+    (n.suffix ?? []).join(' '),
+  ].filter(Boolean).join(' ').trim();
   return full || undefined;
 }
 
@@ -83,12 +89,17 @@ export function formatQuantity(q?: QuantityLike): string | undefined {
 export function formatPeriod(p?: PeriodLike): string | undefined {
   if (!p) return undefined;
   if (!p.start && !p.end) return undefined;
-  return \`\${p.start ?? '?'} – \${p.end ?? '?'}\`;
+  // An absent end means the period has not closed, which is not the same as
+  // an end nobody recorded.
+  return \`\${p.start ?? '?'} – \${p.end ?? 'ongoing'}\`;
 }
 
 export function formatIdentifier(i?: IdentifierLike): string | undefined {
-  if (!i) return undefined;
-  return i.value || undefined;
+  if (!i?.value) return undefined;
+  // A bare "12345" says nothing next to a second identifier; the type is what
+  // tells the reader which number they are looking at.
+  const label = formatCodeableConcept(i.type);
+  return label ? \`\${label}: \${i.value}\` : i.value;
 }
 
 export function formatAddress(a?: AddressLike): string | undefined {
@@ -237,10 +248,11 @@ import { registerPipe, type PipeFn } from '@maxhealth.tech/prefab';
 const humanName: PipeFn = (value) => {
   const format = (n: unknown): string => {
     if (!n || typeof n !== 'object') return '';
-    const name = n as { text?: string; given?: string[]; family?: string };
+    const name = n as { text?: string; prefix?: string[]; given?: string[]; family?: string; suffix?: string[] };
     if (name.text) return name.text;
-    const given = Array.isArray(name.given) ? name.given.join(' ') : '';
-    return [given, name.family].filter(Boolean).join(' ').trim();
+    const joined = (v: unknown): string => (Array.isArray(v) ? v.join(' ') : '');
+    return [joined(name.prefix), joined(name.given), name.family, joined(name.suffix)]
+      .filter(Boolean).join(' ').trim();
   };
   if (Array.isArray(value)) {
     return value.map(format).filter(Boolean).join(', ');
@@ -273,13 +285,25 @@ const address: PipeFn = (value) => {
   return format(value);
 };
 
-/** Format a single ContactPoint (telecom) into its raw \`value\`. */
+/**
+ * Format a ContactPoint (telecom).
+ *
+ * One contact renders bare, because whatever labels it already says which
+ * system it is. A list mixes systems, so each entry names its own — without it
+ * a phone number and a fax number are two indistinguishable strings.
+ */
 const contactPoint: PipeFn = (value) => {
   const format = (cp: unknown): string => {
     if (!cp || typeof cp !== 'object') return '';
     return String((cp as { value?: unknown }).value ?? '');
   };
-  if (Array.isArray(value)) return value.map(format).filter(Boolean).join(', ');
+  const labelled = (cp: unknown): string => {
+    const val = format(cp);
+    if (!val) return '';
+    const sys = (cp as { system?: unknown }).system;
+    return typeof sys === 'string' && sys ? sys + ': ' + val : val;
+  };
+  if (Array.isArray(value)) return value.map(labelled).filter(Boolean).join(', ');
   return format(value);
 };
 
@@ -294,7 +318,12 @@ const contactPointBySystem: PipeFn = (value, system) => {
     .join(', ');
 };
 
-/** Format ContactPoint[] entries whose \`system\` is neither 'phone' nor 'email'. */
+/**
+ * Format ContactPoint[] entries whose \`system\` is neither 'phone' nor 'email'.
+ *
+ * This is the leftover bucket — fax, pager, url, sms — so each entry names its
+ * system, exactly as a mixed list does above.
+ */
 const contactPointOther: PipeFn = (value) => {
   if (!Array.isArray(value)) return '';
   return value
@@ -302,16 +331,28 @@ const contactPointOther: PipeFn = (value) => {
       const s = cp && (cp as { system?: unknown }).system;
       return typeof s === 'string' && s !== 'phone' && s !== 'email';
     })
-    .map((cp) => String((cp as { value?: unknown }).value ?? ''))
+    .map((cp) => {
+      const val = String((cp as { value?: unknown }).value ?? '');
+      return val ? String((cp as { system?: unknown }).system) + ': ' + val : '';
+    })
     .filter(Boolean)
     .join(', ');
 };
 
-/** Format an Identifier — returns the \`value\` field. */
+/** Format an Identifier as \`type: value\`, or the bare value when untyped. */
 const identifier: PipeFn = (value) => {
   const format = (i: unknown): string => {
     if (!i || typeof i !== 'object') return '';
-    return String((i as { value?: unknown }).value ?? '');
+    const ident = i as {
+      value?: unknown;
+      type?: { text?: string; coding?: Array<{ display?: string; code?: string }> };
+    };
+    const val = String(ident.value ?? '');
+    if (!val) return '';
+    const type = ident.type;
+    const first = type && Array.isArray(type.coding) ? type.coding[0] : undefined;
+    const label = (type && type.text) || (first && (first.display ?? first.code)) || '';
+    return label ? label + ': ' + val : val;
   };
   if (Array.isArray(value)) return value.map(format).filter(Boolean).join(', ');
   return format(value);
@@ -417,7 +458,7 @@ const period: PipeFn = (value) => {
     if (!p || typeof p !== 'object') return '';
     const per = p as { start?: string; end?: string };
     if (!per.start && !per.end) return '';
-    return \`\${per.start ?? '?'} – \${per.end ?? '?'}\`;
+    return \`\${per.start ?? '?'} – \${per.end ?? 'ongoing'}\`;
   };
   if (Array.isArray(value)) return value.map(format).filter(Boolean).join(', ');
   return format(value);

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

@@ -0,0 +1,45 @@
+/**
+ * Invariants declared on an Extension's own StructureDefinition, evaluated against
+ * each matched extension in the resource that carries it.
+ *
+ * The extension profile's own validator already emits these, but that one runs only
+ * when an Extension is validated standalone. A resource embedding the extension
+ * checked that the slice was present and that its value[x] was permitted, and never
+ * evaluated the extension's constraints. KBV_EX_ERP_Multiple_Prescription is the
+ * clear case: "if the flag is true a period must be given" is an invariant on the
+ * extension SD, and the HL7 validator reports it on the containing MedicationRequest
+ * where we reported nothing.
+ *
+ * Split out of sliceExtensionValidation.ts to keep that file under the 650 LOC gate.
+ */
+/**
+ * Emit the invariant checks for one matched-extension list.
+ *
+ * Returns '' when the extension declares nothing worth checking, so callers can
+ * concatenate unconditionally.
+ */
+export function generateExtensionInvariantChecks(matchedArrayVar, extensionUrl, extMeta, ctx, indent) {
+    const constraints = extMeta?.constraints;
+    if (!constraints || constraints.length === 0)
+        return '';
+    // The fhirpath import is gated on the profile's own constraint list, so a profile
+    // that declares none would reference an undeclared `fhirpath` binding here.
+    if (ctx?.fhirpathNeeded)
+        ctx.fhirpathNeeded.value = true;
+    const lines = [];
+    lines.push(`${indent}// Invariants declared on extension ${extensionUrl}`);
+    lines.push(`${indent}for (const _invExt of ${matchedArrayVar}) {`);
+    for (const c of constraints) {
+        // Evaluated against the extension element rather than the resource: the
+        // expressions are written against Extension, exactly as the extension's own
+        // validator evaluates them.
+        lines.push(`${indent}  const _inv${c.key.replace(/[^A-Za-z0-9]/g, '_')} = await fhirpath.evaluate(`
+            + `node(_invExt), ${JSON.stringify(c.expression)}, `
+            + `{ resource, rootResource: resource }, fhirpath_model, fhirpathOptions);`);
+        lines.push(`${indent}  if (!_inv${c.key.replace(/[^A-Za-z0-9]/g, '_')}.every(Boolean)) {`);
+        lines.push(`${indent}    errors.push(${JSON.stringify(`Constraint violation: ${c.human}`)});`);
+        lines.push(`${indent}  }`);
+    }
+    lines.push(`${indent}}`);
+    return '\n' + lines.join('\n');
+}

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

@@ -1,6 +1,7 @@
 /**
  * Extension and ValueSet slice validation strategies.
  */
+import { generateExtensionInvariantChecks } from './extensionInvariants.js';
 import { safeAccessor, safeList, sliceElseBranch, detectNestedArray, findArrayAncestor, isArrayPath, FHIR_PRIMITIVE_STRING_TYPES } from './sliceValidatorUtils.js';
 import { stripVersionFromCanonicalUrl, stripSliceSuffix } from '../../core/utils.js';
 import { buildSubExtensionScope, renderScopeHops } from './subExtensionScope.js';
@@ -517,7 +518,7 @@ ${indent}  if (_forbidden) {
 ${indent}    errors.push("Extension.value[x]: max allowed = 0, but found 1 (${forbidUrl})");
 ${indent}    errors.push("The Extension '${extensionUrl}' definition allows for the types [] but found type " + _forbidden.slice(5));
 ${indent}  }${generateSubExtensionChecks(extMeta, ctx, indent + '  ')}
-${indent}}`;
+${indent}}${generateExtensionInvariantChecks(matchedArrayVar, extensionUrl, extMeta, ctx, indent)}`;
     }
     const lines = [];
     const allowedProps = extMeta.valueTypes.map(t => `"value${valuePropertySuffix(t)}"`);
@@ -575,5 +576,6 @@ ${indent}}`;
         }
     }
     lines.push(`${indent}}`);
-    return '\n' + lines.join('\n');
+    return '\n' + lines.join('\n')
+        + generateExtensionInvariantChecks(matchedArrayVar, extensionUrl, extMeta, ctx, indent);
 }

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

@@ -216,10 +216,15 @@ export function generateValidateProfileFunction(interfaceName, fields, valueSets
             isChoiceType: false,
         });
     });
+    // Slice code can need fhirpath on its own: an extension's invariants are evaluated
+    // against each matched extension, and the profile carrying it need not declare a
+    // constraint of its own.
+    const fhirpathNeeded = { value: false };
     const sliceValidations = generateSliceValidations({
         fields, fieldPathMap, arrayFieldPaths, getValueSetForBinding,
         valueSetImports, profileUrl, profileName: interfaceName, baseResourceType,
         profileUrlToName, validatorImports, extensionMetadata, profileUrlToType, datatypeProfilePins,
+        fhirpathNeeded,
     });
     const closedSlicingValidations = generateClosedSlicingValidations(fields, profileUrl, baseResourceType, profileUrlToType);
     const primitiveFormatValidations = buildPrimitiveFormatValidations(fields);
@@ -491,7 +496,7 @@ ${body}
         const expr = c.constraint.expression || '';
         return /\bmemberOf\b/.test(expr) || /\bresolve\b/.test(expr);
     });
-    const fhirpathImport = filteredConstraints.length > 0
+    const fhirpathImport = filteredConstraints.length > 0 || fhirpathNeeded.value
         ? `import fhirpath from "fhirpath";\nimport fhirpath_model from "fhirpath/fhir-context/${fhirpathModelSlug()}/index.js";\n`
         : '';
     // `at`/`arr` are value imports: they replace the `as any` element probing that

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

@@ -263,12 +263,17 @@ emitInvariants = false) {
         }
     }
     // 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.
-    const isDataTypeProfile = getZodPackageTypes().has(rootPrefix);
-    const refinementResult = isDataTypeProfile
-        ? { refinements: [], supportedConstraints: [], unsupportedConstraints: [], valueSetImports: new Map(), invariantEvaluators: [] }
-        : buildRefinements(allFields, rootPrefix, valueSets, emitInvariants);
+    //
+    // Emitted for DataType profiles too, Extension among them. They used to be skipped
+    // wholesale because "DataType random() methods don't produce pattern-aware data" —
+    // a property of the test fixtures, deciding what conformance rules a shipped
+    // schema enforces. The cost was that an Extension profile's zod schema checked its
+    // fixed url and nothing else: sdc's AssembleExpectation carries a required binding
+    // to the assemble-expectation ValueSet, validate() enforced it, and the schema
+    // accepted any code at all. Over a hundred profiles disagreed that way, and the
+    // disagreement was recorded as a parity failure rather than as the missing check
+    // it was.
+    const refinementResult = buildRefinements(allFields, rootPrefix, valueSets, emitInvariants);
     // Merge ValueSet imports from binding refinements
     for (const [name, importPath] of refinementResult.valueSetImports) {
         if (!valueSetImports.has(name)) {

package/out/src/generator/fhir/createRules.js

@@ -10,7 +10,6 @@
  * are genuinely identical across R4 / R4B / R5 so they live here as shared
  * constants.
  */
-import { TS } from '../core/constants.js';
 // ── Shared constants (version-independent) ──────────────────────────────────
 /** FHIR primitive type → TypeScript type mapping (same for R4/R4B/R5). */
 const PRIMITIVE_MAP = {
@@ -46,8 +45,6 @@ export const VALUESET_THRESHOLDS = {
     UNION_TYPE: 20,
     STORE_CODES: 50,
 };
-/** Re-export centralized terminology systems for backward compatibility. */
-export const FHIR_TERMINOLOGY_SYSTEMS = TS;
 // ── Cardinality / child-type helpers ────────────────────────────────────────
 /**
  * Fields whose `use` / `type` properties are enum codes that should *not*

package/out/src/generator/fhir/createRules.ts

@@ -13,7 +13,6 @@
 
 import type { FhirRules } from './types.js';
 import type { DerivedVersionData } from './corePackageResolver.js';
-import { TS } from '../core/constants.js';
 
 // ── Shared constants (version-independent) ──────────────────────────────────
 
@@ -54,9 +53,6 @@ export const VALUESET_THRESHOLDS = {
   STORE_CODES: 50,
 } as const;
 
-/** Re-export centralized terminology systems for backward compatibility. */
-export const FHIR_TERMINOLOGY_SYSTEMS = TS;
-
 // ── Cardinality / child-type helpers ────────────────────────────────────────
 
 /**

package/out/src/generator/sdProcessor.js

@@ -21,6 +21,7 @@ import { ctx as versionCtx, fhirModuleSpecifier } from './fhir/versionContext.js
 import { registerProfile, addDiagnostic } from './core/sdDiagnostics.js';
 import { resetFetchFailureTracking, getFetchFailureCount, getFetchFailureWarning, recordFetchFailure, resolveComplexTypeChildType, ensureRandomSupportFile, ensureValidatorOptionsFile, } from './sdProcessorHelpers.js';
 import { extractAndDeduplicateRequiredFields, resolveChoiceSegments } from './sdProcessorRequiredFields.js';
+import { isBaseElementInvariant } from './emitters/validator/validatorExpressions.js';
 // Re-export public API consumed by index.ts / generationHelpers.ts
 export { resetFetchFailureTracking, getFetchFailureCount, getFetchFailureWarning };
 const log = logger.withTag('generator');
@@ -194,6 +195,52 @@ async function fillSliceProfileUrlsFromBaseProfiles(fields, baseDefinition) {
  * DTRStdQuestionnaire's contextExpression emitted no validation at all.
  * Callers must strip before reading; use `lookupExtensionMetadata`.
  */
+/**
+ * Invariants on an Extension SD, minus the ones the emitted validator handles
+ * elsewhere or evaluates differently from HL7.
+ *
+ * ext-1 is already checked structurally by the extension slice code, and ele-1
+ * diverges between fhirpath.js and HL7, so both are dropped here for the same
+ * reasons validatorGenerator drops them from a profile's own constraint list.
+ */
+function readExtensionConstraints(extSd) {
+    const els = extensionElements(extSd);
+    if (!els)
+        return undefined;
+    const out = [];
+    const seen = new Set();
+    for (const el of els) {
+        // Only invariants on the Extension root apply to the extension as a whole.
+        const path = el.path;
+        if (path !== 'Extension')
+            continue;
+        for (const c of (el.constraint ?? [])) {
+            const { key, human, expression, severity } = c;
+            if (!key || !human || !expression)
+                continue;
+            if (severity && severity !== 'error')
+                continue;
+            // By key first, because these are restated with local variations that defeat
+            // matching on the expression: the subscriptions-backport extensions write ele-1
+            // as `hasValue() or (children().count() > id.count()) or $this is Parameters`,
+            // and isBaseElementInvariant anchors its pattern, so the suffix slipped through
+            // and every backport extension reported ele-1 on its Subscription.
+            if (key === 'ele-1' || key === 'ext-1')
+                continue;
+            if (isBaseElementInvariant(expression))
+                continue;
+            if (/text\.div/.test(expression))
+                continue;
+            if (/\$[A-Z]/.test(expression))
+                continue;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            out.push({ key, human, expression });
+        }
+    }
+    return out.length > 0 ? out : undefined;
+}
 async function resolveExtensionMetadata(fields) {
     const extUrls = new Set();
     for (const f of fields) {
@@ -220,6 +267,10 @@ async function resolveExtensionMetadata(fields) {
             const valueEl = els.find(el => el.path === 'Extension.value[x]' || el.id === 'Extension.value[x]');
             const subExtensions = collectSubExtensionSlices(els);
             const subExtensionMin = readSubExtensionMin(els);
+            // Read before the branching below: a complex extension returns early, and its
+            // invariants are exactly the ones worth carrying (Mehrfachverordnung's
+            // "if the flag is true a period is required" lives on such an SD).
+            const constraints = readExtensionConstraints(extSd);
             // A complex extension carries sub-extensions instead of a value, and forbids a
             // value outright (ext-1: extension.exists() != value.exists()). Recorded as an
             // empty type list — different from no entry at all, which would mean the SD
@@ -235,6 +286,7 @@ async function resolveExtensionMetadata(fields) {
                     valueTypes: [],
                     subExtensionMin,
                     subExtensions: subExtensions.length ? subExtensions : undefined,
+                    constraints,
                 });
                 return;
             }
@@ -243,7 +295,7 @@ async function resolveExtensionMetadata(fields) {
             const types = (valueEl.type || []).map((t) => t.code).filter(Boolean);
             if (types.length === 0)
                 return;
-            const entry = { valueTypes: types };
+            const entry = { valueTypes: types, constraints };
             // Check binding on value[x] first, then fall back to typed slices
             // (e.g., Extension.valueCode may carry the binding instead of Extension.value[x])
             let binding = readBinding(valueEl);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "babelfhir-ts",
-  "version": "1.6.10",
+  "version": "1.6.12",
   "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",
@@ -86,32 +86,32 @@
   },
   "devDependencies": {
     "@eslint/js": "^10.0.1",
-    "@max-health-inc/config": "^3.1.0",
+    "@max-health-inc/config": "^3.3.0",
     "@maxhealth.tech/prefab": "^0.3.12",
-    "@types/node": "^25.9.5",
+    "@types/node": "^26.4.0",
     "@types/semver": "^7.8.0",
     "@types/unzipper": "^0.10.11",
-    "@vitest/coverage-v8": "^4.1.10",
-    "@vitest/eslint-plugin": "^1.6.26",
-    "@vitest/ui": "^4.1.10",
+    "@vitest/coverage-v8": "^4.1.11",
+    "@vitest/eslint-plugin": "^1.6.27",
+    "@vitest/ui": "^4.1.11",
     "cross-env": "^10.1.0",
-    "eslint": "^10.8.0",
+    "eslint": "^10.9.1",
     "fhirpath": "^5.2.0",
-    "globals": "^17.9.0",
+    "globals": "^17.11.0",
     "rimraf": "^6.1.3",
     "semver": "^7.8.5",
     "typescript": "^6.0.3",
-    "typescript-eslint": "^8.66.0",
+    "typescript-eslint": "^8.68.0",
     "vitepress": "^1.6.4",
-    "vitepress-plugin-llms": "^1.13.4",
-    "vitest": "^4.1.10",
-    "zod": "4.3.6"
+    "vitepress-plugin-llms": "^1.13.5",
+    "vitest": "^4.1.11",
+    "zod": "4.4.3"
   },
   "dependencies": {
     "@types/fhir": "^0.0.44",
     "consola": "^3.4.2",
     "tar": "^7.5.22",
-    "tsx": "^4.23.7",
+    "tsx": "^4.23.12",
     "unzipper": "^0.12.5"
   },
   "overrides": {