babelfhir-ts 1.6.9 → 1.6.11

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

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

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

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

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

@@ -119,13 +119,17 @@ export const EMITTED_RANGES = {
      * serializer/renderer pair to apply themes. A 0.2.x renderer would silently
      * drop them.
      *
-     * 0.3.10 is the floor because `AutoFormField` gained `options` there, and the
-     * emitted form now carries the bound ValueSet's concepts on every coded
-     * field. Below it the property is not in the type and is ignored by
-     * `autoForm`, so a required-binding field renders as free text: the form
-     * still builds, and every constraint the binding states is gone from it.
+     * 0.3.12 is the floor, for what the emitted form puts on a coded field.
+     * `AutoFormField` gained `options` in 0.3.10 — below that the property is not
+     * in the type, `autoForm` ignores it, and a bound field renders as free text.
+     * 0.3.12 then moved `required` onto every stateful control and added
+     * `Select({ multiple })`: before it, `autoForm` dropped `required` on the
+     * Select path because the component could not carry it, and a repeating coded
+     * element had no multi-select to render as. On 0.3.10 or 0.3.11 the form still
+     * builds and still offers the right choices, but a required element is not
+     * marked required and a repeating one takes a single value.
      */
-    prefab: '^0.3.10',
+    prefab: '^0.3.12',
     /**
      * Generated FHIR client base package (`@babelfhir-ts/client-<slug>`).
      *

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

@@ -2,18 +2,11 @@ import fs from "fs";
 import path from "path";
 import { logger } from "../../logger.js";
 import { ctx } from '../fhir/versionContext.js';
-/**
- * Strips the version suffix from a FHIR canonical URL.
- * FHIR canonical URLs use '|' to separate the URL from the version.
- * Example: "http://hl7.org/fhir/StructureDefinition/translation|5.3.0-ballot-tc1"
- *       -> "http://hl7.org/fhir/StructureDefinition/translation"
- */
-export function stripVersionFromCanonicalUrl(url) {
-    if (!url)
-        return url;
-    const pipeIndex = url.indexOf('|');
-    return pipeIndex >= 0 ? url.substring(0, pipeIndex) : url;
-}
+// Defined in a leaf module so `constants.ts` can call it without importing this
+// one — see canonicalUrl.ts. Re-exported here because 20+ call sites import it
+// from utils, and used below in this file too.
+import { stripVersionFromCanonicalUrl } from "./canonicalUrl.js";
+export { stripVersionFromCanonicalUrl };
 /**
  * An element path with any slice suffix removed: `identifier:NPI` -> `identifier`.
  *
@@ -341,6 +334,32 @@ export function mergeFields(newFields, oldFields) {
     // Return the merged fields as an array
     return Array.from(fieldMap.values());
 }
+/**
+ * Copies a directory tree, optionally keeping only the files a predicate accepts.
+ *
+ * Shared by the compile-time dependency providers, which each need part of an
+ * installed package inside the output's `node_modules` — the zod runtime whole,
+ * prefab's declarations only.
+ *
+ * @param filter - Called per file with its absolute source path. Omit to copy everything.
+ *                 A directory left empty by the filter is not created.
+ */
+export function copyDirRecursive(src, dest, filter) {
+    for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+        const srcPath = path.join(src, entry.name);
+        const destPath = path.join(dest, entry.name);
+        if (entry.isDirectory()) {
+            fs.mkdirSync(destPath, { recursive: true });
+            copyDirRecursive(srcPath, destPath, filter);
+            if (fs.readdirSync(destPath).length === 0)
+                fs.rmdirSync(destPath);
+        }
+        else if (!filter || filter(srcPath)) {
+            fs.mkdirSync(path.dirname(destPath), { recursive: true });
+            fs.copyFileSync(srcPath, destPath);
+        }
+    }
+}
 /**
  * Ensures the given directory exists, creating it if necessary.
  */

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

