babelfhir-ts 1.5.21 → 1.6.0

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

@@ -3,6 +3,7 @@
  * and required ValueSet bindings.
  */
 import { sanitizeValueSetName } from '../valueset/valueSetGenerator.js';
+import { scopeConstraintExpression } from '../validator/validatorExpressions.js';
 /** Escape double-quote characters in refinement messages */
 function escStr(s) {
     return s.replace(/"/g, '\\"');
@@ -11,8 +12,11 @@ function escStr(s) {
  * Build refinement chains for pattern constraints, required slice cardinalities,
  * and FHIRPath invariants. Returns refinement code strings plus tracked constraint metadata.
  */
-export function buildRefinements(allFields, rootPrefix, valueSets) {
+export function buildRefinements(allFields, rootPrefix, valueSets, 
+/** See generateZodSchema's `emitInvariants`: opt-in, for the per-parse cost. */
+emitInvariants = false) {
     const refinements = [];
+    const invariantEvaluators = [];
     const bindingVsImports = new Map();
     // Build set of direct (root-level) field names for safety checks
     const directFieldNames = new Set();
@@ -163,10 +167,42 @@ export function buildRefinements(allFields, rootPrefix, valueSets) {
             unsupportedConstraints.push(meta);
         }
         else {
-            // Supported but not yet emitted — future FHIRPath→JS translation point
             supportedConstraints.push(meta);
         }
     }
+    // Emit the supported invariants.
+    //
+    // These were tracked and never emitted, on the premise that FHIRPath
+    // evaluation is async while Zod refinements are synchronous. Neither half
+    // holds: fhirpath.js returns an array and only returns a Promise when async
+    // mode is opted into, which it needs solely for memberOf()/resolve() — and
+    // those are already in `unsupportedConstraints` above. So every constraint
+    // here evaluates synchronously inside a plain refinement, and `safeParse`
+    // keeps working for consumers.
+    //
+    // The expression goes through the same scoping the validator uses, and the
+    // message repeats its wording, so the two agree per profile rather than
+    // reporting the same defect under different text.
+    supportedConstraints.forEach((meta, i) => {
+        if (!emitInvariants)
+            return;
+        const scoped = scopeConstraintExpression(meta.expression, meta.fieldPath);
+        if (!scoped)
+            return;
+        const human = escStr(meta.human).replace(/[\r\n]+/g, ' ');
+        const fn = `_inv${i}`;
+        // Compiled once at module load, not per parse. `evaluate` re-parses the
+        // expression on every call, which cost ~0.3ms each: 69 invariants made a
+        // C4BBOrganization parse 242x slower on an empty resource and 964x on a
+        // populated one. `compile` parses once and returns a reusable evaluator.
+        //
+        // traceFn is silenced deliberately: fhirpath's trace() defaults to writing
+        // to the console, so a schema parse would print "TRACE:[…]" out of a
+        // published package.
+        invariantEvaluators.push(`const ${fn} = fhirpath.compile("${scoped}", fhirpath_model, { preciseMath: true, traceFn: () => {} });`);
+        refinements.push(`.refine(d => { try { const _r = ${fn}(d, { resource: d, rootResource: d }); return Array.isArray(_r) ? _r.every(Boolean) : true; } catch { return true; } },`
+            + ` { message: "Constraint violation: ${human}", when: () => true })`);
+    });
     // 4. Meta sub-field constraints
     // When a profile constrains meta.lastUpdated, meta.profile, etc. with min>=1,
     // emit refinements that check for their presence. Uses `when: () => true` so
@@ -253,5 +289,5 @@ export function buildRefinements(allFields, rootPrefix, valueSets) {
             }
         }
     }
-    return { refinements, supportedConstraints, unsupportedConstraints, valueSetImports: bindingVsImports };
+    return { refinements, supportedConstraints, unsupportedConstraints, valueSetImports: bindingVsImports, invariantEvaluators };
 }

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

@@ -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();
@@ -113,14 +122,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) {
@@ -181,7 +198,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 +237,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 +273,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 +294,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} =`);

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 = [];
@@ -279,10 +334,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 +506,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 +597,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 +652,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 +749,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 +831,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 +962,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/packageParser.js

@@ -498,6 +498,20 @@ export function readValueSetCodesFromDir(extractedRoot, codeSystemMap) {
     }
     return map;
 }
+/**
+ * Whether a `dependencies` entry names a FHIR package at a concrete version.
+ *
+ * A FHIR IG manifest lists unscoped names pinned to exact versions. An npm
+ * scope or a semver range means the manifest being read is not an IG's — and
+ * the cache path built from it is unwritable (`<cache>/@types/fhir->=0.0.44
+ * <0.1.0.tgz`), which surfaced as an unhandled rejection from the download
+ * stream and took the whole run down instead of skipping one entry.
+ */
+export function isFhirPackageSpec(depName, depVersion) {
+    if (depName.startsWith('@'))
+        return false;
+    return /^[A-Za-z0-9][A-Za-z0-9.\-+]*$/.test(depVersion);
+}
 /**
  * Recursively ensure all dependency packages are downloaded and extracted.
  * Walks the dependency tree from an extracted package's package.json,
@@ -508,6 +522,10 @@ export async function ensureDependenciesDownloaded(extractedRoot) {
     ensureCacheDir(cacheDir);
     const visited = new Set();
     async function downloadAndExtract(depName, depVersion) {
+        if (!isFhirPackageSpec(depName, depVersion)) {
+            log.warn(`Ignoring dependency that is not a FHIR package spec: ${depName}@${depVersion}`);
+            return null;
+        }
         const depDir = path.join(cacheDir, `${depName}@${depVersion}`);
         // Already cached (@ separator)?
         if (fs.existsSync(depDir) && fs.readdirSync(depDir).length > 0) {
@@ -824,6 +842,64 @@ export function readValueSetsFromDir(extractedRoot) {
     }
     return map;
 }
+/**
+ * Read all NamingSystem resources from an extracted package directory.
+ *
+ * Entries with no `uniqueId` are dropped: there is nothing to emit for them.
+ */
+export function readNamingSystemsFromDir(extractedRoot) {
+    const jsonFiles = findJsonFilesByPrefix(extractedRoot, 'NamingSystem-');
+    const found = [];
+    let skippedRetired = 0;
+    let skippedNoId = 0;
+    for (const file of jsonFiles) {
+        try {
+            const content = JSON.parse(fs.readFileSync(file, 'utf-8'));
+            if (content.resourceType !== 'NamingSystem')
+                continue;
+            if (content.status === 'retired') {
+                skippedRetired++;
+                continue;
+            }
+            const uniqueIds = (Array.isArray(content.uniqueId) ? content.uniqueId : [])
+                .filter((u) => typeof u?.value === 'string' && u.value.length > 0)
+                .map((u) => ({
+                type: u.type || 'other',
+                value: u.value,
+                ...(u.preferred !== undefined && { preferred: u.preferred }),
+                ...(u.comment && { comment: u.comment }),
+            }));
+            // Destructured rather than length-checked: this is what proves the tuple
+            // shape to the compiler, so the emitters need no undefined handling.
+            const [firstId, ...restIds] = uniqueIds;
+            if (!firstId) {
+                skippedNoId++;
+                continue;
+            }
+            const name = content.name || content.title || content.id;
+            if (!name) {
+                skippedNoId++;
+                continue;
+            }
+            found.push({
+                name,
+                ...(content.title && { title: content.title }),
+                ...(content.description && { description: content.description }),
+                ...(content.kind && { kind: content.kind }),
+                uniqueIds: [firstId, ...restIds],
+            });
+            log.debug(`Loaded NamingSystem: ${name} (${uniqueIds.length} uniqueId entries)`);
+        }
+        catch (err) {
+            log.debug(`Skipping invalid JSON while reading NamingSystems ${file}: ${err.message}`);
+        }
+    }
+    // Say what was dropped: a silently shorter list reads as "the IG declares none".
+    if (skippedRetired > 0 || skippedNoId > 0) {
+        log.info(`NamingSystems: emitting ${found.length}, skipped ${skippedRetired} retired and ${skippedNoId} without a usable uniqueId`);
+    }
+    return found;
+}
 /**
  * Read all SearchParameter resources from a package directory.
  * Returns a map of base resource type → array of search parameter definitions.

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

@@ -118,7 +118,9 @@ export function getUniformSystem(valueSet) {
     if (valueSet.concepts.length === 0) {
         return null;
     }
-    const firstSystem = valueSet.concepts[0].system;
+    const firstSystem = valueSet.concepts[0]?.system;
+    if (firstSystem === undefined)
+        return null;
     const allSameSystem = valueSet.concepts.every(c => c.system === firstSystem);
     return allSameSystem ? firstSystem : null;
 }
@@ -222,7 +224,7 @@ export function addPlaceholdersForExternalBindings(valueSets, bindingUrls, fhirC
 function findValueSetInCache(canonicalUrl, fhirCacheDir) {
     // Derive the expected filename from the canonical URL
     // e.g. "http://hl7.org/fhir/ValueSet/mimetypes" → "ValueSet-mimetypes.json"
-    const urlName = canonicalUrl.split('|')[0].split('/').pop();
+    const urlName = (canonicalUrl.split('|')[0] ?? canonicalUrl).split('/').pop();
     if (!urlName)
         return undefined;
     const expectedFilename = `ValueSet-${urlName}.json`;