babelfhir-ts 1.5.21 → 1.6.1

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

@@ -8,7 +8,7 @@
 import { sanitizeValueSetName } from '../valueset/valueSetGenerator.js';
 import { getRules, versionSlug } from '../../fhir/versionContext.js';
 import { getZodPackageTypes } from './zodTypes.js';
-import { mergeFields } from '../../core/utils.js';
+import { mergeFields, capitalize, stripSliceSuffix, firstSegment, stripVersionFromCanonicalUrl } from '../../core/utils.js';
 import { buildRefinements } from './zodRefinementBuilder.js';
 /** Map FHIR primitive types to Zod schema calls */
 /** Runtime helpers a refinement may reference, imported from ValidatorOptions. */
@@ -53,7 +53,16 @@ function isPrimitive(fhirType) {
  * @param baseFields     Fields inherited from the base resource
  * @param valueSets      Optional parsed ValueSets for enum generation
  */
-export function generateZodSchema(interfaceName, newFields, baseResource, baseFields = [], valueSets) {
+export function generateZodSchema(interfaceName, newFields, baseResource, baseFields = [], valueSets, 
+/**
+ * Emit the FHIRPath invariants as refinements.
+ *
+ * Off by default: each invariant is a compiled FHIRPath evaluation on every
+ * parse (~5.5us, so +0.38ms across C4BBOrganization's 69), which is the right
+ * trade for conformance checking and the wrong one for per-request validation
+ * in a hot path. The caller decides.
+ */
+emitInvariants = false) {
     const lines = [];
     const imports = new Set();
     const baseTypeImports = new Set();
@@ -101,8 +110,7 @@ export function generateZodSchema(interfaceName, newFields, baseResource, baseFi
                 : [{ code: field.type || 'string' }];
             for (const opt of options) {
                 const typeCode = opt.code;
-                const suffix = typeCode === 'code' ? 'Code'
-                    : typeCode[0].toUpperCase() + typeCode.slice(1);
+                const suffix = typeCode === 'code' ? 'Code' : capitalize(typeCode);
                 choiceExpandedProps.add(basePropName + suffix);
                 if (isPrimitive(typeCode)) {
                     choiceExpandedProps.add('_' + basePropName + suffix);
@@ -113,14 +121,22 @@ export function generateZodSchema(interfaceName, newFields, baseResource, baseFi
     // Pre-compute minimum cardinality implied by required slices.
     // If an array field (e.g., extension) has slices with min>=1, the parent array
     // must contain at least that many elements even if its own min is 0.
+    //
+    // Keyed by the slice's full path. Keying by the last segment made every
+    // `*.extension:slice` anywhere in the resource count towards the *root*
+    // `extension`, so PASClaimBase emitted `z.array(ExtensionSchema).min(3)` for a
+    // profile whose Claim.extension slices are all min=0.
+    //
+    // An unstated `min` counts as 0, not 1. A differential states only what it
+    // changes, so a slice that says nothing about cardinality inherits the base,
+    // and a slice can only become required by stating min>=1 itself.
     const sliceMinByParent = new Map();
     for (const f of allFields) {
         if (!f.sliceName)
             continue;
-        const sliceMin = typeof f.min === 'number' ? f.min : (f.isOptional ? 0 : 1);
+        const sliceMin = typeof f.min === 'number' ? f.min : 0;
         if (sliceMin > 0) {
-            const parentKey = f.name.split('.').pop();
-            sliceMinByParent.set(parentKey, (sliceMinByParent.get(parentKey) || 0) + sliceMin);
+            sliceMinByParent.set(f.name, (sliceMinByParent.get(f.name) || 0) + sliceMin);
         }
     }
     for (const field of schemaFields) {
@@ -134,8 +150,7 @@ export function generateZodSchema(interfaceName, newFields, baseResource, baseFi
             const expandedProps = [];
             for (const opt of options) {
                 const typeCode = opt.code;
-                const suffix = typeCode === 'code' ? 'Code'
-                    : typeCode[0].toUpperCase() + typeCode.slice(1);
+                const suffix = typeCode === 'code' ? 'Code' : capitalize(typeCode);
                 const propName = basePropName + suffix;
                 let variantType = buildZodTypeForCode(typeCode, baseTypeImports);
                 variantType = `${variantType}.optional()`;
@@ -181,7 +196,7 @@ export function generateZodSchema(interfaceName, newFields, baseResource, baseFi
         if (field.isArray) {
             let minItems = typeof field.min === 'number' && field.min > 0 ? field.min : 0;
             // If required slices exist, the parent array needs at least that many items
-            const sliceImpliedMin = sliceMinByParent.get(fieldName) || 0;
+            const sliceImpliedMin = sliceMinByParent.get(field.name) || 0;
             if (sliceImpliedMin > minItems)
                 minItems = sliceImpliedMin;
             const maxItems = typeof field.max === 'number' && field.max !== Infinity ? field.max : 0;
@@ -220,7 +235,7 @@ export function generateZodSchema(interfaceName, newFields, baseResource, baseFi
         }
         // Make optional or required
         // A field is required if it has min>=1 OR required slices imply a minimum
-        const effectiveRequired = !field.isOptional || (sliceMinByParent.get(fieldName) || 0) > 0;
+        const effectiveRequired = !field.isOptional || (sliceMinByParent.get(field.name) || 0) > 0;
         if (!effectiveRequired) {
             zodType = `${zodType}.optional()`;
         }
@@ -256,8 +271,8 @@ export function generateZodSchema(interfaceName, newFields, baseResource, baseFi
     // because DataType random() methods don't produce pattern-aware data.
     const isDataTypeProfile = getZodPackageTypes().has(rootPrefix);
     const refinementResult = isDataTypeProfile
-        ? { refinements: [], supportedConstraints: [], unsupportedConstraints: [], valueSetImports: new Map() }
-        : buildRefinements(allFields, rootPrefix, valueSets);
+        ? { refinements: [], supportedConstraints: [], unsupportedConstraints: [], valueSetImports: new Map(), invariantEvaluators: [] }
+        : buildRefinements(allFields, rootPrefix, valueSets, emitInvariants);
     // Merge ValueSet imports from binding refinements
     for (const [name, importPath] of refinementResult.valueSetImports) {
         if (!valueSetImports.has(name)) {
@@ -277,7 +292,18 @@ export function generateZodSchema(interfaceName, newFields, baseResource, baseFi
         const headerIndex = lines.indexOf(`import { z } from "zod";`);
         lines.splice(headerIndex + 1, 0, `import { ${usedHelpers.join(', ')} } from "./ValidatorOptions.js";`);
     }
+    // Invariant refinements evaluate FHIRPath synchronously, so the engine and the
+    // version's model have to be imported alongside the schema.
+    if (refinementResult.invariantEvaluators.length > 0) {
+        const headerIndex = lines.indexOf(`import { z } from "zod";`);
+        lines.splice(headerIndex + 1, 0, `import fhirpath from "fhirpath";`, `import fhirpath_model from "fhirpath/fhir-context/${versionSlug()}/index.js";`);
+    }
     lines.push('');
+    // Compiled invariant evaluators, hoisted above the schema so each FHIRPath
+    // expression is parsed once at import instead of on every parse.
+    if (refinementResult.invariantEvaluators.length > 0) {
+        lines.push(...refinementResult.invariantEvaluators, '');
+    }
     // Emit schema
     const schemaName = `${interfaceName}Schema`;
     lines.push(`export const ${schemaName} =`);
@@ -285,7 +311,7 @@ export function generateZodSchema(interfaceName, newFields, baseResource, baseFi
     // Deduplicate properties by name (keep first occurrence)
     const seenTopProps = new Set();
     for (const prop of properties) {
-        const propName = prop.trim().split(':')[0].trim();
+        const propName = stripSliceSuffix(prop.trim()).trim();
         if (seenTopProps.has(propName))
             continue;
         seenTopProps.add(propName);
@@ -346,9 +372,10 @@ function buildZodType(field, valueSets, valueSetImports, complexTypeImports, bas
         return `z.enum([${codes.join(', ')}])`;
     }
     // Check for ValueSet binding via parsed ValueSets
-    if (!isComplexBoundType && field.binding?.uri && valueSets) {
-        const vsUri = field.binding.uri.split('|')[0];
-        const vs = valueSets.get(vsUri) || valueSets.get(field.binding.uri);
+    const bindingUri = field.binding?.uri;
+    if (!isComplexBoundType && bindingUri && valueSets) {
+        const vsUri = stripVersionFromCanonicalUrl(bindingUri);
+        const vs = valueSets.get(vsUri) || valueSets.get(bindingUri);
         if (vs && vs.concepts.length > 0 && vs.concepts.length <= 50) {
             const sanitizedName = sanitizeValueSetName(vs.name);
             const vsCodeType = `${sanitizedName}Code`;
@@ -423,8 +450,7 @@ function buildInlineBackboneSchema(allFields, parentPath, valueSets, valueSetImp
                 : [{ code: child.type || 'string' }];
             for (const opt of options) {
                 const typeCode = opt.code;
-                const suffix = typeCode === 'code' ? 'Code'
-                    : typeCode[0].toUpperCase() + typeCode.slice(1);
+                const suffix = typeCode === 'code' ? 'Code' : capitalize(typeCode);
                 choiceExpandedProps.add(basePropName + suffix);
                 if (isPrimitive(typeCode)) {
                     choiceExpandedProps.add('_' + basePropName + suffix);
@@ -444,8 +470,7 @@ function buildInlineBackboneSchema(allFields, parentPath, valueSets, valueSetImp
                 : [{ code: child.type || 'string' }];
             for (const opt of options) {
                 const typeCode = opt.code;
-                const suffix = typeCode === 'code' ? 'Code'
-                    : typeCode[0].toUpperCase() + typeCode.slice(1);
+                const suffix = typeCode === 'code' ? 'Code' : capitalize(typeCode);
                 const propName = basePropName + suffix;
                 let variantType = buildZodTypeForCode(typeCode, baseTypeImports);
                 variantType = `${variantType}.optional()`;
@@ -493,7 +518,7 @@ function buildInlineBackboneSchema(allFields, parentPath, valueSets, valueSetImp
     // Deduplicate properties by name (keep first occurrence)
     const seenProps = new Set();
     const uniqueProps = props.filter(p => {
-        const name = p.split(':')[0].trim();
+        const name = stripSliceSuffix(p).trim();
         if (seenProps.has(name))
             return false;
         seenProps.add(name);
@@ -507,7 +532,9 @@ function getRootPrefix(fields, baseResource, interfaceName) {
     // Find the most common first segment
     const counts = new Map();
     for (const f of fields) {
-        const root = f.name.split('.')[0];
+        const root = firstSegment(f.name);
+        if (!root)
+            continue;
         counts.set(root, (counts.get(root) || 0) + 1);
     }
     // Sort by count, prefer baseResource if tied
@@ -524,7 +551,7 @@ function getRootPrefix(fields, baseResource, interfaceName) {
 /** Sanitize a field name for use as an object property */
 function sanitizePropertyName(name) {
     // Strip slice suffix (e.g. "category:VSCat" -> "category")
-    const clean = name.split(':')[0];
+    const clean = stripSliceSuffix(name);
     // If the name is a JS reserved word or starts with a digit, quote it
     if (/^\d/.test(clean) || JS_RESERVED.has(clean)) {
         return `"${clean}"`;

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

@@ -223,7 +223,7 @@ function collectDataTypeFields(sd, typeName, dataTypes) {
         if (parts.length !== 2)
             continue;
         const fieldName = parts[1];
-        if (INFRA_FIELDS.has(fieldName))
+        if (!fieldName || INFRA_FIELDS.has(fieldName))
             continue;
         const typeCode = el.type?.[0]?.code;
         if (!typeCode)
@@ -260,8 +260,7 @@ function collectBackboneInterfaces(sd, rootType, interfaceNames) {
         const parts = id.split('.');
         // Skip the root type segment (parts[0])
         let name = rootType;
-        for (let i = 1; i < parts.length; i++) {
-            const seg = parts[i];
+        for (const seg of parts.slice(1)) {
             name += seg.charAt(0).toUpperCase() + seg.slice(1);
         }
         interfaceNames.push(name);

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

@@ -272,7 +272,7 @@ function collectDataTypeFields(
     if (parts.length !== 2) continue;
 
     const fieldName = parts[1];
-    if (INFRA_FIELDS.has(fieldName)) continue;
+    if (!fieldName || INFRA_FIELDS.has(fieldName)) continue;
 
     const typeCode = el.type?.[0]?.code;
     if (!typeCode) continue;
@@ -315,8 +315,7 @@ function collectBackboneInterfaces(
     const parts = id.split('.');
     // Skip the root type segment (parts[0])
     let name = rootType;
-    for (let i = 1; i < parts.length; i++) {
-      const seg = parts[i];
+    for (const seg of parts.slice(1)) {
       name += seg.charAt(0).toUpperCase() + seg.slice(1);
     }
 

package/out/src/generator/generationHelpers.js

@@ -6,6 +6,7 @@ import path from 'path';
 import fs from 'fs';
 import { expandValueSetsFromTx, addPlaceholdersForExternalBindings } from './parser/vsParser.js';
 import { generateValueSetTypeScript, generateValueSetRegistry, assignValueSetNames } from './emitters/valueset/valueSetGenerator.js';
+import { generateNamingSystemTypeScript, generateNamingSystemRegistry, assignNamingSystemNames } from './emitters/namingsystem/namingSystemGenerator.js';
 import { collectValueSetBindingUrls, clearLocalStructureDefinitions } from './parser/sdParser.js';
 import { ensureDirectoryExists, sanitizeIdentifier, toPascalCase } from './core/utils.js';
 import { getCacheConfig, getFhirPackagesCacheDir } from './core/cacheConfig.js';
@@ -183,6 +184,12 @@ export async function expandValueSetsWithTx(valueSets, valueSetCodesMap, structu
  * Returns whether any files were generated. Handles stale directory cleanup.
  */
 export function emitValueSetFiles(valueSets, outputDir) {
+    const generated = writeValueSetFiles(valueSets, outputDir);
+    if (!generated)
+        cleanupStaleSubdir(outputDir, 'valuesets');
+    return generated;
+}
+function writeValueSetFiles(valueSets, outputDir) {
     if (valueSets.size === 0)
         return false;
     const valueSetOutputDir = path.join(outputDir, 'valuesets');
@@ -282,17 +289,62 @@ export function enrichValueSetsFromCodeMap(valueSets, valueSetCodesMap, bindingU
         logger.log(`ValueSet enrichment: ${enrichedCount} enriched, ${createdCount} created from CodeSystem resolution`);
     }
 }
-/** Remove stale valuesets directory if it exists and no ValueSets were generated. */
-export function cleanupStaleValueSetDir(outputDir) {
-    const vdir = path.join(outputDir, 'valuesets');
+/**
+ * Generate TypeScript files for NamingSystems and write them to disk.
+ *
+ * Mirrors {@link emitValueSetFiles}: an IG's declared identifier systems become
+ * typed constants rather than literals retyped by every consumer.
+ * Returns whether any files were generated. Handles stale directory cleanup.
+ */
+export function emitNamingSystemFiles(namingSystems, outputDir) {
+    const generated = writeNamingSystemFiles(namingSystems, outputDir);
+    if (!generated)
+        cleanupStaleSubdir(outputDir, 'namingsystems');
+    return generated;
+}
+function writeNamingSystemFiles(namingSystems, outputDir) {
+    if (namingSystems.length === 0)
+        return false;
+    const nsOutputDir = path.join(outputDir, 'namingsystems');
+    let generatedCount = 0;
+    const assigned = assignNamingSystemNames(namingSystems);
+    for (const { namingSystem, sanitized } of assigned) {
+        try {
+            if (generatedCount === 0) {
+                ensureDirectoryExists(nsOutputDir);
+            }
+            const { filename, content } = generateNamingSystemTypeScript(namingSystem, { nameOverride: sanitized });
+            fs.writeFileSync(path.join(nsOutputDir, filename), content, 'utf-8');
+            generatedCount++;
+        }
+        catch (err) {
+            log.error(`Failed to generate NamingSystem ${namingSystem.name}:`, err);
+        }
+    }
+    if (generatedCount === 0)
+        return false;
+    const registryContent = generateNamingSystemRegistry(namingSystems);
+    fs.writeFileSync(path.join(nsOutputDir, 'index.ts'), registryContent, 'utf-8');
+    logger.log(`Generated ${generatedCount} NamingSystem files in ${nsOutputDir}`);
+    return true;
+}
+/**
+ * Remove a generated subdirectory left over from an earlier run.
+ *
+ * A cached extraction can keep a `valuesets/`/`namingsystems/` folder whose
+ * source resources are gone; leaving it behind makes the barrel export a module
+ * nothing regenerates.
+ */
+function cleanupStaleSubdir(outputDir, subdir) {
+    const dir = path.join(outputDir, subdir);
     try {
-        if (fs.existsSync(vdir)) {
-            fs.rmSync(vdir, { recursive: true, force: true });
-            log.debug(`Removed stale ValueSets directory: ${vdir}`);
+        if (fs.existsSync(dir)) {
+            fs.rmSync(dir, { recursive: true, force: true });
+            log.debug(`Removed stale ${subdir} directory: ${dir}`);
         }
     }
     catch (e) {
-        log.debug(`Failed to remove stale ValueSets directory ${vdir}: ${e.message}`);
+        log.debug(`Failed to remove stale ${subdir} directory ${dir}: ${e.message}`);
     }
 }
 /** Initialize logger and clear local StructureDefinitions for a generation run. */

package/out/src/generator/index.js

@@ -1,7 +1,7 @@
 import path from 'path';
 import fs from 'fs';
 import { fileURLToPath } from 'url';
-import { extractPackage, readStructureDefinitionsFromDir, readStructureDefinitionsFromDependencies, createPackageFromDir, readValueSetCodesWithDependencies, readValueSetsFromDir, detectFhirVersion, ensureDependenciesDownloaded, readSearchParametersFromDir } from './parser/packageParser.js';
+import { extractPackage, readStructureDefinitionsFromDir, readStructureDefinitionsFromDependencies, createPackageFromDir, readValueSetCodesWithDependencies, readValueSetsFromDir, detectFhirVersion, ensureDependenciesDownloaded, readSearchParametersFromDir, readNamingSystemsFromDir } from './parser/packageParser.js';
 import { fetchStructureDefinitions, fetchStructureDefinition, registerLocalStructureDefinitions, clearLocalStructureDefinitions, collectValueSetBindingUrls } from './parser/sdParser.js';
 import { ensureDirectoryExists, downloadFile } from './core/utils.js';
 import { getFhirPackagesCacheDir } from './core/cacheConfig.js';
@@ -13,7 +13,7 @@ import { DEFAULT_FHIR_VERSION } from './fhir/types.js';
 import { FHIR_VERSIONS } from './fhir/versionRegistry.js';
 import { ensureCorePackage } from './fhir/corePackageResolver.js';
 import { spawn } from 'child_process';
-import { buildProfileRegistries, expandValueSetsWithTx, emitValueSetFiles, cleanupStaleValueSetDir, initGenerationContext, enrichValueSetsFromCodeMap, collectReferencedDependencyProfiles, } from './generationHelpers.js';
+import { buildProfileRegistries, expandValueSetsWithTx, emitValueSetFiles, emitNamingSystemFiles, initGenerationContext, enrichValueSetsFromCodeMap, collectReferencedDependencyProfiles, } from './generationHelpers.js';
 /** Resolve the babelfhir-ts CLI version from its own package.json (used to stamp generated packages). */
 const __generatorDir = path.dirname(fileURLToPath(import.meta.url));
 const _generatorPkgPath = [
@@ -218,7 +218,62 @@ async function compileTypeScriptToJS(dir) {
         });
     });
 }
-/** Generate index.ts that exports all generated interfaces and classes */
+/**
+ * Output directories that only some generation runs produce.
+ *
+ * Single source of truth for both the generated `package.json` exports map and
+ * the root index barrel. These were three separate lists — two identical
+ * `exports` blocks plus a hardcoded check in the barrel writer — so registering
+ * an emitter meant remembering all three, and reaching a second entry module
+ * meant naming it literally (`./dicomweb/cornerstone`). `modules` covers any
+ * module a folder emits, so nothing here names one.
+ */
+const OPTIONAL_OUTPUT_DIRS = [
+    { dir: 'fhir-client', barrel: true },
+    // dicomweb writes a second entry module (cornerstone) beside its barrel.
+    { dir: 'dicomweb', barrel: true, modules: true },
+    { dir: 'prefab', barrel: true },
+    { dir: 'valuesets', modules: true, rootReExport: true },
+    { dir: 'namingsystems', modules: true, rootReExport: true },
+];
+/**
+ * Add subpath exports for the optional output directories that were created.
+ *
+ * Shared by generateIntoPackage() and generateIntoPackageDirect(), which
+ * previously carried identical copies of this block.
+ */
+function addOptionalSubpathExports(outputDir, generatedExports) {
+    for (const { dir, barrel, modules } of OPTIONAL_OUTPUT_DIRS) {
+        if (!fs.existsSync(path.join(outputDir, dir)))
+            continue;
+        if (barrel) {
+            generatedExports[`./${dir}`] = { types: `./${dir}/index.d.ts`, import: `./${dir}/index.js` };
+        }
+        if (modules) {
+            generatedExports[`./${dir}/*`] = { types: `./${dir}/*.d.ts`, import: `./${dir}/*.js` };
+        }
+    }
+}
+/**
+ * Put the extraction root's `package.json` back the way it was found.
+ *
+ * The generated manifest is staged there only so `createPackageFromDir` puts it
+ * at the tarball root; it must not outlive the repack when the extraction root
+ * is a shared cache entry.
+ */
+export function restoreRootManifest(rootPackageJsonPath, prior) {
+    try {
+        if (prior) {
+            fs.writeFileSync(rootPackageJsonPath, prior);
+        }
+        else {
+            fs.rmSync(rootPackageJsonPath, { force: true });
+        }
+    }
+    catch (err) {
+        log.warn(`Could not restore ${rootPackageJsonPath}: ${err.message}`);
+    }
+}
 async function generateIndexFile(dir) {
     const files = fs.readdirSync(dir, { withFileTypes: true });
     const exports = [];
@@ -233,8 +288,10 @@ async function generateIndexFile(dir) {
             const content = fs.readFileSync(filePath, 'utf-8');
             const names = new Map();
             const exportMatches = content.matchAll(/export\s+(interface|class|type|const|function)\s+(\w+)/g);
-            for (const match of exportMatches) {
-                names.set(match[2], match[1] === 'interface' || match[1] === 'type' ? 'type' : 'value');
+            for (const [, kind, name] of exportMatches) {
+                if (!name)
+                    continue;
+                names.set(name, kind === 'interface' || kind === 'type' ? 'type' : 'value');
             }
             fileExports.set(file.name, names);
         }
@@ -279,10 +336,11 @@ async function generateIndexFile(dir) {
             }
         }
     }
-    // Also export from valuesets subfolder if it exists
-    const valueSetsDir = path.join(dir, 'valuesets');
-    if (fs.existsSync(valueSetsDir)) {
-        exports.push(`export * from './valuesets/index.js';`);
+    // Re-export the optional subfolders that opt into it (see OPTIONAL_OUTPUT_DIRS)
+    for (const { dir: subdir } of OPTIONAL_OUTPUT_DIRS.filter(d => d.rootReExport)) {
+        if (fs.existsSync(path.join(dir, subdir))) {
+            exports.push(`export * from './${subdir}/index.js';`);
+        }
     }
     // Export shared ValidatorOptions type
     if (fs.existsSync(path.join(dir, 'ValidatorOptions.ts'))) {
@@ -450,10 +508,8 @@ export async function generateIntoPackage(packageArchivePath, outArchivePath, fl
         ensureDirectoryExists(outputDir);
         // Generate TypeScript files for ValueSets inside the embedded package
         endPhase = startPhase('generate');
-        const didGenerateValueSets = emitValueSetFiles(valueSets, outputDir);
-        if (!didGenerateValueSets) {
-            cleanupStaleValueSetDir(outputDir);
-        }
+        emitValueSetFiles(valueSets, outputDir);
+        emitNamingSystemFiles(readNamingSystemsFromDir(extractedRoot), outputDir);
         // Build profile registries from BOTH main and dependency SDs so delegation can resolve names
         const { existingStructureDefinitions, profileIdToName, profileUrlToName, profileUrlToType } = buildProfileRegistries(allSDs, fhirInterfaceNames);
         // Register all local StructureDefinitions for resolution before HTTP fetches
@@ -543,20 +599,7 @@ export async function generateIntoPackage(packageArchivePath, outArchivePath, fl
             const { finalizePrefabOutput } = await import('./emitters/prefab/prefabEmitter.js');
             finalizePrefabOutput(outputDir, { prefabStylesPath: flags.prefabStyles });
         }
-        // Only add subpath exports if their directories were actually created
-        if (fs.existsSync(path.join(outputDir, 'fhir-client'))) {
-            generatedExports['./fhir-client'] = { types: './fhir-client/index.d.ts', import: './fhir-client/index.js' };
-        }
-        if (fs.existsSync(path.join(outputDir, 'dicomweb'))) {
-            generatedExports['./dicomweb'] = { types: './dicomweb/index.d.ts', import: './dicomweb/index.js' };
-            generatedExports['./dicomweb/cornerstone'] = { types: './dicomweb/cornerstone.d.ts', import: './dicomweb/cornerstone.js' };
-        }
-        if (fs.existsSync(path.join(outputDir, 'prefab'))) {
-            generatedExports['./prefab'] = { types: './prefab/index.d.ts', import: './prefab/index.js' };
-        }
-        if (fs.existsSync(path.join(outputDir, 'valuesets'))) {
-            generatedExports['./valuesets/*'] = { types: './valuesets/*.d.ts', import: './valuesets/*.js' };
-        }
+        addOptionalSubpathExports(outputDir, generatedExports);
         const generatedPackageJsonPath = path.join(outputDir, 'package.json');
         fs.writeFileSync(generatedPackageJsonPath, JSON.stringify(generatedPackageJson, null, 2));
         logger.log(`Created package.json in generated folder: ${packageName}-generated@${packageVersion}`);
@@ -611,14 +654,30 @@ export async function generateIntoPackage(packageArchivePath, outArchivePath, fl
             fs.rmdirSync(nodeModulesDir);
         }
         catch { /* not empty or doesn't exist — fine */ }
-        // Copy package.json to root of extractedRoot so it's at the tarball root
+        // Copy package.json to root of extractedRoot so it's at the tarball root.
+        //
+        // extractedRoot is the shared FHIR cache entry whenever the package was
+        // already cached (see shouldCleanup), so this file is not ours to keep: a
+        // package installed flat — no `package/` subdir, as `babelfhir-ts install`
+        // produces for a locally built IG — keeps its own manifest right here, and
+        // leaving the generated one behind makes the next run read `@types/fhir`
+        // and friends as FHIR package specs. Restore the previous state once the
+        // archive is written.
         const rootPackageJsonPath = path.join(extractedRoot, 'package.json');
+        const priorRootManifest = fs.existsSync(rootPackageJsonPath)
+            ? fs.readFileSync(rootPackageJsonPath)
+            : undefined;
         fs.copyFileSync(generatedPackageJsonPath, rootPackageJsonPath);
         logger.log('Copied package.json to tarball root');
         const finalArchive = outArchivePath || deriveOutputArchiveName(packageArchivePath);
         endPhase = startPhase('repack');
-        await createPackageFromDir(extractedRoot, finalArchive);
-        endPhase(); // repack
+        try {
+            await createPackageFromDir(extractedRoot, finalArchive);
+        }
+        finally {
+            endPhase(); // repack
+            restoreRootManifest(rootPackageJsonPath, priorRootManifest);
+        }
         // Write timing summary to output directory
         const timing = getTimingSummary();
         fs.writeFileSync(path.join(outputDir, 'generation-timing.json'), JSON.stringify(timing, null, 2));
@@ -692,9 +751,8 @@ export async function generateIntoPackageDirect(packageArchivePath, flags) {
     }
     ensureDirectoryExists(outputDir);
     endPhase = startPhase('generate');
-    const didGenerateValueSets = emitValueSetFiles(valueSets, outputDir);
-    if (!didGenerateValueSets)
-        cleanupStaleValueSetDir(outputDir);
+    emitValueSetFiles(valueSets, outputDir);
+    emitNamingSystemFiles(readNamingSystemsFromDir(extractedRoot), outputDir);
     const { existingStructureDefinitions, profileIdToName, profileUrlToName, profileUrlToType } = buildProfileRegistries(allSDs, fhirInterfaceNames);
     registerLocalStructureDefinitions(allSDs);
     // PackageManager already loaded and registered dependency SDs above —
@@ -775,19 +833,7 @@ export async function generateIntoPackageDirect(packageArchivePath, flags) {
         finalizePrefabOutput(outputDir, { prefabStylesPath: flags.prefabStyles });
     }
     // Only add subpath exports if their directories were actually created
-    if (fs.existsSync(path.join(outputDir, 'fhir-client'))) {
-        generatedExports['./fhir-client'] = { types: './fhir-client/index.d.ts', import: './fhir-client/index.js' };
-    }
-    if (fs.existsSync(path.join(outputDir, 'dicomweb'))) {
-        generatedExports['./dicomweb'] = { types: './dicomweb/index.d.ts', import: './dicomweb/index.js' };
-        generatedExports['./dicomweb/cornerstone'] = { types: './dicomweb/cornerstone.d.ts', import: './dicomweb/cornerstone.js' };
-    }
-    if (fs.existsSync(path.join(outputDir, 'prefab'))) {
-        generatedExports['./prefab'] = { types: './prefab/index.d.ts', import: './prefab/index.js' };
-    }
-    if (fs.existsSync(path.join(outputDir, 'valuesets'))) {
-        generatedExports['./valuesets/*'] = { types: './valuesets/*.d.ts', import: './valuesets/*.js' };
-    }
+    addOptionalSubpathExports(outputDir, generatedExports);
     const generatedPackageJsonPath = path.join(outputDir, 'package.json');
     fs.writeFileSync(generatedPackageJsonPath, JSON.stringify(generatedPackageJson, null, 2));
     logger.log(`Created package.json in generated folder: ${packageName}-generated@${packageVersion}`);
@@ -918,9 +964,8 @@ export async function generateForDirectory(inputDir, outputDir, flags) {
     }
     // Generate TypeScript files for ValueSets
     endPhase = startPhase('generate');
-    if (!emitValueSetFiles(valueSets, outputDir)) {
-        cleanupStaleValueSetDir(outputDir);
-    }
+    emitValueSetFiles(valueSets, outputDir);
+    emitNamingSystemFiles(readNamingSystemsFromDir(inputDir), outputDir);
     const { existingStructureDefinitions, profileIdToName, profileUrlToName, profileUrlToType } = buildProfileRegistries(allLocalSDs, fhirInterfaceNames);
     // Register all local StructureDefinitions for resolution before HTTP fetches
     registerLocalStructureDefinitions(allLocalSDs);

package/out/src/generator/parser/packageManager.js

@@ -30,8 +30,8 @@ export class PackageManager {
     parsePackageReference(ref) {
         // Handle # separator (FHIR package format)
         if (ref.includes('#')) {
-            const [name, version] = ref.split('#');
-            return { name, version, original: ref };
+            const hashIndex = ref.indexOf('#');
+            return { name: ref.substring(0, hashIndex), version: ref.substring(hashIndex + 1), original: ref };
         }
         // Handle @ separator (npm format)
         if (ref.includes('@') && !ref.startsWith('@')) {
@@ -111,11 +111,11 @@ export class PackageManager {
                 return closestHigher.pkg;
             }
             // No higher version, return highest available
-            return sortedByVersion[sortedByVersion.length - 1]?.pkg || matchingPackages[0];
+            return sortedByVersion[sortedByVersion.length - 1]?.pkg ?? matchingPackages[0] ?? null;
         }
         // Return the first (or only) matching package
         // Could be enhanced to prefer stable versions, latest, etc.
-        return matchingPackages[0];
+        return matchingPackages[0] ?? null;
     }
     /**
      * Find all packages that match a pattern (supports wildcards)