@@ -0,0 +1,104 @@
+/**
+ * Makes `@maxhealth.tech/prefab` resolvable while the generated output compiles.
+ *
+ * `--prefab` emits renderers that import the real prefab API, and the emitted
+ * package declares prefab as a dependency — but nothing puts it where the
+ * generator's own `tsc` pass can see it. Every emitted renderer then failed
+ * TS2307 and the whole package failed to compile, so a `--prefab` run produced
+ * no `prefab/` in the shipped package at all. It only ever passed when the
+ * output happened to sit inside a tree that already had prefab installed, which
+ * is why it looks fine from this repo's own `output/` and fails in CI.
+ *
+ * The real declarations are used rather than a stub. The emitted renderers are
+ * checked against prefab's actual component signatures, and their `.d.ts` quotes
+ * prefab's types back to the consumer — a hand-written stub would both drift
+ * from the library and erase those types from the emitted package.
+ *
+ * Two sources, in order: a copy already installed alongside the generator (this
+ * repo, where prefab is a devDependency), else a one-package install from the
+ * registry (an `npx babelfhir-ts` run, which ships no devDependencies). Only
+ * the declarations are copied — `tsc` reads no JavaScript — and whatever this
+ * added is removed after the compile, because the consumer installs the real
+ * dependency themselves.
+ */
+import fs from 'fs';
+import path from 'path';
+import { spawnSync } from 'child_process';
+import { fileURLToPath } from 'url';
+import { copyDirRecursive } from '../../core/utils.js';
+import { EMITTED_RANGES } from '../../core/generatedPackageDeps.js';
+import { logger } from '../../../logger.js';
+const log = logger.withTag('prefab');
+const PACKAGE_NAME = '@maxhealth.tech/prefab';
+const PACKAGE_SEGMENTS = PACKAGE_NAME.split('/');
+/** How far up a tree to look for a `node_modules` holding the package. */
+const MAX_LOOKUP_DEPTH = 8;
+/** The package directory under a given tree root, whether or not it exists. */
+function packageDirIn(root) {
+    return path.join(root, 'node_modules', ...PACKAGE_SEGMENTS);
+}
+/** Walk up from `start`, returning the first installed copy found. */
+function findInstalledCopy(start) {
+    let dir = start;
+    for (let i = 0; i < MAX_LOOKUP_DEPTH; i++) {
+        const candidate = packageDirIn(dir);
+        if (fs.existsSync(path.join(candidate, 'package.json')))
+            return candidate;
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return undefined;
+}
+/** Install the package into the output dir, declarations included. */
+function installFromRegistry(outputDir) {
+    const npm = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+    const spec = `${PACKAGE_NAME}@${EMITTED_RANGES.prefab}`;
+    log.debug(`Installing ${spec} for the output typecheck`);
+    const result = spawnSync(npm, ['install', '--no-save', '--no-package-lock', '--no-audit', '--no-fund',
+        '--prefix', outputDir, spec], { stdio: 'pipe', encoding: 'utf8' });
+    if (result.status !== 0) {
+        log.warn(`Could not install ${spec}: ${result.stderr?.trim() || `exit ${result.status}`}`);
+        return false;
+    }
+    return fs.existsSync(path.join(packageDirIn(outputDir), 'package.json'));
+}
+/**
+ * Ensure the emitted `prefab/` files can be typechecked from `outputDir`.
+ *
+ * @returns a cleanup that removes what this added, and does nothing when the
+ *          package was already resolvable.
+ */
+export function providePrefabTypes(outputDir) {
+    const alreadyResolvable = findInstalledCopy(outputDir);
+    if (alreadyResolvable) {
+        log.debug(`Typechecking prefab output against ${alreadyResolvable}`);
+        return () => { };
+    }
+    const target = packageDirIn(outputDir);
+    const generatorDir = path.dirname(fileURLToPath(import.meta.url));
+    const alongsideGenerator = findInstalledCopy(generatorDir);
+    if (alongsideGenerator) {
+        fs.mkdirSync(target, { recursive: true });
+        // Declarations only: `tsc` never reads the JavaScript, and prefab ships
+        // browser bundles and source maps that would triple the copy for nothing.
+        copyDirRecursive(alongsideGenerator, target, src => src.endsWith('.d.ts') || path.basename(src) === 'package.json');
+    }
+    else if (!installFromRegistry(outputDir)) {
+        throw new Error(`--prefab needs ${PACKAGE_NAME} to typecheck the emitted renderers, and it could not be ` +
+            `resolved next to the generator or installed from the registry. Install ` +
+            `${PACKAGE_NAME}@${EMITTED_RANGES.prefab} where generation runs, or drop --prefab.`);
+    }
+    return () => {
+        try {
+            fs.rmSync(target, { recursive: true, force: true });
+        }
+        catch { /* ignore */ }
+        // Leave `@maxhealth.tech/` behind only while it still holds something else.
+        try {
+            fs.rmdirSync(path.dirname(target));
+        }
+        catch { /* not empty — fine */ }
+    };
+}

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

@@ -89,9 +89,12 @@ function emitFormFields(descriptors) {
         // Forms can't capture complex nested structures cleanly; skip them.
         if (d.kind === 'nested' || d.kind === 'json' || d.kind === 'image' || d.kind === 'dicom')
             continue;
-        if (d.isArray)
-            continue; // v1: scalars only
         const options = d.enumOptions?.length ? d.enumOptions : undefined;
+        // A repeating element is only expressible as a form field when the choices
+        // are enumerated: prefab's multi-select submits a list under the name, which
+        // is the element's own shape. Any other array still has no control.
+        if (d.isArray && !options)
+            continue;
         let type = 'text';
         if (d.kind === 'number')
             type = 'number';
@@ -106,6 +109,8 @@ function emitFormFields(descriptors) {
             extra.push('required: true');
         if (options)
             extra.push(`options: ${emitOptionsLiteral(options)}`);
+        if (d.isArray)
+            extra.push('multiple: true');
         lines.push(`    { ${extra.join(', ')} },`);
         seen.add(d.name);
     }

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

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

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

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

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

@@ -12,6 +12,7 @@ import path from 'path';
 import { fileURLToPath } from 'url';
 import { versionSlug } from '../../fhir/versionContext.js';
 import { getZodPackageTypes } from './zodTypes.js';
+import { copyDirRecursive } from '../../core/utils.js';
 /** Resolve the repo root from this file's location (src/generator/emitters/zod/) */
 function findRepoRoot() {
     const selfDir = path.dirname(fileURLToPath(import.meta.url));
@@ -26,20 +27,6 @@ function findRepoRoot() {
     }
     return path.resolve(selfDir, '..', '..', '..', '..');
 }
-/** Recursively copy a directory's contents, handling nested subdirectories. */
-function copyDirRecursive(src, dest) {
-    for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
-        const srcPath = path.join(src, entry.name);
-        const destPath = path.join(dest, entry.name);
-        if (entry.isDirectory()) {
-            fs.mkdirSync(destPath, { recursive: true });
-            copyDirRecursive(srcPath, destPath);
-        }
-        else {
-            fs.copyFileSync(srcPath, destPath);
-        }
-    }
-}
 export function installBaseZodTypes(outputDir) {
     const slug = versionSlug();
     const pkgDir = path.join(outputDir, 'node_modules', '@babelfhir-ts', 'zod');

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

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

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

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

package/out/src/generator/index.js

@@ -619,10 +619,19 @@ export async function generateIntoPackage(packageArchivePath, outArchivePath, fl
         // Install fhirpath type stub so tsc can resolve validator imports
         const { installFhirpathStub, removeFhirpathStub } = await import('./emitters/validator/fhirpathStubInstaller.js');
         installFhirpathStub(outputDir);
+        // Emitted renderers import the real prefab API, which nothing has installed here yet
+        const releasePrefabTypes = flags?.prefab
+            ? (await import('./emitters/prefab/prefabDepProvider.js')).providePrefabTypes(outputDir)
+            : undefined;
         // Compile TypeScript to JavaScript
         endPhase = startPhase('compile');
         logger.log('Compiling TypeScript to JavaScript...');
-        await compileTypeScriptToJS(outputDir);
+        try {
+            await compileTypeScriptToJS(outputDir);
+        }
+        finally {
+            releasePrefabTypes?.();
+        }
         endPhase(); // compile
         // Remove fhirpath stub — the real package is a peer dependency
         removeFhirpathStub(outputDir);
@@ -841,9 +850,17 @@ export async function generateIntoPackageDirect(packageArchivePath, flags) {
     }
     const { installFhirpathStub, removeFhirpathStub } = await import('./emitters/validator/fhirpathStubInstaller.js');
     installFhirpathStub(outputDir);
+    const releasePrefabTypes = flags?.prefab
+        ? (await import('./emitters/prefab/prefabDepProvider.js')).providePrefabTypes(outputDir)
+        : undefined;
     endPhase = startPhase('compile');
     logger.log('Compiling TypeScript to JavaScript...');
-    await compileTypeScriptToJS(outputDir);
+    try {
+        await compileTypeScriptToJS(outputDir);
+    }
+    finally {
+        releasePrefabTypes?.();
+    }
     endPhase(); // compile
     removeFhirpathStub(outputDir);
     const babelfhirDir = path.join(outputDir, 'node_modules', '@babelfhir-ts');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "babelfhir-ts",
-  "version": "1.6.9",
+  "version": "1.6.11",
   "description": "BabelFHIR-TS: generate TypeScript interfaces, validators, and helper classes from FHIR R4/R4B/R5 StructureDefinitions (profiles) directly inside package archives.",
   "type": "module",
   "main": "out/src/main.js",
@@ -86,32 +86,32 @@
   },
   "devDependencies": {
     "@eslint/js": "^10.0.1",
-    "@max-health-inc/config": "^3.1.0",
-    "@maxhealth.tech/prefab": "^0.3.11",
-    "@types/node": "^25.9.5",
+    "@max-health-inc/config": "^3.3.0",
+    "@maxhealth.tech/prefab": "^0.3.12",
+    "@types/node": "^26.4.0",
     "@types/semver": "^7.8.0",
     "@types/unzipper": "^0.10.11",
-    "@vitest/coverage-v8": "^4.1.10",
-    "@vitest/eslint-plugin": "^1.6.26",
-    "@vitest/ui": "^4.1.10",
+    "@vitest/coverage-v8": "^4.1.11",
+    "@vitest/eslint-plugin": "^1.6.27",
+    "@vitest/ui": "^4.1.11",
     "cross-env": "^10.1.0",
-    "eslint": "^10.8.0",
+    "eslint": "^10.9.1",
     "fhirpath": "^5.2.0",
-    "globals": "^17.9.0",
+    "globals": "^17.11.0",
     "rimraf": "^6.1.3",
     "semver": "^7.8.5",
     "typescript": "^6.0.3",
-    "typescript-eslint": "^8.66.0",
+    "typescript-eslint": "^8.68.0",
     "vitepress": "^1.6.4",
-    "vitepress-plugin-llms": "^1.13.4",
-    "vitest": "^4.1.10",
-    "zod": "4.3.6"
+    "vitepress-plugin-llms": "^1.13.5",
+    "vitest": "^4.1.11",
+    "zod": "4.4.3"
   },
   "dependencies": {
     "@types/fhir": "^0.0.44",
     "consola": "^3.4.2",
     "tar": "^7.5.22",
-    "tsx": "^4.23.7",
+    "tsx": "^4.23.12",
     "unzipper": "^0.12.5"
   },
   "overrides": {