babelfhir-ts 1.5.21 → 1.6.0

package/README.md

@@ -61,9 +61,9 @@ Every push to `develop` and `main` runs the parity pipeline, which validates gen
 4. Generates `empty()` and `random()` test resources for every profile
 5. Validates those resources against two independent external FHIR validators
 
-### Validated Implementation Guides (30)
+### Validated Implementation Guides (31)
 
-Every parity run validates **30 real-world IGs** (28 R4, 2 R5). The list is not duplicated here — it is generated from the parity suite's own source of truth into [`parity-matrix.json`](./parity-matrix.json).
+Every parity run validates **31 real-world IGs** (29 R4, 2 R5). The list is not duplicated here — it is generated from the parity suite's own source of truth into [`parity-matrix.json`](./parity-matrix.json).
 
 Each validated IG is also published as a ready-to-install package — `@max-health-inc/fhir-<name>` — so you do not have to generate it yourself:
 
@@ -111,6 +111,7 @@ The `firely` job validates generated resources using the [Firely SDK Validator](
 ![AU Core (Australia)](https://img.shields.io/endpoint?url=https://max-health-inc.github.io/BabelFHIR-TS/badges/badge-au-core.json)
 ![PIXm](https://img.shields.io/endpoint?url=https://max-health-inc.github.io/BabelFHIR-TS/badges/badge-pixm.json)
 ![MHD](https://img.shields.io/endpoint?url=https://max-health-inc.github.io/BabelFHIR-TS/badges/badge-mhd.json)
+![vitals](https://img.shields.io/endpoint?url=https://max-health-inc.github.io/BabelFHIR-TS/badges/badge-vitals.json)
 
 </details>
 
@@ -148,10 +149,11 @@ The `hl7` job validates the same artifacts using the [official HL7 FHIR Validato
 ![AU Core (Australia)](https://img.shields.io/endpoint?url=https://max-health-inc.github.io/BabelFHIR-TS/badges/badge-hl7-au-core.json)
 ![PIXm](https://img.shields.io/endpoint?url=https://max-health-inc.github.io/BabelFHIR-TS/badges/badge-hl7-pixm.json)
 ![MHD](https://img.shields.io/endpoint?url=https://max-health-inc.github.io/BabelFHIR-TS/badges/badge-hl7-mhd.json)
+![vitals](https://img.shields.io/endpoint?url=https://max-health-inc.github.io/BabelFHIR-TS/badges/badge-hl7-vitals.json)
 
 </details>
 
-> External-validator badges cover the 28 R4/R4B IGs. R5 packages are generated and typechecked, but neither external validator publishes R5 badges yet.
+> External-validator badges cover the 29 R4/R4B IGs. R5 packages are generated and typechecked, but neither external validator publishes R5 badges yet.
 
 > Terminology validation requires a tx server. The pipeline uses `--tx-server https://tx.fhir.org/{r4|r5}` (matching the package's FHIR version) during generation to expand ValueSets and produce valid codes.
 
@@ -223,6 +225,7 @@ Options:
   --no-classes             Only generate interfaces and types (skip class generation)
   --no-client              Skip FHIR client generation (client generated by default)
   --schema <format>        Generate schema files alongside outputs (supported: zod)
+  --zod-invariants         Emit FHIRPath invariants into Zod schemas (fuller checking, slower parse)
   --dicomweb               Generate DICOMweb helpers typed to ImagingStudy profiles in the IG
   --prefab                 Generate Prefab UI render functions per profile (@maxhealth.tech/prefab)
   --prefab-styles <path>   Path to styles module (.ts/.js) copied into the generated prefab/ folder

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

@@ -9,6 +9,7 @@
  * binding, while KBV_EX_ERP_PracticeSupply_Payor binds it required to
  * KBV_VS_FOR_Payor_type.
  */
+import { stripVersionFromCanonicalUrl } from './utils.js';
 /** `Extension.extension:<name>` with no further path below it. */
 const SUB_SLICE_ID = /^Extension\.extension:([^.:]+)$/;
 /**
@@ -32,7 +33,7 @@ export function readBinding(el) {
         : binding.valueSet?.reference;
     if (!raw)
         return undefined;
-    return { strength: binding.strength, uri: raw.split('|')[0] };
+    return { strength: binding.strength, uri: stripVersionFromCanonicalUrl(raw) };
 }
 /** Type codes declared on an element. */
 function typeCodes(el) {

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

@@ -14,6 +14,33 @@ export function stripVersionFromCanonicalUrl(url) {
     const pipeIndex = url.indexOf('|');
     return pipeIndex >= 0 ? url.substring(0, pipeIndex) : url;
 }
+/**
+ * An element path with any slice suffix removed: `identifier:NPI` -> `identifier`.
+ *
+ * FHIR element ids name the slice after a colon, and most path comparisons want
+ * the unsliced form. Written with indexOf rather than `split(':')[0]` so it
+ * 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.
+ */
+export function stripSliceSuffix(path) {
+    if (!path)
+        return path;
+    const colonIndex = path.indexOf(':');
+    return colonIndex >= 0 ? path.substring(0, colonIndex) : path;
+}
+/**
+ * The first dot-separated segment of a path: `code.coding.system` -> `code`.
+ *
+ * indexOf rather than `split('.')[0]`, for the same reason as
+ * {@link stripSliceSuffix}: the split form is an indexing expression and reads as
+ * possibly-undefined even when it cannot be.
+ */
+export function firstSegment(path) {
+    if (!path)
+        return path;
+    const dotIndex = path.indexOf('.');
+    return dotIndex >= 0 ? path.substring(0, dotIndex) : path;
+}
 export function writeInterfaceAndValidatorToFile(outputDir, interfaceName, interfaceContent, validateFunctionContent) {
     const filePath = path.join(outputDir, `${interfaceName}.ts`);
     const content = `${interfaceContent}\n\n${validateFunctionContent}`;
@@ -331,6 +358,48 @@ export function sanitizeIdentifier(name) {
         cleaned = `_${cleaned}`;
     return cleaned;
 }
+/**
+ * Turn a FHIR resource name into a PascalCase TypeScript identifier.
+ *
+ * Shared by the ValueSet and NamingSystem emitters, which previously carried
+ * the same split-and-capitalize loop with only the digit prefix differing.
+ * {@link toPascalCase} alone is not enough: it drops the underscore that
+ * {@link sanitizeIdentifier} adds, so a name starting with a digit comes back
+ * as an invalid identifier.
+ */
+export function pascalCaseIdentifier(name, opts) {
+    const stripped = opts.stripPrefix ? name.replace(opts.stripPrefix, '') : name;
+    const pascal = toPascalCase(stripped);
+    if (!pascal)
+        return opts.fallback;
+    return /^[0-9]/.test(pascal) ? `${opts.digitPrefix}${pascal}` : pascal;
+}
+/**
+ * Lower-case a name's first character, keeping a leading acronym run intact.
+ *
+ *   "CHCorePatient" → "chCorePatient"   (the acronym lowers wholesale, but the
+ *                                        last capital starts the next word)
+ *   "Patient"       → "patient"
+ *   "HumanName"     → "humanName"
+ *
+ * Shared by the prefab renderer and the MCP view registry, which each carried a
+ * byte-identical copy — the second one commented "Mirrors the same logic in
+ * prefabRenderer.ts", which is the drift warning rather than a defence.
+ *
+ * charAt() is deliberate over indexing: it yields '' past the end, so the
+ * acronym run terminates at the boundary without an index assertion.
+ */
+export function lowerFirstPreservingAcronym(name) {
+    if (!name)
+        return name;
+    let i = 0;
+    while (i < name.length && name.charAt(i) >= 'A' && name.charAt(i) <= 'Z')
+        i++;
+    if (i <= 1)
+        return name.charAt(0).toLowerCase() + name.slice(1);
+    const acronymEnd = i === name.length ? i : i - 1;
+    return name.slice(0, acronymEnd).toLowerCase() + name.slice(acronymEnd);
+}
 export function toPascalCase(name) {
     if (!name)
         return name;

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

@@ -95,8 +95,16 @@ export function generatePatternMetadata(fieldPatterns, forbiddenFields, valueSet
     }
     const hasBindings = Object.keys(valueSetBindings).length > 0;
     return `
-  /** Pattern constraints for profile fields (used by random() generator) */
-  protected static readonly _fieldPatterns = ${JSON.stringify(patternMap, null, 2)};
+  /**
+   * Pattern constraints this profile fixes on its fields, keyed by field path
+   * (e.g. \`"shlSession.system": "https://example.org/fhir/shl-session"\`).
+   *
+   * Public alongside \`valueSetBindings\`: a consumer that needs a fixed value —
+   * an identifier system, a fixed code — would otherwise hand-write the literal
+   * the profile already declares, which is the duplication this package exists
+   * to remove. Read by the random() generator too.
+   */
+  static readonly _fieldPatterns = ${JSON.stringify(patternMap, null, 2)};
 
   /** Fields that are forbidden (max=0) in this profile - must not be generated */
   protected static readonly _forbiddenFields: string[] = ${JSON.stringify(forbiddenFields)};

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

@@ -252,6 +252,13 @@ export function buildNestedRequirementsObject(nestedRequirements) {
         // Navigate/create nested objects for all but the last part
         for (let i = 0; i < parts.length - 1; i++) {
             const part = parts[i];
+            // The loop bound guarantees a segment here; if one is ever missing the
+            // requirement is abandoned rather than navigated halfway, which is the same
+            // course the non-object branch below takes.
+            if (part === undefined) {
+                skipThis = true;
+                break;
+            }
             const isArraySegment = allArraySegments.has(parts.slice(0, i + 1).join('.'));
             if (!(part in current)) {
                 // Create either an array with one object or a plain object
@@ -290,7 +297,9 @@ export function buildNestedRequirementsObject(nestedRequirements) {
             continue;
         }
         // Set the final value
-        const lastPart = parts[parts.length - 1];
+        const lastPart = parts.at(-1);
+        if (lastPart === undefined)
+            continue;
         // If this property already exists and is an object with properties, merge instead of overwrite
         const existingValue = current[lastPart];
         const hasExplicitConstraint = req.patternConstraint !== undefined || req.fixedValue !== undefined;

package/out/src/generator/emitters/interface/interfaceFieldProcessor.js

@@ -1,4 +1,4 @@
-import { capitalize, choicePropertyName, narrowedChoiceType, sanitizeIdentifier, toPascalCase, stripVersionFromCanonicalUrl } from '../../core/utils.js';
+import { capitalize, choicePropertyName, narrowedChoiceType, sanitizeIdentifier, toPascalCase, stripVersionFromCanonicalUrl, stripSliceSuffix } from '../../core/utils.js';
 import { sanitizeValueSetName } from '../valueset/valueSetGenerator.js';
 import { logger } from '../../../logger.js';
 import { getRules } from '../../fhir/versionContext.js';
@@ -45,8 +45,8 @@ export function processFields(ctx, fields, parentInterfaceName, parentFieldType,
         }
         // Register external profiles for FHIR datatype profiles (like SimpleQuantity) early
         // This must happen before any returns to ensure the profile is registered
-        if (field.isProfiled && field.profileUrls && field.profileUrls.length > 0) {
-            const profileUrl = field.profileUrls[0];
+        const profileUrl = field.isProfiled ? field.profileUrls?.[0] : undefined;
+        if (profileUrl) {
             // Use profileUrlToName to get the actual interface name, fallback to URL-derived name
             // Strip version suffix from canonical URL (e.g., |5.3.0-ballot-tc1) before extracting name
             const strippedUrl = stripVersionFromCanonicalUrl(profileUrl);
@@ -61,13 +61,9 @@ export function processFields(ctx, fields, parentInterfaceName, parentFieldType,
             }
         }
         const fieldParts = field.name.split(".");
-        let fieldName = fieldParts[fieldParts.length - 1];
-        // Remove slice notation (e.g., "extension:Stadtteil" -> "extension") for property names
-        // The slice name is preserved in field.sliceName for semantic purposes
-        const colonIndex = fieldName.indexOf(':');
-        if (colonIndex !== -1) {
-            fieldName = fieldName.substring(0, colonIndex);
-        }
+        // Slice notation is dropped for the property name ("extension:Stadtteil"
+        // -> "extension"); field.sliceName keeps it for semantic purposes.
+        let fieldName = stripSliceSuffix(fieldParts.at(-1) ?? field.name);
         const isRootInterface = parentInterfaceName === interfaceName;
         const isNested = isRootInterface ? fieldParts.length > 1 : fieldParts.length >= 1;
         // When generating a slice-specific interface, only include direct children
@@ -126,7 +122,7 @@ export function processFields(ctx, fields, parentInterfaceName, parentFieldType,
         // (2 segments: Identifier.system) and skip nested paths (4+ segments: Identifier.assigner.identifier.system)
         if (isNested && fieldParts.length >= 2) {
             const baseTypeName = fieldParts[0]; // e.g., "Identifier" from "Identifier.assigner.identifier.system"
-            const isExtendingBaseType = baseResource && baseTypeName.toLowerCase() === baseResource.toLowerCase();
+            const isExtendingBaseType = !!baseResource && baseTypeName?.toLowerCase() === baseResource.toLowerCase();
             // Check if this field will create a nested interface (has children in fields)
             const hasChildren = fields.some((f) => f.name.startsWith(field.name + '.'));
             const shouldKeepForNested = field.mustSupport && hasChildren;
@@ -173,7 +169,8 @@ export function processFields(ctx, fields, parentInterfaceName, parentFieldType,
             }
             else if (!isLogicalModel) {
                 // For other profiles, use the original logic
-                if (!parentInterfaceName.toLowerCase().includes(fieldParts[fieldParts.length - 2].toLowerCase())) {
+                const parentSegment = fieldParts.at(-2);
+                if (!parentSegment || !parentInterfaceName.toLowerCase().includes(parentSegment.toLowerCase())) {
                     return; // Skip nested fields that don't match the parent interface name
                 }
             }
@@ -529,7 +526,13 @@ export function processFields(ctx, fields, parentInterfaceName, parentFieldType,
                 deduped.push(line); // JSDoc or other non-field lines
                 continue;
             }
+            // Group 1 is present whenever the regex matched, but the type does not
+            // say so; a line without it is passed through rather than deduped.
             const name = fieldMatch[1];
+            if (!name) {
+                deduped.push(line);
+                continue;
+            }
             if (seenFieldNames.has(name)) {
                 continue; // Skip duplicate — keep the first (more specific) version
             }

package/out/src/generator/emitters/interface/interfaceFieldUtils.js

@@ -26,11 +26,14 @@ export function canonicalToTypeName(name, profileUrlToName) {
                 matches.add(generatedName);
             }
         }
-        if (matches.size === 1)
-            return [...matches][0];
+        if (matches.size === 1) {
+            const [only] = [...matches];
+            if (only)
+                return only;
+        }
     }
     // if already a valid identifier with capitalization, return as-is
-    if (/^[A-Za-z_][A-Za-z0-9_]*$/.test(t) && /[A-Z]/.test(t[0]))
+    if (/^[A-Za-z_][A-Za-z0-9_]*$/.test(t) && /^[A-Z]/.test(t))
         return t;
     const parts = t.split(/[^A-Za-z0-9]+/).filter(Boolean);
     let pascal = parts.map(p => p.charAt(0).toUpperCase() + p.slice(1)).join('');

package/out/src/generator/emitters/interface/postProcessExtensions.js

@@ -300,9 +300,15 @@ export function postProcessExtensions(params) {
             });
             const baseFld2 = baseFieldByLastSegment.get(seg2);
             let extendT2 = actualField2?.type || baseFld2?.type;
-            // Fallback to specific mappings if needed
+            // A generic BackboneElement carries none of the base backbone's own properties, so
+            // resolve it against the level-1 backbone already resolved above
+            // (QuestionnaireResponseItem + 'answer' -> QuestionnaireResponseItemAnswer).
             if (!extendT2 || extendT2 === 'any' || extendT2 === 'BackboneElement') {
-                if (baseResource === 'Encounter' && seg1 === 'hospitalization' && seg2 === 'dischargeDisposition') {
+                const inferred2 = extendT1 ? inferBackboneType(extendT1, seg2) : undefined;
+                if (inferred2) {
+                    extendT2 = inferred2;
+                }
+                else if (baseResource === 'Encounter' && seg1 === 'hospitalization' && seg2 === 'dischargeDisposition') {
                     extendT2 = 'CodeableConcept';
                 }
             }

package/out/src/generator/emitters/interface/processNestedField.js

@@ -175,12 +175,10 @@ export function handleNestedField(args) {
         }
         else {
             // No nested interface existed; create a minimal one extending the base/inferred type to host the extension union
-            let parentT = baseFieldByLastSegment.get(fieldName)?.type || field.type;
-            if (!parentT || parentT === 'any') {
-                const inferred = inferBackboneType(baseResource, fieldName);
-                if (inferred)
-                    parentT = inferred;
-            }
+            // Reuse the type resolved above rather than recomputing it: the local
+            // recomputation used to stop at a generic BackboneElement, which drops the
+            // base backbone's own properties (e.g. QuestionnaireResponseItem.linkId).
+            let parentT = baseFieldType;
             if (parentT && !isPrimitiveType(parentT)) {
                 parentT = canonicalToTypeName(parentT);
                 const sanitized = sanitizeIdentifier(parentT);

package/out/src/generator/emitters/namingsystem/namingSystemGenerator.js

@@ -0,0 +1,136 @@
+/**
+ * NamingSystem Generator
+ *
+ * Emits a `namingsystems/` module mirroring `valuesets/`, so an IG's declared
+ * identifier systems are consumable as typed constants instead of retyped as
+ * string literals in every downstream repo.
+ */
+import { pascalCaseIdentifier } from '../../core/utils.js';
+/**
+ * Sanitize a NamingSystem name for use as a TypeScript identifier.
+ */
+export function sanitizeNamingSystemName(name) {
+    return pascalCaseIdentifier(name, {
+        stripPrefix: /^NamingSystem[-_]?/i,
+        digitPrefix: 'NS',
+        fallback: 'UnnamedNamingSystem',
+    });
+}
+/**
+ * Assign a unique identifier to every NamingSystem that will be emitted.
+ *
+ * Single source of truth for NamingSystem naming, shared by the file writer and
+ * the registry — the same arrangement `assignValueSetNames` uses, and for the
+ * same reason: two independent deduplication passes drift, and the registry
+ * then imports a file that was never written (TS2307).
+ *
+ * A NamingSystem has no canonical URL in R4, so identity here is the preferred
+ * uniqueId value rather than a `url` element.
+ */
+export function assignNamingSystemNames(namingSystems) {
+    const takenNames = new Set();
+    const seenIdentities = new Set();
+    const assigned = [];
+    for (const namingSystem of namingSystems) {
+        const identity = preferredUniqueId(namingSystem).value;
+        if (seenIdentities.has(identity))
+            continue;
+        seenIdentities.add(identity);
+        const base = sanitizeNamingSystemName(namingSystem.name);
+        let sanitized = base;
+        let suffix = 2;
+        while (takenNames.has(sanitized)) {
+            sanitized = `${base}${suffix}`;
+            suffix++;
+        }
+        takenNames.add(sanitized);
+        assigned.push({ namingSystem, sanitized });
+    }
+    return assigned;
+}
+/**
+ * The uniqueId a consumer means when they say "the system".
+ *
+ * `preferred: true` wins, then the first `uri` entry (what a profile fixes on
+ * `Identifier.system`), then the first entry at all.
+ */
+export function preferredUniqueId(namingSystem) {
+    return namingSystem.uniqueIds.find(u => u.preferred)
+        ?? namingSystem.uniqueIds.find(u => u.type === 'uri')
+        ?? namingSystem.uniqueIds[0];
+}
+/**
+ * Generate TypeScript content for a NamingSystem.
+ */
+export function generateNamingSystemTypeScript(namingSystem, options) {
+    const name = options?.nameOverride ?? sanitizeNamingSystemName(namingSystem.name);
+    const filename = `NamingSystem-${name}.ts`;
+    const preferred = preferredUniqueId(namingSystem);
+    let content = `/**\n * NamingSystem: ${namingSystem.title || namingSystem.name}\n`;
+    if (namingSystem.description) {
+        content += ` * ${namingSystem.description.replace(/\*\//g, '*\\/').split('\n').join('\n * ')}\n`;
+    }
+    if (namingSystem.kind)
+        content += ` * Kind: ${namingSystem.kind}\n`;
+    content += ` */\n\n`;
+    content += `export const ${name}UniqueIds = [\n`;
+    for (const uid of namingSystem.uniqueIds) {
+        const preferredPart = uid.preferred !== undefined ? `, preferred: ${uid.preferred}` : '';
+        const commentPart = uid.comment ? `, comment: ${JSON.stringify(uid.comment)}` : '';
+        content += `  { type: ${JSON.stringify(uid.type)}, value: ${JSON.stringify(uid.value)}${preferredPart}${commentPart} },\n`;
+    }
+    content += `] as const;\n\n`;
+    content += `/**\n * The identifier system this NamingSystem defines.\n`;
+    content += ` * Use in place of a hand-written literal on \`Identifier.system\`.\n */\n`;
+    content += `export const ${name}System = ${JSON.stringify(preferred.value)};\n\n`;
+    const valueUnion = [...new Set(namingSystem.uniqueIds.map(u => JSON.stringify(u.value)))].join(' | ');
+    content += `/** Union of every uniqueId value this NamingSystem declares */\n`;
+    content += `export type ${name}Value = ${valueUnion};\n\n`;
+    content += `/** Type representing a uniqueId entry of this NamingSystem */\n`;
+    content += `export type ${name}UniqueId = typeof ${name}UniqueIds[number];\n\n`;
+    content += `/**\n * Check whether a value is one of this NamingSystem's declared identifiers\n */\n`;
+    content += `export function isValid${name}Value(value: string): value is ${name}Value {\n`;
+    content += `  return ${name}UniqueIds.some(u => u.value === value);\n`;
+    content += `}\n\n`;
+    content += `/**\n * Get this NamingSystem's identifier for a given uniqueId type (oid, uuid, uri, other)\n */\n`;
+    content += `export function get${name}Value(type: string): string | undefined {\n`;
+    content += `  return ${name}UniqueIds.find(u => u.type === type)?.value;\n`;
+    content += `}\n`;
+    return { filename, content };
+}
+/**
+ * Generate a registry file that exports all NamingSystems.
+ */
+export function generateNamingSystemRegistry(namingSystems) {
+    let content = `/**\n * NamingSystem Registry\n * Central registry of all identifier systems declared by this package\n */\n\n`;
+    // Names come from the shared assignment pass so every import below refers to
+    // a file the writer actually emitted (see assignNamingSystemNames).
+    const sorted = assignNamingSystemNames(namingSystems)
+        .map(({ namingSystem, sanitized }) => ({ sanitized, system: preferredUniqueId(namingSystem).value }))
+        .sort((a, b) => a.sanitized.localeCompare(b.sanitized));
+    for (const { sanitized } of sorted) {
+        content += `import * as ${sanitized} from './NamingSystem-${sanitized}.js';\n`;
+    }
+    content += '\n';
+    content += `export const NamingSystemRegistry = {\n`;
+    for (const { sanitized } of sorted) {
+        content += `  ${sanitized},\n`;
+    }
+    content += `} as const;\n\n`;
+    content += `export type NamingSystemName = keyof typeof NamingSystemRegistry;\n\n`;
+    content += `export function getNamingSystem(name: NamingSystemName) {\n`;
+    content += `  return NamingSystemRegistry[name];\n`;
+    content += `}\n\n`;
+    content += `/** Map from identifier system value to registry name */\n`;
+    content += `export const NamingSystemUrlMap: Record<string, NamingSystemName> = {\n`;
+    for (const { sanitized, system } of sorted) {
+        content += `  ${JSON.stringify(system)}: '${sanitized}',\n`;
+    }
+    content += `};\n\n`;
+    content += `/**\n * Look up the registry entry that declares an identifier system\n * @param system - An identifier system value (e.g. from \`Identifier.system\`)\n */\n`;
+    content += `export function getNamingSystemBySystem(system: string) {\n`;
+    content += `  const name = NamingSystemUrlMap[system];\n`;
+    content += `  return name ? NamingSystemRegistry[name] : undefined;\n`;
+    content += `}\n`;
+    return content;
+}

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

@@ -8,6 +8,7 @@
  */
 import fs from 'node:fs';
 import path from 'node:path';
+import { lowerFirstPreservingAcronym } from '../../core/utils.js';
 import { generatePrefabRenderer } from './prefabRenderer.js';
 import { FHIR_FORMAT_TS, DEFAULT_STYLES_TS, REGISTER_FHIR_PIPES_TS, buildPrefabIndexTs, } from './prefabRuntimeAssets.js';
 import { logger } from '../../../logger.js';
@@ -88,21 +89,7 @@ export function resetPrefabState() {
     emittedProfiles.clear();
 }
 // ── MCP View Registry generator ──────────────────────────────────────────────
-/**
- * Lower-case the first character(s) of a name, preserving acronym runs.
- * Mirrors the same logic in prefabRenderer.ts.
- */
-function lowerFirst(name) {
-    if (!name)
-        return name;
-    let i = 0;
-    while (i < name.length && name[i] >= 'A' && name[i] <= 'Z')
-        i++;
-    if (i <= 1)
-        return name.charAt(0).toLowerCase() + name.slice(1);
-    const acronymEnd = i === name.length ? i : i - 1;
-    return name.slice(0, acronymEnd).toLowerCase() + name.slice(acronymEnd);
-}
+const lowerFirst = lowerFirstPreservingAcronym;
 /**
  * Build the `mcpViews.ts` source — a `FhirViewRegistry` that maps FHIR
  * resource types to their generated prefab table/detail components.

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

@@ -11,26 +11,9 @@
  * The emitted code depends on `@maxhealth.tech/prefab` and the sibling
  * `fhirFormat.ts` / `styles.ts` files produced in the same output folder.
  */
+import { lowerFirstPreservingAcronym } from '../../core/utils.js';
 import { describeField, dedupeDescriptors, pickTableDescriptors, findTitleDescriptor, } from './prefabTypeMapper.js';
-/**
- * camelCase first char lowercased, but preserve leading acronym runs.
- * "CHCorePatient" → "chCorePatient"   (acronym lowered wholesale)
- * "Patient"       → "patient"
- * "HumanName"     → "humanName"
- */
-function lowerFirst(name) {
-    if (!name)
-        return name;
-    // Count leading uppercase letters (the acronym run).
-    let i = 0;
-    while (i < name.length && name[i] >= 'A' && name[i] <= 'Z')
-        i++;
-    if (i <= 1)
-        return name.charAt(0).toLowerCase() + name.slice(1);
-    // Preserve boundary: last uppercase stays uppercase if it starts the next word.
-    const acronymEnd = i === name.length ? i : i - 1;
-    return name.slice(0, acronymEnd).toLowerCase() + name.slice(acronymEnd);
-}
+const lowerFirst = lowerFirstPreservingAcronym;
 /** Emit a JS expression that extracts the display value for a descriptor from `r`. */
 function rowAccessor(d) {
     // Descriptors can pre-bake a bespoke accessor (e.g. synthesized per-system

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

@@ -34,7 +34,8 @@ function instanceUrl(slice, fields) {
         if (childId === sliceFullId + '.url' && typeof f.fixedValue === 'string')
             return f.fixedValue;
     }
-    return slice.profileUrls?.length ? stripVersionFromCanonicalUrl(slice.profileUrls[0]) : undefined;
+    const firstProfile = slice.profileUrls?.[0];
+    return firstProfile ? stripVersionFromCanonicalUrl(firstProfile) : undefined;
 }
 /**
  * The property name a choice slice occupies.
@@ -87,7 +88,9 @@ export function generateClosedSlicingValidations(fields, profileUrl, baseResourc
         if (elemId.includes(':'))
             continue;
         const segments = elemId.split('.');
-        const leaf = segments[segments.length - 1];
+        const leaf = segments.at(-1);
+        if (!leaf)
+            continue;
         const kind = classify(leaf);
         if (!kind)
             continue;

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

@@ -27,13 +27,19 @@ export function installFhirpathStub(outputDir) {
         types: 'index.d.ts',
     }, null, 2));
     // Minimal type declaration — only what the generated validators import
+    // `compile` is declared alongside `evaluate`: the emitted Zod schemas compile
+    // each invariant once at module load rather than re-parsing it per parse.
     fs.writeFileSync(path.join(pkgDir, 'index.d.ts'), `declare const fhirpath: {
   evaluate(resource: any, expression: string, context?: any, model?: any, options?: any): any[];
+  compile(expression: string, model?: any, options?: any): (resource: any, context?: any) => any[];
 };
 export default fhirpath;
 `);
     // Minimal JS stub (default export so ESM import doesn't crash if somehow reached at runtime)
-    fs.writeFileSync(path.join(pkgDir, 'index.js'), `export default { evaluate() { throw new Error("fhirpath stub — install the real package"); } };\n`);
+    fs.writeFileSync(path.join(pkgDir, 'index.js'), `export default {
+  evaluate() { throw new Error("fhirpath stub — install the real package"); },
+  compile() { throw new Error("fhirpath stub — install the real package"); },
+};\n`);
     // Stub fhir-context/<version>/index.js for each supported FHIR version
     for (const ver of FHIR_CONTEXT_VERSIONS) {
         const ctxDir = path.join(pkgDir, 'fhir-context', ver);