babelfhir-ts 1.5.21 → 1.6.1

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

@@ -263,7 +263,7 @@ export class ImportManager {
         const allFhirTypes = [];
         let match;
         while ((match = fhirImportRegex.exec(output)) !== null) {
-            const types = match[1].split(',').map(t => t.trim()).filter(Boolean);
+            const types = (match[1] ?? '').split(',').map(t => t.trim()).filter(Boolean);
             allFhirTypes.push(...types);
         }
         if (allFhirTypes.length === 0) {

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/interfaceGenerator.js

@@ -61,7 +61,9 @@ export function generateInterfaces(interfaceName, newFields, baseResource, baseF
     const baseFieldAnyArray = new Map();
     for (const bf of baseFields) {
         const parts = bf.name.split('.');
-        const seg = parts[parts.length - 1];
+        const seg = parts.at(-1);
+        if (!seg)
+            continue;
         if (!baseFieldByLastSegment.has(seg))
             baseFieldByLastSegment.set(seg, bf);
         // Track the widest array flag across direct children only (not nested duplicates)
@@ -83,10 +85,11 @@ export function generateInterfaces(interfaceName, newFields, baseResource, baseF
                 f.sliceName &&
                 f.binding?.uri);
             // Use the first slice binding if available (slices typically have more specific constraints)
-            if (slicesForThisField.length > 0 && slicesForThisField[0].binding) {
-                binding = slicesForThisField[0].binding;
+            const firstSlice = slicesForThisField[0];
+            if (firstSlice?.binding) {
+                binding = firstSlice.binding;
                 isSlicedField = true;
-                debug(`Using binding from slice ${slicesForThisField[0].sliceName} for ${field.name}`);
+                debug(`Using binding from slice ${firstSlice.sliceName} for ${field.name}`);
             }
         }
         if (!binding) {
@@ -196,6 +199,8 @@ export function generateInterfaces(interfaceName, newFields, baseResource, baseF
     // This must run after all interfaces + extension unions are assembled.
     for (let i = 0; i < interfaces.length; i++) {
         const iface = interfaces[i];
+        if (!iface)
+            continue;
         // Match "export interface Foo extends Bar {" or "export interface Foo extends Omit<Bar, ...> {"
         const extendsMatch = iface.match(/^export interface (\S+) extends (Omit<)?(\S+?)([,>])? \{/);
         if (!extendsMatch)
@@ -203,16 +208,16 @@ export function generateInterfaces(interfaceName, newFields, baseResource, baseF
         const alreadyOmit = !!extendsMatch[2];
         const baseType = extendsMatch[3];
         // Only wrap FHIR base types (not local profile interfaces)
-        if (!isFhirType(baseType))
+        if (!baseType || !isFhirType(baseType))
             continue;
         // Extract all declared property names from the interface body
         const bodyStart = iface.indexOf('{');
         const body = iface.slice(bodyStart + 1);
         const propNames = [];
         for (const line of body.split('\n')) {
-            const m = line.match(/^\s+(\w+)[?:]/);
-            if (m && m[1] !== 'resourceType')
-                propNames.push(m[1]);
+            const propName = line.match(/^\s+(\w+)[?:]/)?.[1];
+            if (propName && propName !== 'resourceType')
+                propNames.push(propName);
         }
         if (propNames.length === 0)
             continue;
@@ -266,7 +271,7 @@ export function generateInterfaces(interfaceName, newFields, baseResource, baseF
         logger.debug('[DEBUG FINAL INTERFACES]', {
             interfaceName,
             interfaceCount: interfaces.length,
-            interfaceNames: interfaces.map(i => i.split('\n')[0]).filter(n => n.includes('ConditionDeBasis02'))
+            interfaceNames: interfaces.map(i => i.split('\n')[0] ?? '').filter(n => n.includes('ConditionDeBasis02'))
         });
     }
     return {

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

@@ -122,18 +122,22 @@ export function postProcessExtensions(params) {
             }
             idx = findInterfaceIndex(name);
         }
-        if (idx >= 0 && !interfaces[idx].includes(line.trim())) {
+        // Hoisted once: the block below reads the same entry five times, and
+        // indexing it each time reads as possibly-undefined even after the bound
+        // check. Reads go through `target`, writes still go to interfaces[idx].
+        const target = idx >= 0 ? interfaces[idx] : undefined;
+        if (target !== undefined && !target.includes(line.trim())) {
             // Also check if a property with the same name already exists to avoid duplicates
-            const propName = line.trim().split(/[?:]/)[0].trim();
+            const propName = (line.trim().split(/[?:]/)[0] ?? '').trim();
             const propPattern = new RegExp(`^\\s*${propName}[?:]`, 'm');
-            if (interfaces[idx].match(propPattern)) {
+            if (target.match(propPattern)) {
                 // For extension properties, REPLACE the existing declaration with the new union
                 // This handles both union `(Extension | Type)[]` and plain `Type[]` formats
                 if (propName === 'extension' && line.includes('extension?:')) {
                     const existingExtPattern = /\s*extension\?\s*:\s*[^;\n]+;/;
-                    if (existingExtPattern.test(interfaces[idx])) {
+                    if (existingExtPattern.test(target)) {
                         const newExtLine = line.trim();
-                        interfaces[idx] = interfaces[idx].replace(existingExtPattern, `\n    ${newExtLine}`);
+                        interfaces[idx] = target.replace(existingExtPattern, `\n    ${newExtLine}`);
                         logger.debug('[DEBUG replaced extension property]', { propName, line: newExtLine });
                         return;
                     }
@@ -142,9 +146,9 @@ export function postProcessExtensions(params) {
                 return;
             }
             if (name === 'USCoreQuestionnaireResponseProfileItem' && line.includes('answer')) {
-                logger.debug('[DEBUG appendToInterface Item answer]', { name, line, currentInterface: interfaces[idx] });
+                logger.debug('[DEBUG appendToInterface Item answer]', { name, line, currentInterface: target });
             }
-            interfaces[idx] = interfaces[idx].replace(/}\s*$/, `\n    ${line}\n}`);
+            interfaces[idx] = target.replace(/}\s*$/, `\n    ${line}\n}`);
         }
     };
     // Ensure root interface exists and track its name
@@ -174,7 +178,9 @@ export function postProcessExtensions(params) {
             continue;
         }
         if (segs.length === 1) {
-            const seg = segs[0].replace(/\[x\]/g, '');
+            const seg = (segs[0] ?? '').replace(/\[x\]/g, '');
+            if (!seg)
+                continue;
             const nestedName = `${rootName}${capitalize(seg)}`;
             // Create alias types and union
             const aliases = [];
@@ -204,8 +210,9 @@ export function postProcessExtensions(params) {
                 const optionalLine = `_${seg}?: ${elementIface};`;
                 // Replace any required with optional first
                 const idx = findInterfaceIndex(rootName);
-                if (idx >= 0) {
-                    interfaces[idx] = interfaces[idx].replace(requiredLine, optionalLine);
+                const existing = idx >= 0 ? interfaces[idx] : undefined;
+                if (existing !== undefined) {
+                    interfaces[idx] = existing.replace(requiredLine, optionalLine);
                 }
                 appendToInterface(rootName, `_${seg}${opt}: ${elementIface};`);
             }
@@ -265,6 +272,8 @@ export function postProcessExtensions(params) {
         }
         else if (segs.length === 2) {
             const [seg1Raw, seg2Raw] = segs;
+            if (!seg1Raw || !seg2Raw)
+                continue;
             const seg1 = seg1Raw.replace(/\[x\]/g, '');
             const seg2 = seg2Raw.replace(/\[x\]/g, '');
             // Ensure first-level container exists
@@ -300,9 +309,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';
                 }
             }
@@ -383,14 +398,15 @@ export function safetyNetRootExtensions(params) {
         importManager.addFhirType('Extension');
         const union = ['Extension', ...aliases].join(' | ');
         const idx = findInterfaceIndex(interfaceName);
-        if (idx >= 0) {
+        const target = idx >= 0 ? interfaces[idx] : undefined;
+        if (target !== undefined) {
             // Replace any existing extension property (union or plain type) with the new union
             const existingExtPattern = /\s*extension\?\s*:\s*[^;\n]+;/;
-            if (existingExtPattern.test(interfaces[idx])) {
-                interfaces[idx] = interfaces[idx].replace(existingExtPattern, `\n    extension?: (${union})[];`);
+            if (existingExtPattern.test(target)) {
+                interfaces[idx] = target.replace(existingExtPattern, `\n    extension?: (${union})[];`);
             }
             else {
-                interfaces[idx] = interfaces[idx].replace(/}\s*$/, `\n    extension?: (${union})[];\n}`);
+                interfaces[idx] = target.replace(/}\s*$/, `\n    extension?: (${union})[];\n}`);
             }
         }
     }

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

@@ -366,8 +366,9 @@ export function handleFlatField(args) {
             }
             else {
                 const idxEl = findInterfaceIndex(elementIface);
-                if (idxEl >= 0 && !interfaces[idxEl].includes('extension?: (')) {
-                    interfaces[idxEl] = interfaces[idxEl].replace(/\n}\s*$/, `\n    ${extLine}\n}`);
+                const ifaceEl = idxEl >= 0 ? interfaces[idxEl] : undefined;
+                if (ifaceEl !== undefined && !ifaceEl.includes('extension?: (')) {
+                    interfaces[idxEl] = ifaceEl.replace(/\n}\s*$/, `\n    ${extLine}\n}`);
                 }
             }
             // Add sidecar property _fieldName?: ElementIface to the current parent's interface lines
@@ -391,8 +392,8 @@ export function handleFlatField(args) {
             // If a required variant was already written elsewhere, replace it with optional
             if (writtenLines.has(sidecarLineRequired)) {
                 // replace in existing interfaces
-                for (let i = 0; i < interfaces.length; i++) {
-                    interfaces[i] = interfaces[i].replace(sidecarLineRequired, sidecarLineOptional);
+                for (const [i, iface] of interfaces.entries()) {
+                    interfaces[i] = iface.replace(sidecarLineRequired, sidecarLineOptional);
                 }
                 writtenLines.delete(sidecarLineRequired);
             }
@@ -414,8 +415,9 @@ export function handleFlatField(args) {
             const nestedDefined = interfaces.some(i => i.startsWith(`export interface ${nestedInterfaceName}`));
             if (nestedDefined) {
                 const idx = findInterfaceIndex(nestedInterfaceName);
-                if (idx >= 0 && !interfaces[idx].includes('extension?: (')) {
-                    interfaces[idx] = interfaces[idx].replace(/\n}\s*$/, `\n    ${extLine}\n}`);
+                const iface = idx >= 0 ? interfaces[idx] : undefined;
+                if (iface !== undefined && !iface.includes('extension?: (')) {
+                    interfaces[idx] = iface.replace(/\n}\s*$/, `\n    ${extLine}\n}`);
                 }
             }
             else {
@@ -463,7 +465,7 @@ export function handleFlatField(args) {
     fieldType = applyBindingConstraint(fieldType, field, fields);
     // Apply ValueSet binding constraints for primitive code fields (generates union literal type)
     if (isPrimitiveCodeField && hasNarrowingBinding && field.binding?.codes) {
-        const vsUri = field.binding.uri?.split('|')[0];
+        const vsUri = field.binding.uri ? stripVersionFromCanonicalUrl(field.binding.uri) : undefined;
         const vs = vsUri && valueSets ? (valueSets.get(vsUri) || valueSets.get(field.binding.uri)) : undefined;
         if (vs && vs.isSmall && vs.concepts.length > 0) {
             // Import the ValueSet Code type from the generated valuesets directory

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

@@ -169,18 +169,17 @@ export function handleNestedField(args) {
         if (nestedDefined) {
             // Append a line to the nested interface's content
             const idx = findInterfaceIndex(nestedInterfaceName);
-            if (idx >= 0 && !interfaces[idx].includes('extension?: (')) {
-                interfaces[idx] = interfaces[idx].replace(/\n}\s*$/, `\n    ${extLine}\n}`);
+            const iface = idx >= 0 ? interfaces[idx] : undefined;
+            if (iface !== undefined && !iface.includes('extension?: (')) {
+                interfaces[idx] = iface.replace(/\n}\s*$/, `\n    ${extLine}\n}`);
             }
         }
         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);
@@ -394,8 +393,8 @@ export function handleNestedField(args) {
     }
     // Register external profiles for any field with profile URLs, regardless of nesting
     // This handles FHIR datatype profiles like SimpleQuantity that aren't in @types/fhir
-    if (field.isProfiled && field.profileUrls && field.profileUrls.length > 0 && !isFhirType(resolvedType)) {
-        const profileUrl = field.profileUrls[0];
+    const [profileUrl] = field.profileUrls ?? [];
+    if (field.isProfiled && profileUrl && !isFhirType(resolvedType)) {
         // Strip version suffix from canonical URL before extracting name
         const strippedUrl = stripVersionFromCanonicalUrl(profileUrl);
         // Use helper to determine base type - extension fields get 'Extension' as base type

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/prefab/prefabTypeMapper.js

@@ -100,6 +100,8 @@ export function describeField(field) {
     if (segments.length !== 2)
         return [];
     const bareName = segments[1];
+    if (!bareName)
+        return [];
     // Skip extension plumbing — surfaced separately once sliced-extension rendering lands.
     if (bareName === 'extension' || bareName === 'modifierExtension')
         return [];

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);