@atomic-ehr/codegen 0.0.18 → 0.0.19-canary.20260921150939.55823d6

package/dist/index.js

@@ -1,13 +1,14 @@
 import pc from 'picocolors';
 import assert4 from 'assert';
 import * as fs from 'fs';
-import fs__default from 'fs';
+import fs__default, { existsSync } from 'fs';
 import * as Path5 from 'path';
 import Path5__default from 'path';
 import { CanonicalManager } from '@atomic-ehr/fhir-canonical-manager';
-import { fileURLToPath } from 'url';
+import { excludeCanonical } from '@atomic-ehr/fhir-canonical-manager/patch';
 import * as fsPromises from 'fs/promises';
 import { createHash } from 'crypto';
+import { fileURLToPath } from 'url';
 import * as YAML from 'yaml';
 import YAML__default from 'yaml';
 import * as fhirschema from '@atomic-ehr/fhirschema';
@@ -108,6 +109,42 @@ function mkLogger(opts = {}) {
 
 // src/utils/log.ts
 var mkCodegenLogger = (opts = {}) => mkLogger(opts);
+var codeableReferenceInR4 = "Use CodeableReference which is not provided by FHIR R4.";
+var availabilityInR4 = "Use Availability which is not provided by FHIR R4.";
+var R4_EXTENSIONS = [
+  ["biologicallyderivedproduct-manipulation", codeableReferenceInR4],
+  ["biologicallyderivedproduct-processing", codeableReferenceInR4],
+  ["extended-contact-availability", availabilityInR4],
+  ["immunization-procedure", codeableReferenceInR4],
+  ["specimen-additive", codeableReferenceInR4],
+  ["workflow-barrier", codeableReferenceInR4],
+  ["workflow-protectiveFactor", codeableReferenceInR4],
+  ["workflow-reason", codeableReferenceInR4]
+];
+var R4_EXTENSIONS_BROKEN_VERSIONS = ["0.1.0", "1.0.0", "5.1.0", "5.2.0"];
+var builtinPatches = {
+  indexEntry: [
+    ...R4_EXTENSIONS_BROKEN_VERSIONS.flatMap(
+      (version) => R4_EXTENSIONS.map(
+        ([name, reason]) => excludeCanonical({
+          package: { name: "hl7.fhir.uv.extensions.r4", version },
+          url: `http://hl7.org/fhir/StructureDefinition/${name}`,
+          reason
+        })
+      )
+    ),
+    excludeCanonical({
+      package: { name: "hl7.fhir.r5.core", version: "5.0.0" },
+      url: "http://hl7.org/fhir/StructureDefinition/shareablecodesystem",
+      reason: "FIXME: CodeSystem.concept.concept defined by ElementReference. FHIR Schema generator output broken value in it, so we just skip it for now."
+    }),
+    excludeCanonical({
+      package: { name: "hl7.fhir.r5.core", version: "5.0.0" },
+      url: "http://hl7.org/fhir/StructureDefinition/publishablecodesystem",
+      reason: "Uses R5-only base types not available in R4 generation."
+    })
+  ]
+};
 
 // src/api/writer-generator/utils.ts
 var WORD_SPLIT_RE = /(?<=[a-z])(?=[A-Z])|[-_.\s]/;
@@ -220,7 +257,7 @@ var FileSystemWriter = class {
       absPath: Path5.resolve(destination),
       tokens: [content]
     };
-    fs.cpSync(source, destination);
+    if (!this.opts.inMemoryOnly) fs.cpSync(source, destination);
   }
   cp(source, destination) {
     if (!this.opts.resolveAssets) throw new Error("resolveAssets is not defined");
@@ -232,7 +269,7 @@ var FileSystemWriter = class {
       absPath: Path5.resolve(destination),
       tokens: [content]
     };
-    fs.cpSync(source, destination);
+    if (!this.opts.inMemoryOnly) fs.cpSync(source, destination);
   }
   writtenFiles() {
     return Object.values(this.writtenFilesBuffer).map(({ relPath, absPath, tokens }) => {
@@ -240,6 +277,7 @@ var FileSystemWriter = class {
     }).sort((a, b) => a.relPath.localeCompare(b.relPath));
   }
   async flushAsync() {
+    if (this.opts.inMemoryOnly) return;
     const files = this.writtenFiles();
     const dirs = /* @__PURE__ */ new Set();
     for (const file of files) {
@@ -457,6 +495,22 @@ var enrichValueSet = (vs, packageMeta2) => {
     url: vs.url
   };
 };
+var ASSET_ROOT_SEGMENTS = ["assets", "api", "writer-generator"];
+var MAX_LOOKUP_DEPTH = 12;
+var resolveGeneratorAsset = (moduleUrl, language, fn) => {
+  const searched = [];
+  let directory = Path5.dirname(fileURLToPath(moduleUrl));
+  for (let depth = 0; depth < MAX_LOOKUP_DEPTH; depth++) {
+    const candidate = Path5.resolve(directory, ...ASSET_ROOT_SEGMENTS, language, fn);
+    searched.push(candidate);
+    if (existsSync(candidate)) return candidate;
+    const parent = Path5.dirname(directory);
+    if (parent === directory) break;
+    directory = parent;
+  }
+  throw new Error(`Cannot locate generator asset ${language}/${fn}. Looked in:
+  ${searched.join("\n  ")}`);
+};
 
 // src/api/writer-generator/csharp/formatHelper.ts
 var ops = {
@@ -505,14 +559,7 @@ function formatName(input) {
 }
 
 // src/api/writer-generator/csharp/csharp.ts
-var resolveCSharpAssets = (fn) => {
-  const __filename = fileURLToPath(import.meta.url);
-  const __dirname = Path5__default.dirname(__filename);
-  if (__filename.endsWith("dist/index.js")) {
-    return Path5__default.resolve(__dirname, "..", "assets", "api", "writer-generator", "csharp", fn);
-  }
-  return Path5__default.resolve(__dirname, "../../../..", "assets", "api", "writer-generator", "csharp", fn);
-};
+var resolveCSharpAssets = (fn) => resolveGeneratorAsset(import.meta.url, "csharp", fn);
 var PRIMITIVE_TYPE_MAP = {
   boolean: "bool",
   instant: "string",
@@ -851,6 +898,7 @@ var PYTHON_KEYWORDS = /* @__PURE__ */ new Set([
 var fixReservedWords = (name) => {
   return PYTHON_KEYWORDS.has(name) ? `${name}_` : name;
 };
+var LEADING_DIGIT_RE3 = /^\d/;
 var canonicalToName2 = (canonical, dropFragment = true) => {
   if (!canonical) return void 0;
   let localName = canonical.split("/").pop();
@@ -859,7 +907,7 @@ var canonicalToName2 = (canonical, dropFragment = true) => {
     localName = localName.split("#")[0];
   }
   if (!localName) return void 0;
-  if (/^\d/.test(localName)) {
+  if (LEADING_DIGIT_RE3.test(localName)) {
     localName = `number_${localName}`;
   }
   return snakeCase(localName);
@@ -898,13 +946,8 @@ var pyTypeFromIdentifier = (id) => {
 };
 var pyReferenceTypeParam = (field, tsIndex) => {
   if (!field.reference || field.reference.resource.length === 0) return void 0;
-  const isFamilyType = (ref) => {
-    const schema = tsIndex.resolveType(ref);
-    if (!schema || !("typeFamily" in schema)) return false;
-    return (schema.typeFamily?.resources?.length ?? 0) > 0;
-  };
   const resolved = field.reference.resource.map((ref) => tsIndex.findLastSpecializationByIdentifier(ref));
-  if (resolved.some(isFamilyType)) return void 0;
+  if (resolved.some(tsIndex.isFamilyType)) return void 0;
   const names = [...new Set(resolved.map((ref) => ref.name))];
   return `Literal[${names.map((n) => JSON.stringify(n)).join(", ")}]`;
 };
@@ -1181,7 +1224,7 @@ var mkTypeSchemaIndex = (schemas, {
     append(schema);
   }
   populateTypeFamily(schemas);
-  const resolve6 = ((id) => {
+  const resolve5 = ((id) => {
     if (isSnapshotProfileIdentifier(id)) return snapshotIndex[id.url]?.[id.package];
     return index[id.url]?.[id.package];
   });
@@ -1226,7 +1269,7 @@ var mkTypeSchemaIndex = (schemas, {
       const base = cur.base;
       if (base === void 0) break;
       if (isNestedIdentifier(base)) break;
-      const resolved = resolve6(base);
+      const resolved = resolve5(base);
       if (!resolved) {
         logger?.warn(
           "#resolveBase",
@@ -1260,6 +1303,11 @@ var mkTypeSchemaIndex = (schemas, {
     if (isNestedTypeSchema(resolved)) return findLastSpecializationByIdentifier(resolved.base);
     return findLastSpecialization(resolved).identifier;
   };
+  const isFamilyType = (id) => {
+    const schema = resolveType(id);
+    if (!schema || !("typeFamily" in schema)) return false;
+    return (schema.typeFamily?.resources?.length ?? 0) > 0;
+  };
   const narrowMergedChoiceDeclarations = (mergedFields, constraintSchemas, baseFields = {}) => {
     const result = { ...mergedFields };
     const declNames = /* @__PURE__ */ new Set([...Object.keys(result), ...Object.keys(baseFields)]);
@@ -1388,6 +1436,14 @@ var mkTypeSchemaIndex = (schemas, {
     }
     return void 0;
   };
+  const sliceChoiceVariants = (pkgName, baseTypeId, sliceElements, name) => {
+    const baseSchema = resolveByUrl(pkgName, baseTypeId.url);
+    if (!baseSchema || !("fields" in baseSchema) || !baseSchema.fields) return void 0;
+    const field = baseSchema.fields[name];
+    if (!field || !isChoiceDeclarationField(field)) return void 0;
+    const narrowed = field.choices.filter((c) => sliceElements.includes(c));
+    return narrowed.length > 0 ? narrowed : field.choices;
+  };
   const isWithMetaField = (profile) => {
     const genealogy = tryHierarchy(profile);
     if (!genealogy) return false;
@@ -1431,15 +1487,17 @@ var mkTypeSchemaIndex = (schemas, {
     collectLogicalModels: () => schemas.filter(isLogicalTypeSchema),
     collectProfiles: () => schemas.filter(isProfileTypeSchema),
     collectSnapshotProfiles,
-    resolve: resolve6,
+    resolve: resolve5,
     resolveType,
     resolveByUrl,
     tryHierarchy,
     hierarchy,
     findLastSpecialization,
     findLastSpecializationByIdentifier,
+    isFamilyType,
     flatProfile,
     constrainedChoice,
+    sliceChoiceVariants,
     isWithMetaField,
     entityTree,
     exportTree,
@@ -1452,7 +1510,7 @@ var mkTypeSchemaIndex = (schemas, {
 var normalizePyName = (n) => {
   let out = n.replace(/\[x\]/g, "_x_").replace(/[- :./]/g, "_");
   if (PYTHON_KEYWORDS.has(out)) out = `${out}_`;
-  if (/^\d/.test(out)) out = `_${out}`;
+  if (LEADING_DIGIT_RE3.test(out)) out = `_${out}`;
   return out;
 };
 var pySnakeName = (name) => {
@@ -1997,7 +2055,7 @@ var collectProfileFactoryInfo = (tsIndex, flatProfile) => {
       tryPromoteChoice(field, fields, params, promotedChoices, tsIndex);
       continue;
     }
-    if (field.valueConstraint) {
+    if (field.valueConstraint && !field.valueConstraint.validateOnly) {
       const value = JSON.stringify(field.valueConstraint.value);
       autoFields.push({ name, value: field.array ? `[${value}]` : value });
       if (isNotChoiceDeclarationField(field) && field.type) {
@@ -2216,11 +2274,10 @@ var collectRegularFieldValidation = (field, fieldSlicing, pyName, helpers, error
     errorLines.push(`errors.extend(validate_required(self._resource, profile_name, ${JSON.stringify(pyName)}))`);
   }
   if (field.valueConstraint) {
-    helpers.add("validate_fixed_value");
+    const fn = field.valueConstraint.validateOnly ? "validate_pattern_value" : "validate_fixed_value";
+    helpers.add(fn);
     const value = JSON.stringify(field.valueConstraint.value);
-    errorLines.push(
-      `errors.extend(validate_fixed_value(self._resource, profile_name, ${JSON.stringify(pyName)}, ${value}))`
-    );
+    errorLines.push(`errors.extend(${fn}(self._resource, profile_name, ${JSON.stringify(pyName)}, ${value}))`);
   }
   if (isNotChoiceDeclarationField(field)) {
     if (field.enum) {
@@ -2245,6 +2302,23 @@ var collectRegularFieldValidation = (field, fieldSlicing, pyName, helpers, error
     }
   }
 };
+var collectSliceRequirements = (slice, match, field, tsIndex, formatName2) => {
+  const requiredFields = [];
+  const choiceGroups = [];
+  const matchKeys = new Set(Object.keys(match));
+  const requiredNames = (slice.required ?? []).filter((rf) => !matchKeys.has(rf));
+  const fieldType = field.type;
+  for (const rf of requiredNames) {
+    const variants = fieldType ? tsIndex.sliceChoiceVariants(fieldType.package, fieldType, slice.elements ?? [], rf) : void 0;
+    if (variants && variants.length > 0) choiceGroups.push(variants.map((v) => pyFieldName(v, formatName2)));
+    else requiredFields.push(pyFieldName(rf, formatName2));
+  }
+  if (fieldType && slice.elements) {
+    const cc = tsIndex.constrainedChoice(fieldType.package, fieldType, slice.elements);
+    if (cc && !requiredNames.includes(cc.choiceBase)) requiredFields.push(pyFieldName(cc.variant, formatName2));
+  }
+  return { requiredFields, choiceGroups };
+};
 var collectSliceValidation = (field, fieldSlicing, name, helpers, errorLines, tsIndex, formatName2) => {
   if (!fieldSlicing.slices) return;
   for (const [sliceName, slice] of Object.entries(fieldSlicing.slices)) {
@@ -2258,25 +2332,21 @@ var collectSliceValidation = (field, fieldSlicing, name, helpers, errorLines, ts
         `errors.extend(validate_slice_cardinality(self._resource, profile_name, ${JSON.stringify(name)}, ${JSON.stringify(match)}, ${JSON.stringify(sliceName)}, ${min}, ${max}))`
       );
     }
-    const sliceRequiredFields = [];
-    const matchKeys = new Set(Object.keys(match));
-    for (const rf of slice.required ?? []) {
-      if (!matchKeys.has(rf)) sliceRequiredFields.push(pyFieldName(rf, formatName2));
-    }
-    if (field.type && slice.elements) {
-      const cc = tsIndex.constrainedChoice(field.type.package, field.type, slice.elements);
-      if (cc) sliceRequiredFields.push(pyFieldName(cc.variant, formatName2));
-    }
-    if (sliceRequiredFields.length > 0) {
-      helpers.add("validate_slice_fields");
-      pushListValidation(
-        errorLines,
-        "errors",
-        "validate_slice_fields",
-        [JSON.stringify(name), JSON.stringify(match), JSON.stringify(sliceName)],
-        sliceRequiredFields
-      );
+    const { requiredFields, choiceGroups } = collectSliceRequirements(slice, match, field, tsIndex, formatName2);
+    if (requiredFields.length === 0 && choiceGroups.length === 0) continue;
+    helpers.add("validate_slice_fields");
+    const args = [JSON.stringify(name), JSON.stringify(match), JSON.stringify(sliceName)];
+    if (choiceGroups.length === 0) {
+      pushListValidation(errorLines, "errors", "validate_slice_fields", args, requiredFields);
+      continue;
     }
+    pushListValidation(
+      errorLines,
+      "errors",
+      "validate_slice_fields",
+      [...args, JSON.stringify(requiredFields)],
+      choiceGroups
+    );
   }
 };
 
@@ -2511,7 +2581,7 @@ var generateProfileModule = (w, tsIndex, flatProfile) => {
   const sliceDefs = collectSliceDefs(tsIndex, flatProfile);
   const typedResources = [
     ...new Set(
-      sliceDefs.filter((s) => s.isTypeDiscriminated && s.typeDiscriminatorResource).map((s) => s.typeDiscriminatorResource)
+      sliceDefs.filter((s) => s.isTypeDiscriminated).map((s) => s.typeDiscriminatorResource).filter((resource) => resource !== void 0)
     )
   ];
   const annotatedBaseTypeName = typedResources.length > 0 ? `${baseTypeName}[${typedResources.join(" | ")}, Resource]` : baseTypeName;
@@ -2610,14 +2680,7 @@ var generateNewProfiles = (w, tsIndex, profiles) => {
 };
 
 // src/api/writer-generator/python/writer.ts
-var resolvePyAssets = (fn) => {
-  const __dirname = Path5.dirname(fileURLToPath(import.meta.url));
-  const __filename = fileURLToPath(import.meta.url);
-  if (__filename.endsWith("dist/index.js")) {
-    return Path5.resolve(__dirname, "..", "assets", "api", "writer-generator", "python", fn);
-  }
-  return Path5.resolve(__dirname, "../../../..", "assets", "api", "writer-generator", "python", fn);
-};
+var resolvePyAssets = (fn) => resolveGeneratorAsset(import.meta.url, "python", fn);
 var AVAILABLE_STRING_FORMATS = {
   snake_case: snakeCase,
   PascalCase: pascalCase,
@@ -3192,372 +3255,198 @@ var collisionSourcesKey = (sources) => JSON.stringify(
 );
 var compareCollisionVariants = (left, right) => right.sources.length - left.sources.length || compareStrings(collisionSourcesKey(left.sources), collisionSourcesKey(right.sources)) || compareStrings(left.schemaHash, right.schemaHash);
 
-// src/typeschema/skip-hack.ts
-var codeableReferenceInR4 = "Use CodeableReference which is not provided by FHIR R4.";
-var availabilityInR4 = "Use Availability which is not provided by FHIR R4.";
-var skipList = {
-  "hl7.fhir.uv.extensions.r4": {
-    "http://hl7.org/fhir/StructureDefinition/biologicallyderivedproduct-manipulation": codeableReferenceInR4,
-    "http://hl7.org/fhir/StructureDefinition/biologicallyderivedproduct-processing": codeableReferenceInR4,
-    "http://hl7.org/fhir/StructureDefinition/extended-contact-availability": availabilityInR4,
-    "http://hl7.org/fhir/StructureDefinition/immunization-procedure": codeableReferenceInR4,
-    "http://hl7.org/fhir/StructureDefinition/specimen-additive": codeableReferenceInR4,
-    "http://hl7.org/fhir/StructureDefinition/workflow-barrier": codeableReferenceInR4,
-    "http://hl7.org/fhir/StructureDefinition/workflow-protectiveFactor": codeableReferenceInR4,
-    "http://hl7.org/fhir/StructureDefinition/workflow-reason": codeableReferenceInR4
-  },
-  "hl7.fhir.r5.core#5.0.0": {
-    "http://hl7.org/fhir/StructureDefinition/shareablecodesystem": "FIXME: CodeSystem.concept.concept defined by ElementReference. FHIR Schema generator output broken value in it, so we just skip it for now.",
-    "http://hl7.org/fhir/StructureDefinition/publishablecodesystem": "Uses R5-only base types not available in R4 generation."
-  }
+// src/fhir-types/hl7-fhir-r4-core/CodeSystem.ts
+var isCodeSystem = (resource) => {
+  return resource !== null && typeof resource === "object" && resource.resourceType === "CodeSystem";
 };
-function shouldSkipCanonical(packageMeta2, canonicalUrl) {
-  const pkgId = `${packageMeta2.name}#${packageMeta2.version}`;
-  const reasonByPkgId = skipList[pkgId]?.[canonicalUrl];
-  if (reasonByPkgId) {
-    return { shouldSkip: true, reason: reasonByPkgId };
-  }
-  const reasonByName = skipList[packageMeta2.name]?.[canonicalUrl];
-  if (reasonByName) {
-    return { shouldSkip: true, reason: reasonByName };
-  }
-  return { shouldSkip: false };
-}
 
-// src/typeschema/core/identifier.ts
-function dropVersionFromUrl(url) {
-  const baseUrl = url.split("|")[0];
-  return baseUrl ? baseUrl : url;
-}
-function getVersionFromUrl(url) {
-  const version = url.split("|")[1];
-  return version;
-}
-var identifierBase = (fhirSchema) => ({
-  package: fhirSchema.package_meta.name,
-  version: fhirSchema.package_meta.version,
-  name: fhirSchema.name,
-  url: fhirSchema.url
-});
-function mkIdentifier(fhirSchema) {
-  const fields = identifierBase(fhirSchema);
-  if (fhirSchema.derivation === "constraint") return { kind: "profile", ...fields };
-  if (fhirSchema.kind === "primitive-type") return { kind: "primitive-type", ...fields };
-  if (fhirSchema.kind === "complex-type") return { kind: "complex-type", ...fields };
-  if (fhirSchema.kind === "resource") return { kind: "resource", ...fields };
-  if (fhirSchema.kind === "logical") return { kind: "logical", ...fields };
-  return { kind: "resource", ...fields };
-}
-var VALUE_SET_NAME_SPLIT_RE = /[-_]/;
-var OPAQUE_VALUE_SET_ID_RE = /^[a-zA-Z0-9_-]{20,}$/;
-var getValueSetName = (url) => {
-  const urlParts = url.split("/");
-  const lastSegment = urlParts[urlParts.length - 1];
-  if (lastSegment && lastSegment.length > 0) {
-    return lastSegment.split(VALUE_SET_NAME_SPLIT_RE).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("");
-  }
-  return url;
+// src/fhir-types/hl7-fhir-r4-core/ValueSet.ts
+var isValueSet = (resource) => {
+  return resource !== null && typeof resource === "object" && resource.resourceType === "ValueSet";
 };
-function mkValueSetIdentifierByUrl(register, pkg, fullValueSetUrl) {
-  const valueSetUrl = dropVersionFromUrl(fullValueSetUrl);
-  const valueSetNameFallback = getValueSetName(valueSetUrl);
-  const valuesSetFallback = {
-    package_meta: {
-      name: "missing_valuesets",
-      version: getVersionFromUrl(valueSetUrl) || "0.0.0"
-    },
-    id: fullValueSetUrl};
-  const valueSet = register.resolveVs(pkg, valueSetUrl) || valuesSetFallback;
-  const valueSetName = valueSet?.id && !OPAQUE_VALUE_SET_ID_RE.test(valueSet.id) ? valueSet.id : valueSetNameFallback;
-  return {
-    kind: "value-set",
-    package: valueSet.package_meta.name,
-    version: valueSet.package_meta.version,
-    name: valueSetName,
-    url: valueSetUrl
-  };
-}
-function mkBindingIdentifier(fhirSchema, path, element) {
-  const bindingName = element.binding?.bindingName;
-  const pathStr = path.join(".");
-  const [pkg, name, url] = bindingName ? [{ name: "shared", version: "1.0.0" }, bindingName, `urn:fhir:binding:${bindingName}`] : [fhirSchema.package_meta, `${fhirSchema.name}.${pathStr}_binding`, `${fhirSchema.url}#${pathStr}_binding`];
-  return {
-    kind: "binding",
-    package: pkg.name,
-    version: pkg.version,
-    name,
-    url
-  };
-}
 
-// src/typeschema/core/binding.ts
-function extractValueSetConceptsByUrl(register, pkg, valueSetUrl, logger) {
-  const cleanUrl = dropVersionFromUrl(valueSetUrl) || valueSetUrl;
-  const valueSet = register.resolveVs(pkg, cleanUrl);
-  if (!valueSet) return void 0;
-  return extractValueSetConcepts(register, valueSet);
-}
-function extractValueSetConcepts(register, valueSet, _logger) {
-  if (valueSet.expansion?.contains) {
-    return valueSet.expansion.contains.filter((item) => item.code !== void 0).map((item) => {
-      assert4(item.code);
-      return {
-        code: item.code,
-        display: item.display,
-        system: item.system
-      };
+// src/typeschema/register.ts
+var BARE_RESOURCE_NAME_RE = /^[a-zA-Z0-9]+$/;
+var FHIR_BASE_CANONICAL = "http://hl7.org/fhir/StructureDefinition/Base";
+var isVirtualFhirBaseCanonical = (ref) => {
+  const [name, version] = ref.split("|");
+  const canonical = BARE_RESOURCE_NAME_RE.test(name) ? `http://hl7.org/fhir/StructureDefinition/${name}` : name;
+  if (canonical !== FHIR_BASE_CANONICAL) return false;
+  return version === void 0 || version.startsWith("4.");
+};
+var readPackageDependencies = async (manager, packageMeta2) => {
+  const packageJSON = await manager.packageJson(packageMeta2.name);
+  if (!packageJSON) return [];
+  const dependencies = packageJSON.dependencies;
+  if (dependencies !== void 0) {
+    return Object.entries(dependencies).map(([name, version]) => {
+      return { name, version };
     });
   }
-  const concepts = [];
-  if (valueSet.compose?.include) {
-    for (const include of valueSet.compose.include) {
-      if (include.concept) {
-        for (const concept of include.concept) {
-          concepts.push({
-            system: include.system,
-            code: concept.code,
-            display: concept.display
-          });
-        }
-      } else if (include.system && !include.filter) {
-        try {
-          const codeSystem = register.resolveAny(include.system);
-          if (codeSystem?.concept) {
-            const extractConcepts = (conceptList, system) => {
-              for (const concept of conceptList) {
-                concepts.push({
-                  system,
-                  code: concept.code,
-                  display: concept.display
-                });
-                if (concept.concept) {
-                  extractConcepts(concept.concept, system);
-                }
-              }
-            };
-            extractConcepts(codeSystem.concept, include.system);
-          }
-        } catch {
-        }
+  return [];
+};
+var flattenTerminologyConcepts = (concepts) => {
+  const flattened = [];
+  const stack = [...concepts ?? []].reverse();
+  while (stack.length > 0) {
+    const concept = stack.pop();
+    if (!concept) continue;
+    flattened.push(concept);
+    if (concept.concept) {
+      for (let index = concept.concept.length - 1; index >= 0; index -= 1) {
+        const nested = concept.concept[index];
+        if (nested) stack.push(nested);
       }
     }
   }
-  return concepts.length > 0 ? concepts : void 0;
-}
-var MAX_ENUM_LENGTH = 100;
-var PLACEHOLDER_ONLY_ENUM_CODES = /* @__PURE__ */ new Set(["UNK"]);
-var BINDABLE_TYPES = /* @__PURE__ */ new Set([
-  "code",
-  "Coding",
-  "CodeableConcept",
-  "CodeableReference",
-  "Quantity",
-  "string",
-  "uri",
-  "Duration"
-]);
-function buildEnum(register, fhirSchema, element, logger) {
-  if (!element.binding) return void 0;
-  const strength = element.binding.strength;
-  const valueSetUrl = element.binding.valueSet;
-  if (!valueSetUrl) return void 0;
-  if (!BINDABLE_TYPES.has(element.type ?? "")) {
-    logger?.dryWarn(
-      "#binding",
-      `eld-11: Binding on non-bindable type '${element.type}' (valueSet: ${valueSetUrl})`
-    );
-    return void 0;
-  }
-  const shouldGenerateEnum = strength === "required" || strength === "extensible" || strength === "preferred";
-  if (!shouldGenerateEnum) return void 0;
-  const concepts = extractValueSetConceptsByUrl(register, fhirSchema.package_meta, valueSetUrl);
-  if (!concepts || concepts.length === 0) return void 0;
-  const codes = concepts.map((c) => c.code).filter((code) => code && typeof code === "string" && code.trim().length > 0);
-  const onlyCode = codes.length === 1 ? codes[0] : void 0;
-  if (onlyCode && PLACEHOLDER_ONLY_ENUM_CODES.has(onlyCode)) {
-    logger?.dryWarn(
-      "#placeholderValueSet",
-      `Value set ${valueSetUrl} only expands to placeholder code '${onlyCode}'; skipping enum generation.`
-    );
-    return void 0;
+  return flattened;
+};
+var mkTerminologyEntries = (packageTerminology, verification, logger) => {
+  const { packageMeta: pkg, resources } = packageTerminology;
+  const byCanonical = /* @__PURE__ */ new Map();
+  for (const resource of resources) {
+    const key = `${resource.resourceType}\0${resource.url}`;
+    const matching = byCanonical.get(key) ?? [];
+    matching.push(resource);
+    byCanonical.set(key, matching);
+  }
+  const identity = (resource) => `${resource.id ?? ""}\0${resource.name ?? ""}`;
+  const deduped = [];
+  for (const matching of byCanonical.values()) {
+    const candidates = matching.slice().sort((left, right) => identity(left).localeCompare(identity(right)));
+    const winner = candidates[0];
+    if (!winner) continue;
+    if (candidates.length > 1) {
+      const identities = candidates.map((candidate) => candidate.id ?? candidate.name ?? candidate.url);
+      logger?.dryWarn(
+        "#duplicateCanonical",
+        `Package ${packageMetaToNpm(pkg)} contains duplicate ${winner.resourceType} canonical URL ${JSON.stringify(winner.url)} for resources ${identities.join(", ")}; keeping ${winner.id ?? winner.name ?? winner.url}`
+      );
+    }
+    deduped.push(winner);
   }
-  if (codes.length > MAX_ENUM_LENGTH) {
-    logger?.dryWarn(
-      "#largeValueSet",
-      `Value set ${valueSetUrl} has ${codes.length} which is more than ${MAX_ENUM_LENGTH} codes, which may cause issues with code generation.`
-    );
-    return void 0;
+  return deduped.map((resource) => {
+    const base = {
+      canonicalUrl: resource.url,
+      packageId: pkg.name,
+      packageVersion: pkg.version,
+      verification
+    };
+    if (resource.resourceType === "ValueSet")
+      return { resource, entry: { ...base, resourceType: resource.resourceType } };
+    if (resource.resourceType === "NamingSystem")
+      return { resource, entry: { ...base, resourceType: resource.resourceType } };
+    const codeSystemEntry = {
+      ...base,
+      resourceType: "CodeSystem",
+      ...resource.content !== void 0 ? { contentMode: resource.content } : {}
+    };
+    const embedsCodes = resource.content === "complete" && verification !== "unverifiable";
+    if (!embedsCodes) return { resource, entry: codeSystemEntry };
+    const concepts = flattenTerminologyConcepts(resource.concept);
+    const seenCodes = /* @__PURE__ */ new Set();
+    const displays = {};
+    for (const concept of concepts) {
+      if (seenCodes.has(concept.code))
+        throw new Error(`CodeSystem ${resource.url} repeats code ${JSON.stringify(concept.code)}`);
+      seenCodes.add(concept.code);
+      if (concept.display !== void 0)
+        Object.defineProperty(displays, concept.code, {
+          value: concept.display,
+          enumerable: true,
+          writable: true,
+          configurable: true
+        });
+    }
+    const entry = {
+      ...codeSystemEntry,
+      contentMode: "complete",
+      codes: concepts.map(({ code }) => code),
+      displays
+    };
+    return { resource, entry };
+  });
+};
+var projectTerminologyConcepts = (concepts) => {
+  if (!Array.isArray(concepts)) return void 0;
+  const projected = [];
+  const stack = [{ source: concepts, target: projected, index: 0 }];
+  while (stack.length > 0) {
+    const frame = stack[stack.length - 1];
+    if (!frame) break;
+    if (frame.index >= frame.source.length) {
+      if (frame.parent && frame.target.length === 0) delete frame.parent.concept;
+      stack.pop();
+      continue;
+    }
+    const concept = frame.source[frame.index];
+    frame.index += 1;
+    if (concept === null || typeof concept !== "object") continue;
+    const candidate = concept;
+    if (typeof candidate.code !== "string") continue;
+    const copy = {
+      code: candidate.code,
+      ...typeof candidate.display === "string" ? { display: candidate.display } : {}
+    };
+    frame.target.push(copy);
+    if (Array.isArray(candidate.concept)) {
+      const nested = [];
+      copy.concept = nested;
+      stack.push({ source: candidate.concept, target: nested, index: 0, parent: copy });
+    }
+  }
+  return projected;
+};
+var namingSystemIdentity = (candidate, logger) => {
+  const uniqueIds = Array.isArray(candidate.uniqueId) ? candidate.uniqueId.filter(
+    (identifier2) => identifier2 !== null && typeof identifier2 === "object" && typeof identifier2.type === "string" && typeof identifier2.value === "string" && identifier2.value.length > 0
+  ) : [];
+  const preferred = uniqueIds.filter(({ preferred: preferred2 }) => preferred2 === true);
+  const candidates = preferred.length > 0 ? preferred : uniqueIds;
+  const identifier = candidates.find(({ type }) => type === "uri") ?? candidates[0];
+  if (identifier) {
+    if (identifier.type === "oid" && !identifier.value.startsWith("urn:oid:")) return `urn:oid:${identifier.value}`;
+    if (identifier.type === "uuid" && !identifier.value.startsWith("urn:uuid:"))
+      return `urn:uuid:${identifier.value}`;
+    return identifier.value;
+  }
+  if (typeof candidate.id === "string" && candidate.id.length > 0) return `NamingSystem/${candidate.id}`;
+  if (typeof candidate.name === "string" && candidate.name.length > 0) return `NamingSystem/${candidate.name}`;
+  logger?.dryWarn("NamingSystem has no uniqueId, id, or name and cannot be emitted.");
+  return void 0;
+};
+var asTerminologyResource = (resource, logger) => {
+  if (isCodeSystem(resource) || isValueSet(resource)) {
+    if (typeof resource.url !== "string" || resource.url.length === 0) return void 0;
+    const concepts = isCodeSystem(resource) ? projectTerminologyConcepts(resource.concept) : void 0;
+    return {
+      resourceType: resource.resourceType,
+      ...typeof resource.id === "string" ? { id: resource.id } : {},
+      ...typeof resource.name === "string" ? { name: resource.name } : {},
+      url: resource.url,
+      ...isCodeSystem(resource) && typeof resource.content === "string" ? { content: resource.content } : {},
+      ...concepts && concepts.length > 0 ? { concept: concepts } : {}
+    };
   }
-  if (codes.length === 0) return void 0;
-  return { isOpen: strength !== "required", values: codes };
-}
-function generateBindingSchema(register, fhirSchema, path, element, logger) {
-  if (!element.binding?.valueSet) return void 0;
-  const identifier = mkBindingIdentifier(fhirSchema, path, element);
-  const valueSetIdentifier = mkValueSetIdentifierByUrl(
-    register,
-    fhirSchema.package_meta,
-    element.binding.valueSet
-  );
-  const enumResult = buildEnum(register, fhirSchema, element, logger);
+  if (resource === null || typeof resource !== "object") return void 0;
+  const candidate = resource;
+  if (candidate.resourceType !== "NamingSystem") return void 0;
+  const url = typeof candidate.url === "string" && candidate.url.length > 0 ? candidate.url : namingSystemIdentity(candidate, logger);
+  if (url === void 0 || url.length === 0) return void 0;
   return {
-    identifier,
-    valueset: valueSetIdentifier,
-    strength: element.binding.strength,
-    enum: enumResult,
-    dependencies: [valueSetIdentifier]
+    resourceType: "NamingSystem",
+    ...typeof candidate.id === "string" ? { id: candidate.id } : {},
+    ...typeof candidate.name === "string" ? { name: candidate.name } : {},
+    url
   };
-}
-function collectBindingSchemas(register, fhirSchema, logger) {
-  const processedPaths = /* @__PURE__ */ new Set();
-  if (!fhirSchema.elements) return [];
-  const bindings = [];
-  function collectBindings(elements, parentPath) {
-    for (const [key, element] of Object.entries(elements)) {
-      const path = [...parentPath, key];
-      const pathKey = path.join(".");
-      const elemSnapshot = register.resolveElementSnapshot(fhirSchema, path);
-      if (processedPaths.has(pathKey)) continue;
-      processedPaths.add(pathKey);
-      if (elemSnapshot.binding) {
-        const binding = generateBindingSchema(register, fhirSchema, path, elemSnapshot, logger);
-        if (binding) {
-          bindings.push(binding);
-        }
-      }
-      if (element.elements) {
-        collectBindings(element.elements, path);
-      }
-    }
-  }
-  collectBindings(fhirSchema.elements, []);
-  bindings.sort((a, b) => a.identifier.name.localeCompare(b.identifier.name));
-  const uniqueBindings = [];
-  const seenUrls = /* @__PURE__ */ new Set();
-  for (const binding of bindings) {
-    if (!seenUrls.has(binding.identifier.url)) {
-      seenUrls.add(binding.identifier.url);
-      uniqueBindings.push(binding);
-    }
-  }
-  return uniqueBindings;
-}
-
-// src/typeschema/core/name-candidates.ts
-var normalizeName = (s) => {
-  const cleaned = s.replace(/\[x\]/g, "").replace(/[- :.]/g, "_");
-  if (!cleaned) return "";
-  return uppercaseFirstLetter(cleaned);
-};
-var normalizeCamelName = (s) => {
-  const cleaned = s.replace(/\[x\]/g, "").replace(/:/g, "_");
-  if (!cleaned) return "";
-  return uppercaseFirstLetter(camelCase(cleaned));
-};
-var extensionCandidates = (name, path) => {
-  const base = normalizeCamelName(name) || "Extension";
-  const pathParts = path.split(".").filter((p) => p && p !== "extension").join("_");
-  const pathPart = pathParts ? normalizeCamelName(pathParts) : "";
-  const qualified = `${pathPart}${base}`;
-  return [base, qualified, `${qualified}Extension`];
-};
-var sliceCandidates = (fieldName, sliceName) => {
-  const base = normalizeName(sliceName) || "Slice";
-  const fieldPart = normalizeCamelName(fieldName) || "Field";
-  const qualified = `${fieldPart}${base}`;
-  return [base, qualified, `${qualified}Slice`];
-};
-var countBy = (entries, level, reserved) => entries.reduce(
-  (counts, e) => {
-    const name = e.candidates[level] ?? "";
-    counts[name] = (counts[name] ?? 0) + 1;
-    if (reserved.has(name)) counts[name] = (counts[name] ?? 0) + 1;
-    return counts;
-  },
-  {}
-);
-var resolveNameCollisions = (entries, reserved) => {
-  const levels = entries[0]?.candidates.length ?? 0;
-  const resolve6 = (unresolved, level) => {
-    if (unresolved.length === 0 || level >= levels) return {};
-    const counts = countBy(unresolved, level, reserved);
-    const isLastLevel = level >= levels - 1;
-    const [resolved, colliding] = unresolved.reduce(
-      ([res, col], e) => {
-        const name = e.candidates[level] ?? "";
-        return (counts[name] ?? 0) > 1 && !isLastLevel ? [res, [...col, e]] : [{ ...res, [e.key]: name }, col];
-      },
-      [{}, []]
-    );
-    return { ...resolved, ...resolve6(colliding, level + 1) };
-  };
-  return resolve6(entries, 0);
-};
-var mkExtensionNameCandidates = (ext) => {
-  return { candidates: extensionCandidates(ext.name, ext.path), recommended: "" };
-};
-var mkSliceNameCandidates = (fieldName, sliceName) => {
-  return { candidates: sliceCandidates(fieldName, sliceName), recommended: "" };
-};
-var assignRecommendedBaseNames = (profile) => {
-  const extensionEntries = (profile.extensions ?? []).filter((ext) => ext.url).map((ext) => ({
-    key: `ext:${ext.url}:${ext.path}`,
-    candidates: ext.nameCandidates.candidates
-  }));
-  const sliceEntries = Object.entries(profile.slicing ?? {}).flatMap(([fieldName, fieldSlicing]) => {
-    if (!fieldSlicing.slices) return [];
-    return Object.entries(fieldSlicing.slices).map(([sliceName, slice]) => ({
-      key: `slice:${fieldName}:${sliceName}`,
-      candidates: slice.nameCandidates.candidates
-    }));
-  });
-  const reservedNames = new Set(Object.keys(profile.fields ?? {}).map(normalizeCamelName));
-  const allEntries = [...extensionEntries, ...sliceEntries];
-  if (allEntries.length === 0) return;
-  const resolved = resolveNameCollisions(allEntries, reservedNames);
-  for (const ext of profile.extensions ?? []) {
-    if (!ext.url) continue;
-    const key = `ext:${ext.url}:${ext.path}`;
-    if (resolved[key]) ext.nameCandidates.recommended = resolved[key];
-  }
-  for (const [fieldName, fieldSlicing] of Object.entries(profile.slicing ?? {})) {
-    if (!fieldSlicing.slices) continue;
-    for (const [sliceName, slice] of Object.entries(fieldSlicing.slices)) {
-      const key = `slice:${fieldName}:${sliceName}`;
-      if (resolved[key]) slice.nameCandidates.recommended = resolved[key];
-    }
-  }
-};
-
-// src/fhir-types/hl7-fhir-r4-core/CodeSystem.ts
-var isCodeSystem = (resource) => {
-  return resource !== null && typeof resource === "object" && resource.resourceType === "CodeSystem";
-};
-
-// src/fhir-types/hl7-fhir-r4-core/ValueSet.ts
-var isValueSet = (resource) => {
-  return resource !== null && typeof resource === "object" && resource.resourceType === "ValueSet";
-};
-
-// src/typeschema/register.ts
-var BARE_RESOURCE_NAME_RE = /^[a-zA-Z0-9]+$/;
-var readPackageDependencies = async (manager, packageMeta2) => {
-  const packageJSON = await manager.packageJson(packageMeta2.name);
-  if (!packageJSON) return [];
-  const dependencies = packageJSON.dependencies;
-  if (dependencies !== void 0) {
-    return Object.entries(dependencies).map(([name, version]) => {
-      return { name, version };
-    });
-  }
-  return [];
 };
 var mkEmptyPkgIndex = (pkg) => {
   return {
     pkg,
     canonicalResolution: {},
     fhirSchemas: {},
-    valueSets: {}
+    valueSets: {},
+    terminology: []
   };
 };
 var mkPackageAwareResolver = async (manager, pkg, deep, acc, logger) => {
@@ -3567,6 +3456,8 @@ var mkPackageAwareResolver = async (manager, pkg, deep, acc, logger) => {
   const index = mkEmptyPkgIndex(pkg);
   acc[pkgId] = index;
   for (const resource of await manager.search({ package: pkg })) {
+    const terminologyResource = asTerminologyResource(resource, logger);
+    if (terminologyResource) index.terminology.push(terminologyResource);
     const rawUrl = resource.url;
     if (!rawUrl) continue;
     if (!(isStructureDefinition(resource) || isValueSet(resource) || isCodeSystem(resource))) continue;
@@ -3675,6 +3566,8 @@ var registerFromManager = async (manager, { logger, focusedPackages }) => {
     while (fs6?.base) {
       const pkg2 = fs6.package_meta;
       const baseUrl = ensureSpecializationCanonicalUrl(fs6.base);
+      if (fs6.kind === "logical" && fs6.derivation === "specialization" && isVirtualFhirBaseCanonical(fs6.base))
+        break;
       fs6 = resolveFs(pkg2, baseUrl);
       if (fs6 === void 0)
         throw new Error(
@@ -3739,6 +3632,9 @@ var registerFromManager = async (manager, { logger, focusedPackages }) => {
     ).filter((r) => isStructureDefinition(r)).sort((sd1, sd2) => sd1.url.localeCompare(sd2.url)),
     allFs: () => Object.values(resolver).flatMap((pkgIndex) => Object.values(pkgIndex.fhirSchemas)),
     allVs: () => Object.values(resolver).flatMap((pkgIndex) => Object.values(pkgIndex.valueSets)),
+    allTerminology: () => Object.values(resolver).map(({ pkg, terminology }) => ({ packageMeta: pkg, resources: terminology })).sort(
+      (left, right) => packageMetaToNpm(left.packageMeta).localeCompare(packageMetaToNpm(right.packageMeta))
+    ),
     resolveVs,
     resolveAny: (canonicalUrl) => packageAgnosticResolveCanonical(resolver, canonicalUrl),
     resolveElementSnapshot,
@@ -3763,38 +3659,343 @@ var registerFromManager = async (manager, { logger, focusedPackages }) => {
     }
   };
 };
-var registerFromPackageMetas = async (packageMetas, conf) => {
-  const packageNames = packageMetas.map(packageMetaToNpm);
-  conf?.logger?.info(`Loading FHIR packages: ${packageNames.join(", ")}`);
-  const manager = CanonicalManager({
-    packages: packageNames,
-    workingDir: ".codegen-cache/canonical-manager-cache",
-    registry: conf.registry || void 0
-  });
-  await manager.init();
-  return await registerFromManager(manager, {
-    ...conf,
-    focusedPackages: packageMetas
-  });
+var registerFromPackageMetas = async (packageMetas, conf) => {
+  const packageNames = packageMetas.map(packageMetaToNpm);
+  conf?.logger?.info(`Loading FHIR packages: ${packageNames.join(", ")}`);
+  const manager = CanonicalManager({
+    packages: packageNames,
+    workingDir: ".codegen-cache/canonical-manager-cache",
+    registry: conf.registry || void 0
+  });
+  await manager.init();
+  return await registerFromManager(manager, {
+    ...conf,
+    focusedPackages: packageMetas
+  });
+};
+var resolveFsElementGenealogy = (genealogy, path) => {
+  const [top, ...rest] = path;
+  if (top === void 0) return [];
+  return genealogy.map((fs6) => {
+    if (!fs6.elements) return void 0;
+    let elem = fs6.elements?.[top];
+    for (const k of rest) {
+      elem = elem?.elements?.[k];
+    }
+    return elem;
+  }).filter((elem) => elem !== void 0);
+};
+function mergeFsElementProps(genealogy) {
+  const revGenealogy = genealogy.reverse();
+  const snapshot = Object.assign({}, ...revGenealogy);
+  snapshot.elements = void 0;
+  return snapshot;
+}
+
+// src/typeschema/core/identifier.ts
+function dropVersionFromUrl(url) {
+  const baseUrl = url.split("|")[0];
+  return baseUrl ? baseUrl : url;
+}
+function getVersionFromUrl(url) {
+  const version = url.split("|")[1];
+  return version;
+}
+var identifierBase = (fhirSchema) => ({
+  package: fhirSchema.package_meta.name,
+  version: fhirSchema.package_meta.version,
+  name: fhirSchema.name,
+  url: fhirSchema.url
+});
+function mkIdentifier(fhirSchema) {
+  const fields = identifierBase(fhirSchema);
+  if (fhirSchema.derivation === "constraint") return { kind: "profile", ...fields };
+  if (fhirSchema.kind === "primitive-type") return { kind: "primitive-type", ...fields };
+  if (fhirSchema.kind === "complex-type") return { kind: "complex-type", ...fields };
+  if (fhirSchema.kind === "resource") return { kind: "resource", ...fields };
+  if (fhirSchema.kind === "logical") return { kind: "logical", ...fields };
+  return { kind: "resource", ...fields };
+}
+var VALUE_SET_NAME_SPLIT_RE = /[-_]/;
+var OPAQUE_VALUE_SET_ID_RE = /^[a-zA-Z0-9_-]{20,}$/;
+var getValueSetName = (url) => {
+  const urlParts = url.split("/");
+  const lastSegment = urlParts[urlParts.length - 1];
+  if (lastSegment && lastSegment.length > 0) {
+    return lastSegment.split(VALUE_SET_NAME_SPLIT_RE).map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join("");
+  }
+  return url;
+};
+function mkValueSetIdentifierByUrl(register, pkg, fullValueSetUrl) {
+  const valueSetUrl = dropVersionFromUrl(fullValueSetUrl);
+  const valueSetNameFallback = getValueSetName(valueSetUrl);
+  const valuesSetFallback = {
+    package_meta: {
+      name: "missing_valuesets",
+      version: getVersionFromUrl(valueSetUrl) || "0.0.0"
+    },
+    id: fullValueSetUrl};
+  const valueSet = register.resolveVs(pkg, valueSetUrl) || valuesSetFallback;
+  const valueSetName = valueSet?.id && !OPAQUE_VALUE_SET_ID_RE.test(valueSet.id) ? valueSet.id : valueSetNameFallback;
+  return {
+    kind: "value-set",
+    package: valueSet.package_meta.name,
+    version: valueSet.package_meta.version,
+    name: valueSetName,
+    url: valueSetUrl
+  };
+}
+function mkBindingIdentifier(fhirSchema, path, element) {
+  const bindingName = element.binding?.bindingName;
+  const pathStr = path.join(".");
+  const [pkg, name, url] = bindingName ? [{ name: "shared", version: "1.0.0" }, bindingName, `urn:fhir:binding:${bindingName}`] : [fhirSchema.package_meta, `${fhirSchema.name}.${pathStr}_binding`, `${fhirSchema.url}#${pathStr}_binding`];
+  return {
+    kind: "binding",
+    package: pkg.name,
+    version: pkg.version,
+    name,
+    url
+  };
+}
+
+// src/typeschema/core/binding.ts
+function extractValueSetConceptsByUrl(register, pkg, valueSetUrl, logger) {
+  const cleanUrl = dropVersionFromUrl(valueSetUrl) || valueSetUrl;
+  const valueSet = register.resolveVs(pkg, cleanUrl);
+  if (!valueSet) return void 0;
+  return extractValueSetConcepts(register, valueSet);
+}
+function extractValueSetConcepts(register, valueSet, _logger) {
+  if (valueSet.expansion?.contains) {
+    return valueSet.expansion.contains.filter((item) => item.code !== void 0).map((item) => {
+      assert4(item.code);
+      return {
+        code: item.code,
+        display: item.display,
+        system: item.system
+      };
+    });
+  }
+  const concepts = [];
+  if (valueSet.compose?.include) {
+    for (const include of valueSet.compose.include) {
+      if (include.concept) {
+        for (const concept of include.concept) {
+          concepts.push({
+            system: include.system,
+            code: concept.code,
+            display: concept.display
+          });
+        }
+      } else if (include.system && !include.filter) {
+        try {
+          const codeSystem = register.resolveAny(include.system);
+          if (codeSystem?.concept) {
+            const extractConcepts = (conceptList, system) => {
+              for (const concept of conceptList) {
+                concepts.push({
+                  system,
+                  code: concept.code,
+                  display: concept.display
+                });
+                if (concept.concept) {
+                  extractConcepts(concept.concept, system);
+                }
+              }
+            };
+            extractConcepts(codeSystem.concept, include.system);
+          }
+        } catch {
+        }
+      }
+    }
+  }
+  return concepts.length > 0 ? concepts : void 0;
+}
+var MAX_ENUM_LENGTH = 100;
+var PLACEHOLDER_ONLY_ENUM_CODES = /* @__PURE__ */ new Set(["UNK"]);
+var BINDABLE_TYPES = /* @__PURE__ */ new Set([
+  "code",
+  "Coding",
+  "CodeableConcept",
+  "CodeableReference",
+  "Quantity",
+  "string",
+  "uri",
+  "Duration"
+]);
+function buildEnum(register, fhirSchema, element, logger) {
+  if (!element.binding) return void 0;
+  const strength = element.binding.strength;
+  const valueSetUrl = element.binding.valueSet;
+  if (!valueSetUrl) return void 0;
+  if (!BINDABLE_TYPES.has(element.type ?? "")) {
+    logger?.dryWarn(
+      "#binding",
+      `eld-11: Binding on non-bindable type '${element.type}' (valueSet: ${valueSetUrl})`
+    );
+    return void 0;
+  }
+  const shouldGenerateEnum = strength === "required" || strength === "extensible" || strength === "preferred";
+  if (!shouldGenerateEnum) return void 0;
+  const concepts = extractValueSetConceptsByUrl(register, fhirSchema.package_meta, valueSetUrl);
+  if (!concepts || concepts.length === 0) return void 0;
+  const codes = concepts.map((c) => c.code).filter((code) => code && typeof code === "string" && code.trim().length > 0);
+  const onlyCode = codes.length === 1 ? codes[0] : void 0;
+  if (onlyCode && PLACEHOLDER_ONLY_ENUM_CODES.has(onlyCode)) {
+    logger?.dryWarn(
+      "#placeholderValueSet",
+      `Value set ${valueSetUrl} only expands to placeholder code '${onlyCode}'; skipping enum generation.`
+    );
+    return void 0;
+  }
+  if (codes.length > MAX_ENUM_LENGTH) {
+    logger?.dryWarn(
+      "#largeValueSet",
+      `Value set ${valueSetUrl} has ${codes.length} which is more than ${MAX_ENUM_LENGTH} codes, which may cause issues with code generation.`
+    );
+    return void 0;
+  }
+  if (codes.length === 0) return void 0;
+  return { isOpen: strength !== "required", values: codes };
+}
+function generateBindingSchema(register, fhirSchema, path, element, logger) {
+  if (!element.binding?.valueSet) return void 0;
+  const identifier = mkBindingIdentifier(fhirSchema, path, element);
+  const valueSetIdentifier = mkValueSetIdentifierByUrl(
+    register,
+    fhirSchema.package_meta,
+    element.binding.valueSet
+  );
+  const enumResult = buildEnum(register, fhirSchema, element, logger);
+  return {
+    identifier,
+    valueset: valueSetIdentifier,
+    strength: element.binding.strength,
+    enum: enumResult,
+    dependencies: [valueSetIdentifier]
+  };
+}
+function collectBindingSchemas(register, fhirSchema, logger) {
+  const processedPaths = /* @__PURE__ */ new Set();
+  if (!fhirSchema.elements) return [];
+  const bindings = [];
+  function collectBindings(elements, parentPath) {
+    for (const [key, element] of Object.entries(elements)) {
+      const path = [...parentPath, key];
+      const pathKey = path.join(".");
+      const elemSnapshot = register.resolveElementSnapshot(fhirSchema, path);
+      if (processedPaths.has(pathKey)) continue;
+      processedPaths.add(pathKey);
+      if (elemSnapshot.binding) {
+        const binding = generateBindingSchema(register, fhirSchema, path, elemSnapshot, logger);
+        if (binding) {
+          bindings.push(binding);
+        }
+      }
+      if (element.elements) {
+        collectBindings(element.elements, path);
+      }
+    }
+  }
+  collectBindings(fhirSchema.elements, []);
+  bindings.sort((a, b) => a.identifier.name.localeCompare(b.identifier.name));
+  const uniqueBindings = [];
+  const seenUrls = /* @__PURE__ */ new Set();
+  for (const binding of bindings) {
+    if (!seenUrls.has(binding.identifier.url)) {
+      seenUrls.add(binding.identifier.url);
+      uniqueBindings.push(binding);
+    }
+  }
+  return uniqueBindings;
+}
+
+// src/typeschema/core/name-candidates.ts
+var normalizeName = (s) => {
+  const cleaned = s.replace(/\[x\]/g, "").replace(/[- :.]/g, "_");
+  if (!cleaned) return "";
+  return uppercaseFirstLetter(cleaned);
+};
+var normalizeCamelName = (s) => {
+  const cleaned = s.replace(/\[x\]/g, "").replace(/:/g, "_");
+  if (!cleaned) return "";
+  return uppercaseFirstLetter(camelCase(cleaned));
+};
+var extensionCandidates = (name, path) => {
+  const base = normalizeCamelName(name) || "Extension";
+  const pathParts = path.split(".").filter((p) => p && p !== "extension").join("_");
+  const pathPart = pathParts ? normalizeCamelName(pathParts) : "";
+  const qualified = `${pathPart}${base}`;
+  return [base, qualified, `${qualified}Extension`];
+};
+var sliceCandidates = (fieldName, sliceName) => {
+  const base = normalizeName(sliceName) || "Slice";
+  const fieldPart = normalizeCamelName(fieldName) || "Field";
+  const qualified = `${fieldPart}${base}`;
+  return [base, qualified, `${qualified}Slice`];
+};
+var countBy = (entries, level, reserved) => entries.reduce(
+  (counts, e) => {
+    const name = e.candidates[level] ?? "";
+    counts[name] = (counts[name] ?? 0) + 1;
+    if (reserved.has(name)) counts[name] = (counts[name] ?? 0) + 1;
+    return counts;
+  },
+  {}
+);
+var resolveNameCollisions = (entries, reserved) => {
+  const levels = entries[0]?.candidates.length ?? 0;
+  const resolve5 = (unresolved, level) => {
+    if (unresolved.length === 0 || level >= levels) return {};
+    const counts = countBy(unresolved, level, reserved);
+    const isLastLevel = level >= levels - 1;
+    const [resolved, colliding] = unresolved.reduce(
+      ([res, col], e) => {
+        const name = e.candidates[level] ?? "";
+        return (counts[name] ?? 0) > 1 && !isLastLevel ? [res, [...col, e]] : [{ ...res, [e.key]: name }, col];
+      },
+      [{}, []]
+    );
+    return { ...resolved, ...resolve5(colliding, level + 1) };
+  };
+  return resolve5(entries, 0);
+};
+var mkExtensionNameCandidates = (ext) => {
+  return { candidates: extensionCandidates(ext.name, ext.path), recommended: "" };
 };
-var resolveFsElementGenealogy = (genealogy, path) => {
-  const [top, ...rest] = path;
-  if (top === void 0) return [];
-  return genealogy.map((fs6) => {
-    if (!fs6.elements) return void 0;
-    let elem = fs6.elements?.[top];
-    for (const k of rest) {
-      elem = elem?.elements?.[k];
+var mkSliceNameCandidates = (fieldName, sliceName) => {
+  return { candidates: sliceCandidates(fieldName, sliceName), recommended: "" };
+};
+var assignRecommendedBaseNames = (profile) => {
+  const extensionEntries = (profile.extensions ?? []).filter((ext) => ext.url).map((ext) => ({
+    key: `ext:${ext.url}:${ext.path}`,
+    candidates: ext.nameCandidates.candidates
+  }));
+  const sliceEntries = Object.entries(profile.slicing ?? {}).flatMap(([fieldName, fieldSlicing]) => {
+    if (!fieldSlicing.slices) return [];
+    return Object.entries(fieldSlicing.slices).map(([sliceName, slice]) => ({
+      key: `slice:${fieldName}:${sliceName}`,
+      candidates: slice.nameCandidates.candidates
+    }));
+  });
+  const reservedNames = new Set(Object.keys(profile.fields ?? {}).map(normalizeCamelName));
+  const allEntries = [...extensionEntries, ...sliceEntries];
+  if (allEntries.length === 0) return;
+  const resolved = resolveNameCollisions(allEntries, reservedNames);
+  for (const ext of profile.extensions ?? []) {
+    if (!ext.url) continue;
+    const key = `ext:${ext.url}:${ext.path}`;
+    if (resolved[key]) ext.nameCandidates.recommended = resolved[key];
+  }
+  for (const [fieldName, fieldSlicing] of Object.entries(profile.slicing ?? {})) {
+    if (!fieldSlicing.slices) continue;
+    for (const [sliceName, slice] of Object.entries(fieldSlicing.slices)) {
+      const key = `slice:${fieldName}:${sliceName}`;
+      if (resolved[key]) slice.nameCandidates.recommended = resolved[key];
     }
-    return elem;
-  }).filter((elem) => elem !== void 0);
+  }
 };
-function mergeFsElementProps(genealogy) {
-  const revGenealogy = genealogy.reverse();
-  const snapshot = Object.assign({}, ...revGenealogy);
-  snapshot.elements = void 0;
-  return snapshot;
-}
 
 // src/typeschema/core/nested-types.ts
 var hasStructuralElements = (register, fhirSchema, path) => {
@@ -3965,7 +4166,7 @@ var fieldTypeResolutionHint = (register, pkg, type) => {
   if (!dependsOnR4Core(register, pkg)) return "";
   return `
   hint:    '${type}' is an R5+ type and is not available when generating against R4.
-           Either skip this canonical via skip-hack.ts, or upgrade the target to R5.`;
+           Either exclude this canonical via a CanonicalManager patch (excludeCanonical; see src/api/builtin-patches.ts), or upgrade the target to R5.`;
 };
 function isRequired(register, fhirSchema, path) {
   const fieldName = path[path.length - 1];
@@ -4223,18 +4424,13 @@ var mkField = (register, fhirSchema, path, element, logger, rawElement) => {
   if (!valueConstraint && elemForCodingCheck.elements?.coding?.slicing?.slices) {
     const codingSlices = elemForCodingCheck.elements.coding.slicing.slices;
     const allSliceValues = Object.values(codingSlices);
-    const allRequired = allSliceValues.length > 0 && allSliceValues.every(
-      (s) => s.min !== void 0 && s.min >= 1 && s.match && typeof s.match === "object" && Object.keys(s.match).length > 0
+    const allRequiredWithSystem = allSliceValues.length > 0 && allSliceValues.every(
+      (s) => s.min !== void 0 && s.min >= 1 && s.match && typeof s.match === "object" && typeof s.match.system === "string"
     );
-    if (allRequired) {
+    if (allRequiredWithSystem) {
       const codingValues = allSliceValues.flatMap((s) => s.match ? [s.match] : []);
-      valueConstraint = {
-        kind: "fixed",
-        type: "CodeableConcept",
-        value: {
-          coding: codingValues
-        }
-      };
+      const fullyFixed = allSliceValues.every((s) => typeof s.match.code === "string");
+      valueConstraint = fullyFixed ? { kind: "fixed", type: "CodeableConcept", value: { coding: codingValues } } : { kind: "pattern", type: "CodeableConcept", value: { coding: codingValues }, validateOnly: true };
     }
   }
   return {
@@ -4404,14 +4600,6 @@ function mkFields(register, fhirSchema, parentPath, elements, logger) {
   for (const key of register.getAllElementKeys(elements)) {
     const path = [...parentPath, key];
     const elemSnapshot = register.resolveElementSnapshot(fhirSchema, path);
-    const fcurl = elemSnapshot.type ? register.ensureSpecializationCanonicalUrl(elemSnapshot.type) : void 0;
-    if (fcurl && shouldSkipCanonical(fhirSchema.package_meta, fcurl).shouldSkip) {
-      logger?.warn(
-        "#skipCanonical",
-        `Skipping field ${path} for ${fcurl} due to skip hack ${shouldSkipCanonical(fhirSchema.package_meta, fcurl).reason}`
-      );
-      continue;
-    }
     if (isNestedElement(register, fhirSchema, path, elemSnapshot, elements[key])) {
       fields[key] = mkNestedField(register, fhirSchema, path, elemSnapshot);
     } else {
@@ -4469,17 +4657,18 @@ var extractProfileDependencies = (identifier, base, fields, nestedTypes) => {
 function transformFhirSchema(register, fhirSchema, logger) {
   let base;
   if (fhirSchema.base) {
-    const baseFs = register.resolveFs(
-      fhirSchema.package_meta,
-      register.ensureSpecializationCanonicalUrl(fhirSchema.base)
-    );
-    if (!baseFs)
+    const baseUrl = register.ensureSpecializationCanonicalUrl(fhirSchema.base);
+    const baseFs = register.resolveFs(fhirSchema.package_meta, baseUrl);
+    const isVirtualLogicalBase = fhirSchema.kind === "logical" && fhirSchema.derivation === "specialization" && isVirtualFhirBaseCanonical(fhirSchema.base);
+    if (!baseFs && !isVirtualLogicalBase)
       throw new Error(
         `Base resource not found '${fhirSchema.base}' for <${fhirSchema.url}> from ${packageMetaToFhir(fhirSchema.package_meta)}`
       );
-    const baseId = mkIdentifier(baseFs);
-    assert4(!isNestedIdentifier(baseId), `Unexpected nested base for ${fhirSchema.url}`);
-    base = baseId;
+    if (baseFs) {
+      const baseId = mkIdentifier(baseFs);
+      assert4(!isNestedIdentifier(baseId), `Unexpected nested base for ${fhirSchema.url}`);
+      base = baseId;
+    }
   }
   const { fields, slicing } = mkFields(register, fhirSchema, [], fhirSchema.elements, logger);
   const nested = mkNestedTypes(register, fhirSchema, logger);
@@ -4592,11 +4781,6 @@ var generateTypeSchemas = async (register, resolveCollisions, logger) => {
   const schemasWithSources = [];
   for (const fhirSchema of register.allFs()) {
     const pkgId = packageMetaToFhir(fhirSchema.package_meta);
-    const skipCheck = shouldSkipCanonical(fhirSchema.package_meta, fhirSchema.url);
-    if (skipCheck.shouldSkip) {
-      logger?.dryWarn("#skipCanonical", `Skip ${fhirSchema.url} from ${pkgId}. Reason: ${skipCheck.reason}`);
-      continue;
-    }
     for (const schema of transformFhirSchema(register, fhirSchema, logger)) {
       schemasWithSources.push({
         schema,
@@ -5737,14 +5921,14 @@ var createGenerator = (templatePath, apiOpts) => {
   return new MustacheGenerator(mustacheOptions);
 };
 function runCommand(cmd, args = [], options = {}) {
-  return new Promise((resolve6, reject) => {
+  return new Promise((resolve5, reject) => {
     const child = spawn(cmd, args, {
       stdio: "inherit",
       ...options
     });
     child.on("error", reject);
     child.on("close", (code) => {
-      if (code === 0) resolve6(code);
+      if (code === 0) resolve5(code);
       else reject(new Error(`Prozess beendet mit Fehlercode ${code}`));
     });
   });
@@ -5775,13 +5959,19 @@ var MustacheGenerator = class extends FileSystemWriter {
     tsIndex.collectComplexTypes().map((i) => i.identifier).sort((a, b) => a.url.localeCompare(b.url)).map((typeRef) => modelFactory.createComplexType(typeRef, cache)).forEach(this._renderComplexType.bind(this));
     tsIndex.collectResources().map((i) => i.identifier).sort((a, b) => a.url.localeCompare(b.url)).map((typeRef) => modelFactory.createResource(typeRef, cache)).forEach(this._renderResource.bind(this));
     this._renderUtility(modelFactory.createUtility());
-    this.copyStaticFiles();
     if (this.opts.shouldRunHooks) {
       await this._runHooks(this.opts.hooks.afterGenerate);
     }
     return;
   }
+  /** Static files bypass the write buffer, so they are copied once generation is done and
+   *  `opts.inMemoryOnly` reflects the caller again rather than `generateAsync`'s buffering. */
+  async generateAsync(tsIndex) {
+    await super.generateAsync(tsIndex);
+    this.copyStaticFiles();
+  }
   copyStaticFiles() {
+    if (this.opts.inMemoryOnly) return;
     const staticDir = Path5.resolve(this.opts.sources.staticSource);
     if (!staticDir) {
       throw new Error("staticDir must be set in subclass.");
@@ -5879,9 +6069,6 @@ var tsModuleName = (id) => {
 var tsModuleFileName = (id) => {
   return `${tsModuleName(id)}.ts`;
 };
-var tsModulePath = (id) => {
-  return `${tsPackageDir(id.package)}/${tsModuleName(id)}`;
-};
 var tsNameFromCanonical = (canonical, dropFragment = true) => {
   if (!canonical) return void 0;
   const localName = extractNameFromCanonical(canonical, dropFragment);
@@ -5926,8 +6113,19 @@ var tsSliceFlatAllTypeName = (profileName, fieldName, sliceName) => {
 var tsExtensionFlatTypeName = (profileName, extensionName) => {
   return `${uppercaseFirstLetter(profileName)}_${uppercaseFirstLetter(normalizeTsName(extensionName))}Flat`;
 };
+var tsExtensionExtractedTypeName = (profileName, extensionName) => {
+  return `${uppercaseFirstLetter(profileName)}_${uppercaseFirstLetter(normalizeTsName(extensionName))}Extracted`;
+};
+var tsExtensionVFlatTypeName = (profileName, extensionName) => {
+  return `${uppercaseFirstLetter(profileName)}_${uppercaseFirstLetter(normalizeTsName(extensionName))}VFlat`;
+};
 var tsSliceStaticName = (name) => name.replace(/\[x\]/g, "").replace(/[^a-zA-Z0-9_$]/g, "_");
 var tsValueFieldName = (id) => `value${uppercaseFirstLetter(id.name)}`;
+var TS_IDENTIFIER_RE = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+var tsObjectKey = (key) => {
+  if (key === "__proto__") return '["__proto__"]';
+  return TS_IDENTIFIER_RE.test(key) ? key : JSON.stringify(key);
+};
 
 // src/api/writer-generator/typescript/utils.ts
 var primitiveType2tsType = {
@@ -6111,22 +6309,26 @@ var effectiveGetterDefault = (w, hasProfile) => {
   if (configured === "profile" && !hasProfile) return "flat";
   return configured;
 };
-var returnTypeForMode = (mode, inputType, profileClassName) => {
+var returnTypeForMode = (mode, inputType, profileClassName, vFlatType) => {
   if (mode === "profile" && profileClassName) return profileClassName;
   if (mode === "raw") return "Extension";
+  if (mode === "vflat" && vFlatType) return vFlatType;
   return inputType;
 };
-var generateExtensionGetterOverloads = (w, ext, targetPath, methodName, inputType, extProfileInfo, generateInputBody) => {
+var generateExtensionGetterOverloads = (w, ext, targetPath, methodName, inputType, extProfileInfo, generateInputBody, vFlatType) => {
   const hasProfile = !!extProfileInfo;
   const defaultMode = effectiveGetterDefault(w, hasProfile);
   const modes = hasProfile ? ["flat", "profile", "raw"] : ["flat", "raw"];
+  if (vFlatType) modes.splice(1, 0, "vflat");
   for (const mode of modes) {
-    const rt = returnTypeForMode(mode, inputType, extProfileInfo?.className);
+    const rt = returnTypeForMode(mode, inputType, extProfileInfo?.className, vFlatType);
     w.lineSM(`public ${methodName}(mode: '${mode}'): ${rt} | undefined`);
   }
-  const defaultReturn = returnTypeForMode(defaultMode, inputType, extProfileInfo?.className);
+  const defaultReturn = returnTypeForMode(defaultMode, inputType, extProfileInfo?.className, vFlatType);
   w.lineSM(`public ${methodName}(): ${defaultReturn} | undefined`);
-  const allReturns = [...new Set(modes.map((m) => returnTypeForMode(m, inputType, extProfileInfo?.className)))];
+  const allReturns = [
+    ...new Set(modes.map((m) => returnTypeForMode(m, inputType, extProfileInfo?.className, vFlatType)))
+  ];
   const modesUnion = modes.map((m) => `'${m}'`).join(" | ");
   w.curlyBlock(
     ["public", methodName, `(mode: ${modesUnion} = '${defaultMode}'): ${allReturns.join(" | ")} | undefined`],
@@ -6204,21 +6406,50 @@ var generateComplexExtensionSetter2 = (w, info) => {
     });
   }
 };
+var extractableMembers = (extProfileInfo) => {
+  const slices = extProfileInfo ? collectSubExtensionSlices(extProfileInfo.snapshot) : [];
+  if (slices.length === 0) return void 0;
+  return slices.map((sub) => JSON.stringify(sub.name)).join(" | ");
+};
+var extensionExtractedTypes = (tsProfileName, ext, extProfileInfo) => {
+  const inputTypeName = tsExtensionFlatTypeName(tsProfileName, ext.name);
+  const members = extractableMembers(extProfileInfo);
+  if (!members || !extProfileInfo) return { flat: `Partial<${inputTypeName}>`, vFlat: void 0 };
+  const picked = `Pick<${extProfileInfo.className}Flat, ${members}>`;
+  return { flat: `Partial<${picked}>`, vFlat: picked };
+};
 var generateComplexExtensionGetter2 = (w, info) => {
   const { ext, snapshot, getMethodName, targetPath, extProfileInfo } = info;
   const tsProfileName = tsResourceName(snapshot.identifier);
-  const inputTypeName = tsExtensionFlatTypeName(tsProfileName, ext.name);
-  const extProfileHasFlatInput = extProfileInfo ? collectSubExtensionSlices(extProfileInfo.snapshot).length > 0 : false;
-  const inputType = extProfileHasFlatInput && extProfileInfo ? `${extProfileInfo.className}Flat` : inputTypeName;
-  generateExtensionGetterOverloads(w, ext, targetPath, getMethodName, inputType, extProfileInfo, () => {
-    const configItems = (ext.subExtensions ?? []).map((sub) => {
-      const valueField = sub.valueFieldType ? tsValueFieldName(sub.valueFieldType) : "value";
-      const isArray = sub.max === "*";
-      return `{ name: "${sub.url}", valueField: "${valueField}", isArray: ${isArray} }`;
-    });
-    w.line(`const config = [${configItems.join(", ")}]`);
-    w.line(`return extractComplexExtension<${inputType}>(ext, config)`);
-  });
+  const baseName = ext.nameCandidates.recommended;
+  const extractedType = tsExtensionExtractedTypeName(tsProfileName, baseName);
+  const hasVFlat = extensionExtractedTypes(tsProfileName, ext, extProfileInfo).vFlat !== void 0;
+  const vFlatType = hasVFlat ? tsExtensionVFlatTypeName(tsProfileName, baseName) : void 0;
+  generateExtensionGetterOverloads(
+    w,
+    ext,
+    targetPath,
+    getMethodName,
+    extractedType,
+    extProfileInfo,
+    () => {
+      const configItems = (ext.subExtensions ?? []).map((sub) => {
+        const valueField = sub.valueFieldType ? tsValueFieldName(sub.valueFieldType) : "value";
+        const isArray = sub.max === "*";
+        return `{ name: "${sub.url}", valueField: "${valueField}", isArray: ${isArray} }`;
+      });
+      w.line(`const config = [${configItems.join(", ")}]`);
+      if (vFlatType && extProfileInfo) {
+        w.curlyBlock(["if", "(mode === 'vflat')"], () => {
+          w.line(`const { errors } = ${extProfileInfo.className}.apply(ext).validate()`);
+          w.line('if (errors.length > 0) throw new Error(errors.join("; "))');
+          w.line(`return extractComplexExtension<${vFlatType}>(ext, config)`);
+        });
+      }
+      w.line(`return extractComplexExtension<${extractedType}>(ext, config)`);
+    },
+    vFlatType
+  );
 };
 var generateSingleValueExtensionSetter2 = (w, tsIndex, info) => {
   const { ext, setMethodName, targetPath, extProfileInfo } = info;
@@ -6367,6 +6598,11 @@ var collectTypesFromFlatInput = (tsIndex, snapshot, addType) => {
 };
 
 // src/api/writer-generator/typescript/profile-slices.ts
+var sliceAccessorBaseName = (candidates, recommended, fieldNames, reservedNames = /* @__PURE__ */ new Set()) => {
+  const reserved = /* @__PURE__ */ new Set([...fieldNames.map((name) => uppercaseFirstLetter(name)), ...reservedNames]);
+  if (!reserved.has(recommended)) return recommended;
+  return candidates.find((candidate) => !reserved.has(candidate)) ?? recommended;
+};
 var collectChoiceBaseNames = (tsIndex, typeId) => {
   const names = /* @__PURE__ */ new Set();
   const schema = tsIndex.resolveType(typeId);
@@ -6422,38 +6658,48 @@ var collectRequiredSliceNames2 = (field, fieldSlicing) => {
   }).map(([name]) => name);
   return names.length > 0 ? names : void 0;
 };
-var collectSliceDefs2 = (tsIndex, snapshot) => Object.entries(snapshot.slicing ?? {}).flatMap(([fieldName, fieldSlicing]) => {
-  const field = snapshot.fields[fieldName];
-  if (!isNotChoiceDeclarationField(field) || !fieldSlicing.slices || !field.type) return [];
-  const baseType = tsTypeFromIdentifier(field.type);
-  const pkgName = snapshot.identifier.package;
-  const choiceBaseNames = collectChoiceBaseNames(tsIndex, field.type);
-  const isTypeDisc = isTypeDiscriminated(fieldSlicing);
-  return Object.entries(fieldSlicing.slices).filter(([_, slice]) => Object.keys(slice.match ?? {}).length > 0).map(([sliceName, slice]) => {
-    const matchFields = Object.keys(slice.match ?? {});
-    const required = (slice.required ?? []).filter(
-      (name) => !matchFields.includes(name) && !choiceBaseNames.has(name)
-    );
-    const cc = slice.elements ? tsIndex.constrainedChoice(pkgName, field.type, slice.elements) : void 0;
-    const constrainedChoice = cc && !isPrimitiveIdentifier(cc.variantType) ? cc : void 0;
-    const resourceType = isTypeDisc ? extractResourceTypeFromMatch(slice.match ?? {}) : void 0;
-    const typedBaseType = resourceType ? `${baseType}<${resourceType}>` : baseType;
-    return {
-      fieldName,
-      baseType,
-      typedBaseType,
-      sliceName,
-      baseName: slice.nameCandidates.recommended,
-      match: slice.match ?? {},
-      required,
-      excluded: slice.excluded ?? [],
-      array: Boolean(field.array),
-      constrainedChoice,
-      typeDiscriminator: isTypeDisc,
-      max: slice.max ?? 0
-    };
+var collectSliceDefs2 = (tsIndex, snapshot) => {
+  const reservedBaseNames = /* @__PURE__ */ new Set();
+  return Object.entries(snapshot.slicing ?? {}).flatMap(([fieldName, fieldSlicing]) => {
+    const field = snapshot.fields[fieldName];
+    if (!isNotChoiceDeclarationField(field) || !fieldSlicing.slices || !field.type) return [];
+    const baseType = tsTypeFromIdentifier(field.type);
+    const pkgName = snapshot.identifier.package;
+    const choiceBaseNames = collectChoiceBaseNames(tsIndex, field.type);
+    const isTypeDisc = isTypeDiscriminated(fieldSlicing);
+    return Object.entries(fieldSlicing.slices).filter(([_, slice]) => Object.keys(slice.match ?? {}).length > 0).map(([sliceName, slice]) => {
+      const matchFields = Object.keys(slice.match ?? {});
+      const required = (slice.required ?? []).filter(
+        (name) => !matchFields.includes(name) && !choiceBaseNames.has(name)
+      );
+      const cc = slice.elements ? tsIndex.constrainedChoice(pkgName, field.type, slice.elements) : void 0;
+      const constrainedChoice = cc && !isPrimitiveIdentifier(cc.variantType) ? cc : void 0;
+      const resourceType = isTypeDisc ? extractResourceTypeFromMatch(slice.match ?? {}) : void 0;
+      const typedBaseType = resourceType ? `${baseType}<${resourceType}>` : baseType;
+      const baseName = sliceAccessorBaseName(
+        slice.nameCandidates.candidates,
+        slice.nameCandidates.recommended,
+        Object.keys(snapshot.fields),
+        reservedBaseNames
+      );
+      reservedBaseNames.add(baseName);
+      return {
+        fieldName,
+        baseType,
+        typedBaseType,
+        sliceName,
+        baseName,
+        match: slice.match ?? {},
+        required,
+        excluded: slice.excluded ?? [],
+        array: Boolean(field.array),
+        constrainedChoice,
+        typeDiscriminator: isTypeDisc,
+        max: slice.max ?? 0
+      };
+    });
   });
-});
+};
 var generateSliceSetters2 = (w, sliceDefs, snapshot) => {
   const profileClassName = tsProfileClassName(snapshot);
   const tsProfileName = tsResourceName(snapshot.identifier);
@@ -6603,26 +6849,54 @@ var generateSliceGetters2 = (w, sliceDefs, snapshot) => {
 };
 
 // src/api/writer-generator/typescript/profile-validation.ts
-var collectRegularFieldValidation2 = (errors, warnings, name, field, resolveRef, canonicalUrlExpr, tsIndex, fieldSlicing) => {
+var collectSliceRequirements2 = (slice, match, field, tsIndex) => {
+  const requiredFields = [];
+  const choiceGroups = [];
+  const matchKeys = new Set(Object.keys(match));
+  const requiredNames = (slice.required ?? []).filter((rf) => !matchKeys.has(rf));
+  const fieldType = field.type;
+  for (const rf of requiredNames) {
+    const variants = tsIndex && fieldType ? tsIndex.sliceChoiceVariants(fieldType.package, fieldType, slice.elements ?? [], rf) : void 0;
+    if (variants && variants.length > 0) choiceGroups.push(variants);
+    else requiredFields.push(rf);
+  }
+  if (tsIndex && fieldType && slice.elements) {
+    const cc = tsIndex.constrainedChoice(fieldType.package, fieldType, slice.elements);
+    if (cc && !requiredNames.includes(cc.choiceBase)) requiredFields.push(cc.variant);
+  }
+  return { requiredFields, choiceGroups };
+};
+var collectRegularFieldValidation2 = (errors, warnings, name, field, resolveRef, canonicalUrlExpr, tsIndex, fieldSlicing, enumExprs) => {
   if (field.excluded) {
     errors.push(`...validateExcluded(res, profileName, ${JSON.stringify(name)})`);
     return;
   }
   if (field.required) errors.push(`...validateRequired(res, profileName, ${JSON.stringify(name)})`);
   if (field.valueConstraint) {
-    const valueExpr = canonicalUrlExpr && name === "url" && field.valueConstraint.value === canonicalUrlExpr.url ? canonicalUrlExpr.expr : JSON.stringify(field.valueConstraint.value);
-    errors.push(`...validateFixedValue(res, profileName, ${JSON.stringify(name)}, ${valueExpr})`);
+    const constrainedValueExpr = canonicalUrlExpr && name === "url" && field.valueConstraint.value === canonicalUrlExpr.url ? canonicalUrlExpr.expr : JSON.stringify(field.valueConstraint.value);
+    const fn = field.valueConstraint.validateOnly ? "validatePatternValue" : "validateFixedValue";
+    const repeating = field.array ? ", true" : "";
+    errors.push(`...${fn}(res, profileName, ${JSON.stringify(name)}, ${constrainedValueExpr}${repeating})`);
   }
   if (field.enum) {
     const target = field.enum.isOpen ? warnings : errors;
-    target.push(`...validateEnum(res, profileName, ${JSON.stringify(name)}, ${JSON.stringify(field.enum.values)})`);
+    const valuesExpr = enumExprs?.get(name) ?? JSON.stringify(field.enum.values);
+    target.push(`...validateEnum(res, profileName, ${JSON.stringify(name)}, ${valuesExpr})`);
   }
   if (field.mustSupport && !field.required)
     warnings.push(`...validateMustSupport(res, profileName, ${JSON.stringify(name)})`);
-  if (field.reference && field.reference.resource.length > 0)
+  if (field.reference && field.reference.resource.length > 0) {
+    const allowed = field.reference.resource.flatMap((ref) => {
+      const resolved = resolveRef(ref);
+      const target = tsIndex?.resolveType(resolved);
+      const family = target && "typeFamily" in target ? target.typeFamily?.resources ?? [] : [];
+      if (family.length === 0) return [resolved.name];
+      return family.filter((member) => !tsIndex?.isFamilyType(member)).map((member) => member.name).sort((a, b) => a.localeCompare(b));
+    });
     errors.push(
-      `...validateReference(res, profileName, ${JSON.stringify(name)}, ${JSON.stringify(field.reference.resource.map((ref) => resolveRef(ref).name))})`
+      `...validateReference(res, profileName, ${JSON.stringify(name)}, ${JSON.stringify([...new Set(allowed)])})`
     );
+  }
   if (fieldSlicing?.slices) {
     for (const [sliceName, slice] of Object.entries(fieldSlicing.slices)) {
       const match = slice.match ?? {};
@@ -6634,19 +6908,16 @@ var collectRegularFieldValidation2 = (errors, warnings, name, field, resolveRef,
           `...validateSliceCardinality(res, profileName, ${JSON.stringify(name)}, ${JSON.stringify(match)}, ${JSON.stringify(sliceName)}, ${min}, ${max})`
         );
       }
-      const sliceRequiredFields = [];
-      const matchKeys = new Set(Object.keys(match));
-      for (const rf of slice.required ?? []) {
-        if (!matchKeys.has(rf)) sliceRequiredFields.push(rf);
-      }
-      if (tsIndex && field.type && slice.elements) {
-        const cc = tsIndex.constrainedChoice(field.type.package, field.type, slice.elements);
-        if (cc) sliceRequiredFields.push(cc.variant);
-      }
-      if (sliceRequiredFields.length > 0) {
-        errors.push(
-          `...validateSliceFields(res, profileName, ${JSON.stringify(name)}, ${JSON.stringify(match)}, ${JSON.stringify(sliceName)}, ${JSON.stringify(sliceRequiredFields)})`
-        );
+      const { requiredFields, choiceGroups } = collectSliceRequirements2(slice, match, field, tsIndex);
+      if (requiredFields.length > 0 || choiceGroups.length > 0) {
+        const args = [
+          JSON.stringify(name),
+          JSON.stringify(match),
+          JSON.stringify(sliceName),
+          JSON.stringify(requiredFields)
+        ];
+        if (choiceGroups.length > 0) args.push(JSON.stringify(choiceGroups));
+        errors.push(`...validateSliceFields(res, profileName, ${args.join(", ")})`);
       }
     }
   }
@@ -6656,6 +6927,7 @@ var generateValidateMethod2 = (w, tsIndex, snapshot) => {
   const profileName = snapshot.identifier.name;
   const canonicalUrl = snapshot.identifier.url;
   const canonicalUrlExpr = canonicalUrl ? { url: canonicalUrl, expr: `${tsProfileClassName(snapshot)}.canonicalUrl` } : void 0;
+  const enumLinks = w.enumTerminologyLinks(tsIndex, snapshot);
   w.curlyBlock(["validate(): { errors: string[]; warnings: string[] }"], () => {
     w.line(`const profileName = "${profileName}"`);
     w.line("const res = this.resource");
@@ -6678,7 +6950,8 @@ var generateValidateMethod2 = (w, tsIndex, snapshot) => {
         tsIndex.findLastSpecializationByIdentifier,
         canonicalUrlExpr,
         tsIndex,
-        snapshot.slicing?.[name]
+        snapshot.slicing?.[name],
+        enumLinks.exprs
       );
     }
     for (const inheritedName of snapshot.inheritedRequiredFields ?? []) {
@@ -6736,11 +7009,6 @@ var tryPromoteChoice2 = (field, fields, params, promotedChoices, resolveRef, isF
   params.push({ name: choiceName, tsType, typeId: choiceField.type });
   promotedChoices.add(choiceName);
 };
-var mkIsFamilyType = (tsIndex) => (ref) => {
-  const schema = tsIndex.resolveType(ref);
-  if (!schema || !("typeFamily" in schema)) return false;
-  return (schema.typeFamily?.resources?.length ?? 0) > 0;
-};
 var collectProfileFactoryInfo2 = (tsIndex, snapshot) => {
   const autoFields = [];
   const sliceAutoFields = [];
@@ -6750,7 +7018,7 @@ var collectProfileFactoryInfo2 = (tsIndex, snapshot) => {
   const fields = snapshot.fields;
   const promotedChoices = /* @__PURE__ */ new Set();
   const resolveRef = tsIndex.findLastSpecializationByIdentifier;
-  const isFamilyType = mkIsFamilyType(tsIndex);
+  const isFamilyType = tsIndex.isFamilyType;
   if (isResourceIdentifier(snapshot.base)) {
     autoFields.push({ name: "resourceType", value: JSON.stringify(snapshot.base.name) });
   }
@@ -6761,8 +7029,8 @@ var collectProfileFactoryInfo2 = (tsIndex, snapshot) => {
       tryPromoteChoice2(field, fields, params, promotedChoices, resolveRef, isFamilyType);
       continue;
     }
-    if (field.valueConstraint) {
-      const value = JSON.stringify(field.valueConstraint.value);
+    if (field.valueConstraint && !field.valueConstraint.validateOnly) {
+      const value = field.valueConstraint.value === snapshot.identifier.url ? `${tsProfileClassName(snapshot)}.canonicalUrl` : JSON.stringify(field.valueConstraint.value);
       autoFields.push({ name, value: field.array ? `[${value}]` : value });
       fixedFields.add(name);
       if (isNotChoiceDeclarationField(field) && field.type) {
@@ -6831,13 +7099,12 @@ var generateProfileIndexFile = (w, tsIndex, snapshots) => {
       const exports$1 = /* @__PURE__ */ new Map();
       for (const snapshot of snapshots) {
         const className = tsProfileClassName(snapshot);
-        const moduleName = tsProfileModuleName(tsIndex, snapshot);
         if (!exports$1.has(className)) {
-          exports$1.set(className, `export { ${className} } from "./${moduleName}"`);
+          exports$1.set(className, tsProfileModuleName(tsIndex, snapshot));
         }
       }
-      for (const exp of [...exports$1.values()].sort()) {
-        w.lineSM(exp);
+      for (const className of [...exports$1.keys()].sort()) {
+        w.tsExport(`./${exports$1.get(className)}`, className);
       }
     });
   });
@@ -6875,19 +7142,24 @@ var generateProfileHelpersImport = (w, tsIndex, snapshot, sliceDefs, factoryInfo
       "validateChoiceProhibited",
       "validateMustSupport"
     );
+  const hasPatternConstraint = Object.values(snapshot.fields).some(
+    (field) => "valueConstraint" in field && field.valueConstraint?.validateOnly === true
+  );
+  if (hasPatternConstraint) imports.push("validatePatternValue");
   if (imports.length > 0) {
     w.tsImport("../../profile-helpers", ...imports);
     w.line();
   }
 };
 var generateProfileImports = (w, tsIndex, snapshot) => {
+  const terminologyImports = w.enumTerminologyLinks(tsIndex, snapshot).imports;
   const usedTypes = /* @__PURE__ */ new Map();
   const getModulePath = (typeId) => {
     if (isNestedIdentifier(typeId)) {
       const path = tsNameFromCanonical(typeId.url, true);
-      if (path) return `../../${tsPackageDir(typeId.package)}/${pascalCase(path)}`;
+      if (path) return `../../${w.packageDir(typeId)}/${pascalCase(path)}`;
     }
-    return `../../${tsModulePath(typeId)}`;
+    return `../../${w.modulePath(typeId)}`;
   };
   const addType = (typeId) => {
     if (typeId.kind === "primitive-type") return;
@@ -6923,6 +7195,11 @@ var generateProfileImports = (w, tsIndex, snapshot) => {
     w.tsImport(importPath, ...names.sort(), { typeOnly: true });
   }
   if (sortedModules.length > 0) w.line();
+  const sortedTerminology = [...terminologyImports.entries()].sort(([left], [right]) => left.localeCompare(right));
+  for (const [moduleDir, symbols] of sortedTerminology) {
+    w.tsImport(`../../${moduleDir}/terminology`, ...[...symbols].sort());
+  }
+  if (sortedTerminology.length > 0) w.line();
   const extProfileImports = /* @__PURE__ */ new Map();
   for (const ext of snapshot.extensions ?? []) {
     if (!ext.url) continue;
@@ -7031,6 +7308,7 @@ var generateFactoryMethods = (w, tsIndex, snapshot, factoryInfo) => {
   w.line();
   const subSlicesForInput = snapshot.base.name === "Extension" ? collectSubExtensionSlices(snapshot) : [];
   const hasInputHelper = subSlicesForInput.length > 0;
+  const requiresFactoryInput = hasParams || subSlicesForInput.some((sub) => sub.isRequired);
   if (hasInputHelper) {
     const rawInputTypeName = `${profileClassName}Raw`;
     const inputTypeName = `${profileClassName}Flat`;
@@ -7069,9 +7347,24 @@ var generateFactoryMethods = (w, tsIndex, snapshot, factoryInfo) => {
       }
     );
     w.line();
-    const createResourceSig = hasParams ? `args: ${rawInputTypeName} | ${inputTypeName}` : `args?: ${rawInputTypeName} | ${inputTypeName}`;
+    const createResourceSig = requiresFactoryInput ? `args: ${rawInputTypeName} | ${inputTypeName}` : `args?: ${rawInputTypeName} | ${inputTypeName}`;
     w.curlyBlock(["static", "createResource", `(${createResourceSig})`, `: ${tsBaseResourceName}`], () => {
-      w.lineSM(`const resolvedExtensions = ${profileClassName}.resolveInput(args ?? {})`);
+      const inputExpression = requiresFactoryInput ? "args" : "args ?? {}";
+      w.lineSM(`const resolvedExtensions = ${profileClassName}.resolveInput(${inputExpression})`);
+      for (const field of factoryInfo.sliceAutoFields) {
+        if (field.name === "extension") continue;
+        const matchRefs = field.sliceNames.map(
+          (sliceName) => `${profileClassName}.${tsSliceStaticName(sliceName)}SliceMatch`
+        );
+        w.line(`const ${field.name}WithDefaults = ensureSliceDefaults(`);
+        w.indentBlock(() => {
+          w.line(`[...(args.${field.name} ?? [])],`);
+          for (const ref of matchRefs) {
+            w.line(`${ref},`);
+          }
+        });
+        w.lineSM(")");
+      }
       const extSliceField = factoryInfo.sliceAutoFields.find((f) => f.name === "extension");
       if (extSliceField) {
         const matchRefs = extSliceField.sliceNames.map(
@@ -7109,7 +7402,7 @@ var generateFactoryMethods = (w, tsIndex, snapshot, factoryInfo) => {
       w.lineSM("return resource");
     });
     w.line();
-    const createSig = hasParams ? `args: ${rawInputTypeName} | ${inputTypeName}` : `args?: ${rawInputTypeName} | ${inputTypeName}`;
+    const createSig = requiresFactoryInput ? `args: ${rawInputTypeName} | ${inputTypeName}` : `args?: ${rawInputTypeName} | ${inputTypeName}`;
     w.curlyBlock(["static", "create", `(${createSig})`, `: ${profileClassName}`], () => {
       w.lineSM(`return ${profileClassName}.apply(${profileClassName}.createResource(args))`);
     });
@@ -7220,6 +7513,21 @@ var generateInlineExtensionInputTypes = (w, tsIndex, snapshot) => {
     w.line();
   }
 };
+var generateExtensionExtractedTypes = (w, tsIndex, snapshot) => {
+  const tsProfileName = tsResourceName(snapshot.identifier);
+  const complexExtensions = (snapshot.extensions ?? []).filter((ext) => ext.isComplex && ext.subExtensions);
+  for (const ext of complexExtensions) {
+    if (!ext.url) continue;
+    const extProfileInfo = resolveExtensionProfile2(tsIndex, snapshot.identifier.package, ext.url);
+    const { flat, vFlat } = extensionExtractedTypes(tsProfileName, ext, extProfileInfo);
+    const baseName = ext.nameCandidates.recommended;
+    w.lineSM(`export type ${tsExtensionExtractedTypeName(tsProfileName, baseName)} = ${flat}`);
+    if (vFlat) {
+      w.lineSM(`export type ${tsExtensionVFlatTypeName(tsProfileName, baseName)} = ${vFlat}`);
+    }
+    w.line();
+  }
+};
 var valueToTypeLiteral = (value) => {
   if (value === null || value === void 0) return "undefined";
   if (typeof value === "string") return JSON.stringify(value);
@@ -7295,15 +7603,29 @@ var generateRawType = (w, snapshot, factoryInfo) => {
   });
   w.line();
 };
-var generateFlatInputType = (w, snapshot) => {
+var generateFlatInputType = (w, snapshot, factoryInfo) => {
   const subSlices = snapshot.base.name === "Extension" ? collectSubExtensionSlices(snapshot) : [];
   if (subSlices.length === 0) return;
   const flatInputTypeName = `${tsProfileClassName(snapshot)}Flat`;
+  const flatFields = [
+    ...factoryInfo.params.filter((param) => param.name !== "extension").map((param) => ({ name: param.name, optional: false, tsType: param.tsType })),
+    ...factoryInfo.sliceAutoFields.filter((field) => field.name !== "extension").map((field) => ({ name: field.name, optional: true, tsType: field.tsType })),
+    ...subSlices.map((sub) => ({
+      name: sub.name,
+      optional: !sub.isRequired,
+      tsType: `${sub.tsType}${sub.isArray ? "[]" : ""}`
+    }))
+  ];
+  const seen = /* @__PURE__ */ new Set();
+  for (const field of flatFields) {
+    if (seen.has(field.name)) {
+      throw new Error(`Flat input field collision for ${flatInputTypeName}: ${field.name}`);
+    }
+    seen.add(field.name);
+  }
   w.curlyBlock(["export", "type", flatInputTypeName, "="], () => {
-    for (const sub of subSlices) {
-      const opt = sub.isRequired ? "" : "?";
-      const arr = sub.isArray ? "[]" : "";
-      w.lineSM(`${sub.name}${opt}: ${sub.tsType}${arr}`);
+    for (const field of flatFields) {
+      w.lineSM(`${field.name}${field.optional ? "?" : ""}: ${field.tsType}`);
     }
   });
   w.line();
@@ -7313,14 +7635,23 @@ var generateProfileClass = (w, tsIndex, snapshot) => {
   const profileClassName = tsProfileClassName(snapshot);
   const sliceDefs = collectSliceDefs2(tsIndex, snapshot);
   const factoryInfo = collectProfileFactoryInfo2(tsIndex, snapshot);
+  generateProfileHelpersImport(w, tsIndex, snapshot, sliceDefs, factoryInfo);
   generateInlineExtensionInputTypes(w, tsIndex, snapshot);
+  generateExtensionExtractedTypes(w, tsIndex, snapshot);
   generateSliceInputTypes(w, snapshot, sliceDefs);
-  generateProfileHelpersImport(w, tsIndex, snapshot, sliceDefs, factoryInfo);
   generateRawType(w, snapshot, factoryInfo);
-  generateFlatInputType(w, snapshot);
+  generateFlatInputType(w, snapshot, factoryInfo);
   const canonicalUrl = snapshot.identifier.url;
   w.comment("CanonicalURL:", canonicalUrl, `(pkg: ${packageMetaToFhir(packageMeta(snapshot))})`);
   w.curlyBlock(["export", "class", profileClassName], () => {
+    const specializationBase = tsIndex.findLastSpecializationByIdentifier(snapshot.base);
+    if (isResourceIdentifier(specializationBase)) {
+      w.lineSM(`static readonly resourceType = ${JSON.stringify(specializationBase.name)}`);
+    } else if (isProfileIdentifier(specializationBase) || isSnapshotProfileIdentifier(specializationBase)) {
+      w.logger()?.error(
+        `Cannot emit static resourceType for profile '${profileClassName}': base '${snapshot.base.url}' does not resolve to a specialization`
+      );
+    }
     w.lineSM(`static readonly canonicalUrl = ${JSON.stringify(canonicalUrl)}`);
     w.line();
     generateStaticSliceFields2(w, sliceDefs);
@@ -7340,20 +7671,72 @@ var generateProfileClass = (w, tsIndex, snapshot) => {
 };
 
 // src/api/writer-generator/typescript/writer.ts
-var resolveTsAssets = (fn) => {
-  const __dirname = Path5.dirname(fileURLToPath(import.meta.url));
-  const __filename = fileURLToPath(import.meta.url);
-  if (__filename.endsWith("dist/index.js")) {
-    return Path5.resolve(__dirname, "..", "assets", "api", "writer-generator", "typescript", fn);
-  }
-  return Path5.resolve(__dirname, "../../../..", "assets", "api", "writer-generator", "typescript", fn);
-};
+var resolveTsAssets = (fn) => resolveGeneratorAsset(import.meta.url, "typescript", fn);
 var leafOf3 = (path) => path[path.length - 1] ?? "";
 var TS_HARDCODED_GENERIC_NAMES = /* @__PURE__ */ new Set(["Reference", "Coding", "CodeableConcept"]);
+var CODE_SYSTEM_SUFFIX_RE = /CodeSystem$/;
+var CHOICE_SUFFIX_RE = /\[x\]/g;
+var INVALID_TS_IDENTIFIER_RUN_RE = /[^A-Za-z0-9_$]+/g;
+var PACKAGE_PATH_SEPARATOR_RE = /\\/g;
+var INVALID_PACKAGE_DIR_RUN_RE = /[^a-z0-9-]+/g;
+var PACKAGE_DIR_EDGE_RE = /^-+|-+$/g;
+var TS_IDENTIFIER_START_RE = /^[A-Za-z_$]/;
+var validTsIdentifier = (source) => {
+  const normalized = source.replace(CHOICE_SUFFIX_RE, "_x_").replace(INVALID_TS_IDENTIFIER_RUN_RE, "_");
+  return TS_IDENTIFIER_START_RE.test(normalized) ? normalized : `_${normalized}`;
+};
+var terminologySymbolName = (resource) => {
+  const sourceName = resource.name ?? resource.id ?? tsNameFromCanonical(resource.url) ?? "Terminology";
+  return validTsIdentifier(`${uppercaseFirstLetter(sourceName)}${resource.resourceType}`);
+};
+var terminologyResourceIdentity = (resource) => `${resource.id ?? ""}\0${resource.name ?? ""}`;
+var safePackageDir = (source) => {
+  const normalized = tsPackageDir(source.replace(PACKAGE_PATH_SEPARATOR_RE, "_"));
+  return normalized.replace(INVALID_PACKAGE_DIR_RUN_RE, "-").replace(PACKAGE_DIR_EDGE_RE, "") || "package";
+};
+var allocateTerminologySymbols = (resources) => {
+  const baseNames = resources.map(terminologySymbolName);
+  const counts = {};
+  for (const name of baseNames) counts[name] = (counts[name] ?? 0) + 1;
+  const used = /* @__PURE__ */ new Set();
+  return resources.map((resource, index) => {
+    const baseName = baseNames[index] ?? "Terminology";
+    const localIdentity = tsNameFromCanonical(resource.url) ?? resource.id ?? "Resource";
+    const desired = counts[baseName] === 1 ? baseName : validTsIdentifier(`${baseName}_${pascalCase(localIdentity)}`);
+    let symbol = desired;
+    let suffix = 2;
+    while (used.has(symbol)) {
+      symbol = `${desired}_${suffix}`;
+      suffix += 1;
+    }
+    used.add(symbol);
+    return { resource, symbol };
+  });
+};
 var TypeScript = class extends Writer {
+  packageDirectories = /* @__PURE__ */ new Map();
   constructor(options) {
     super({ lineWidth: 120, ...options, resolveAssets: options.resolveAssets ?? resolveTsAssets });
   }
+  /** The package's physical output directory: consults the collision-suffix
+   *  map, so it can differ from the logical `tsPackageDir(name)` in name.ts
+   *  (e.g. `hl7-fhir-r4-core--2`). Unprefixed = stateful writer method. */
+  packageDir(physical) {
+    const pkg = "package" in physical ? { name: physical.package, version: physical.version } : physical;
+    return this.packageDirectories.get(packageMetaToNpm(pkg)) ?? safePackageDir(pkg.name);
+  }
+  /** The module's physical position in the output tree: `packageDir/ModuleName`. */
+  modulePath(identifier) {
+    return `${this.packageDir(identifier)}/${tsModuleName(identifier)}`;
+  }
+  moduleSpecifier(specifier) {
+    if (this.opts.moduleSpecifierStyle !== "node-esm" || !specifier.startsWith(".")) return specifier;
+    return specifier.endsWith(".js") ? specifier : `${specifier}.js`;
+  }
+  directorySpecifier(specifier) {
+    if (this.opts.moduleSpecifierStyle !== "node-esm" || !specifier.startsWith(".")) return specifier;
+    return `${specifier}/index.js`;
+  }
   ifElseChain(branches, elseBody) {
     branches.forEach((branch, i) => {
       const prefix = i === 0 ? "if" : "} else if";
@@ -7375,7 +7758,8 @@ var TypeScript = class extends Writer {
     const typeOnly = typeof last === "object" ? last.typeOnly : false;
     const entities = typeof last === "object" ? rest.slice(0, -1) : rest;
     const keyword = typeOnly ? "import type" : "import";
-    const singleLine = `${keyword} { ${entities.join(", ")} } from "${tsPackageName}"`;
+    const specifier = this.moduleSpecifier(tsPackageName);
+    const singleLine = `${keyword} { ${entities.join(", ")} } from "${specifier}"`;
     if (singleLine.length <= (this.opts.lineWidth ?? 120)) {
       this.lineSM(singleLine);
     } else {
@@ -7383,14 +7767,27 @@ var TypeScript = class extends Writer {
         for (const entity of entities) {
           this.line(`${entity},`);
         }
-      }, [` from "${tsPackageName}";`]);
+      }, [` from "${specifier}";`]);
     }
   }
-  generateFhirPackageIndexFile(schemas) {
+  tsExport(from, ...rest) {
+    const last = rest[rest.length - 1];
+    const typeOnly = typeof last === "object" ? last.typeOnly : false;
+    const entities = typeof last === "object" ? rest.slice(0, -1) : rest;
+    const keyword = typeOnly ? "export type" : "export";
+    this.lineSM(`${keyword} { ${entities.join(", ")} } from "${this.moduleSpecifier(from)}"`);
+  }
+  /** `export * from` a module, or a directory barrel when `barrel` is set. */
+  tsExportAll(from, opts) {
+    const specifier = opts?.barrel ? this.directorySpecifier(from) : this.moduleSpecifier(from);
+    this.lineSM(`export * from "${specifier}"`);
+  }
+  generateFhirPackageIndexFile(schemas, hasTerminology = false) {
     this.cat("index.ts", () => {
+      if (hasTerminology) this.tsExportAll("./terminology");
       const profiles = schemas.filter(isSnapshotProfileTypeSchema);
       if (profiles.length > 0) {
-        this.lineSM(`export * from "./profiles"`);
+        this.tsExportAll("./profiles", { barrel: true });
       }
       let exports$1 = schemas.flatMap((schema) => {
         const resourceName = tsResourceName(schema.identifier);
@@ -7414,11 +7811,12 @@ var TypeScript = class extends Writer {
       );
       for (const exp of exports$1) {
         this.debugComment(exp.identifier);
+        const from = `./${exp.tsPackageName}`;
         if (exp.typeExports.length > 0) {
-          this.lineSM(`export type { ${exp.typeExports.join(", ")} } from "./${exp.tsPackageName}"`);
+          this.tsExport(from, ...exp.typeExports, { typeOnly: true });
         }
         if (exp.valueExports.length > 0) {
-          this.lineSM(`export { ${exp.valueExports.join(", ")} } from "./${exp.tsPackageName}"`);
+          this.tsExport(from, ...exp.valueExports);
         }
       }
     });
@@ -7430,7 +7828,7 @@ var TypeScript = class extends Writer {
       for (const dep of schema.dependencies) {
         if (["complex-type", "resource", "logical"].includes(dep.kind)) {
           imports.push({
-            tsPackage: `${importPrefix}${tsModulePath(dep)}`,
+            tsPackage: `${importPrefix}${this.modulePath(dep)}`,
             name: tsResourceName(dep),
             dep
           });
@@ -7451,7 +7849,7 @@ var TypeScript = class extends Writer {
         const elementUrl = "http://hl7.org/fhir/StructureDefinition/Element";
         const element = tsIndex.resolveByUrl(schema.identifier.package, elementUrl);
         if (!element) throw new Error(`'${elementUrl}' not found for ${schema.identifier.package}.`);
-        this.tsImport(`${importPrefix}${tsModulePath(element.identifier)}`, "Element", { typeOnly: true });
+        this.tsImport(`${importPrefix}${this.modulePath(element.identifier)}`, "Element", { typeOnly: true });
       }
     }
   }
@@ -7460,7 +7858,7 @@ var TypeScript = class extends Writer {
     if (complexTypeDeps && complexTypeDeps.length > 0) {
       for (const dep of complexTypeDeps) {
         this.debugComment(dep);
-        this.lineSM(`export type { ${tsResourceName(dep)} } from "${`../${tsModulePath(dep)}`}"`);
+        this.tsExport(`../${this.modulePath(dep)}`, tsResourceName(dep), { typeOnly: true });
       }
       this.line();
     }
@@ -7582,7 +7980,7 @@ var TypeScript = class extends Writer {
         });
       });
     } else if (isSpecializationTypeSchema(schema)) {
-      const isFamilyType = mkIsFamilyType(tsIndex);
+      const isFamilyType = tsIndex.isFamilyType;
       this.cat(`${tsModuleFileName(schema.identifier)}`, () => {
         this.generateDisclaimer();
         this.generateDependenciesImports(tsIndex, schema);
@@ -7600,6 +7998,204 @@ var TypeScript = class extends Writer {
       throw new Error(`Profile generation not implemented for kind: ${schema.identifier.kind}`);
     }
   }
+  /** Normalized terminology types: the FHIR vocabulary comes from the generated
+   *  CodeSystem type when the closure provides one; a package-free closure gets
+   *  a self-contained copy of the R4/R5 content-mode vocabulary instead. */
+  generateTerminologyTypes(codeSystemImport) {
+    this.cat("terminology-types.ts", () => {
+      this.generateDisclaimer();
+      if (codeSystemImport) this.tsImport(codeSystemImport, "CodeSystem", { typeOnly: true });
+      this.line();
+      const contentType = codeSystemImport ? `CodeSystem["content"]` : `("not-present" | "example" | "fragment" | "complete" | "supplement")`;
+      this.lineSM(`export type TerminologyVerification = "registry-integrity" | "unverifiable" | (string & {})`);
+      this.line();
+      this.curlyBlock(["type", "TerminologyEntryBase", "="], () => {
+        this.lineSM("canonicalUrl: string");
+        this.lineSM("packageId: string");
+        this.lineSM("packageVersion: string");
+        this.lineSM("verification: TerminologyVerification");
+      }, [";"]);
+      this.line();
+      this.line("/** `contentMode` is a CodeSystem concept; the other entry kinds have none. */");
+      this.curlyBlock(["export", "type", "CodeSystemEntry", "=", "TerminologyEntryBase", "&"], () => {
+        this.lineSM(`resourceType: "CodeSystem"`);
+        this.lineSM(`contentMode?: ${contentType}`);
+      }, [";"]);
+      this.line();
+      this.curlyBlock(["export", "type", "ValueSetEntry", "=", "TerminologyEntryBase", "&"], () => {
+        this.lineSM(`resourceType: "ValueSet"`);
+      }, [";"]);
+      this.line();
+      this.curlyBlock(["export", "type", "NamingSystemEntry", "=", "TerminologyEntryBase", "&"], () => {
+        this.lineSM(`resourceType: "NamingSystem"`);
+      }, [";"]);
+      this.line();
+      this.line("/** One normalized terminology resource, discriminated by `resourceType`. */");
+      this.lineSM("export type TerminologyEntry = CodeSystemEntry | ValueSetEntry | NamingSystemEntry");
+      this.line();
+      this.line("/** A complete CodeSystem whose codes are embedded: the simplified runtime surface. */");
+      this.curlyBlock([
+        "export",
+        "type",
+        "CodedTerminologyEntry<Code extends string = string>",
+        "=",
+        "CodeSystemEntry",
+        "&"
+      ], () => {
+        this.lineSM(`contentMode: "complete"`);
+        this.lineSM("codes: readonly Code[]");
+        this.lineSM("displays: Readonly<Partial<Record<Code, string>>>");
+      }, [";"]);
+    });
+  }
+  /** Emitted terminology, resolved ahead of module generation so profile
+   *  emission can reference the allocated symbols. Keyed by package dir. */
+  terminologyModules = /* @__PURE__ */ new Map();
+  /** Coded systems across every emitted terminology module, by canonical URL. */
+  terminologyCodeIndex = /* @__PURE__ */ new Map();
+  prepareTerminology(generationUnits) {
+    this.terminologyModules = /* @__PURE__ */ new Map();
+    this.terminologyCodeIndex = /* @__PURE__ */ new Map();
+    for (const [packageDir, unit] of [...generationUnits].sort(([left], [right]) => left.localeCompare(right))) {
+      if (unit.terminology) this.prepareTerminologyModule(packageDir, unit.terminology);
+    }
+  }
+  prepareTerminologyModule(packageDir, packageTerminology) {
+    const { packageMeta: pkg } = packageTerminology;
+    const verification = this.opts.terminology?.packageVerification?.[packageMetaToNpm(pkg)] ?? "not-recorded";
+    const dedupedEntries = mkTerminologyEntries(packageTerminology, verification, this.logger());
+    const sortedResources = dedupedEntries.slice().sort(({ resource: left }, { resource: right }) => {
+      if (left.resourceType !== right.resourceType) return left.resourceType.localeCompare(right.resourceType);
+      const symbolOrder = terminologySymbolName(left).localeCompare(terminologySymbolName(right));
+      if (symbolOrder !== 0) return symbolOrder;
+      const canonicalOrder = left.url.localeCompare(right.url);
+      if (canonicalOrder !== 0) return canonicalOrder;
+      return terminologyResourceIdentity(left).localeCompare(terminologyResourceIdentity(right));
+    });
+    const allocated = allocateTerminologySymbols(sortedResources.map(({ resource }) => resource));
+    const allocatedEntries = sortedResources.map(({ entry }, index) => ({
+      entry,
+      symbol: allocated[index]?.symbol ?? "Terminology"
+    }));
+    this.terminologyModules.set(packageDir, allocatedEntries);
+    for (const { entry, symbol } of allocatedEntries) {
+      if ("codes" in entry && !this.terminologyCodeIndex.has(entry.canonicalUrl))
+        this.terminologyCodeIndex.set(entry.canonicalUrl, {
+          moduleDir: packageDir,
+          symbol,
+          codes: new Set(entry.codes)
+        });
+    }
+  }
+  /** Enum validations whose value lists are fully explained by emitted coded
+   *  systems reference those systems' `codes` instead of inlining literals.
+   *  Returns the replacement expression per field and the value imports the
+   *  profile module needs. Only whole-system matches convert; anything else
+   *  stays an inline literal, so unlinked output is unchanged. */
+  linkFieldEnum(tsIndex, field) {
+    if (isChoiceDeclarationField(field)) return void 0;
+    if (!field.enum || field.enum.values.length === 0 || !field.binding) return void 0;
+    const binding = tsIndex.resolveByUrl(field.binding.package, field.binding.url);
+    if (!binding) return void 0;
+    let concepts = "concept" in binding ? binding.concept : void 0;
+    if (!concepts) {
+      const dependencies = "dependencies" in binding ? binding.dependencies ?? [] : [];
+      const valueSets = dependencies.filter((dep) => dep.kind === "value-set");
+      const valueSetId = valueSets.length === 1 ? valueSets[0] : void 0;
+      const valueSet = valueSetId ? tsIndex.resolveByUrl(valueSetId.package, valueSetId.url) : void 0;
+      concepts = valueSet && "concept" in valueSet ? valueSet.concept : void 0;
+      if (!concepts && valueSetId && tsIndex.register) {
+        concepts = extractValueSetConceptsByUrl(
+          tsIndex.register,
+          { name: valueSetId.package, version: valueSetId.version },
+          valueSetId.url,
+          this.logger()
+        );
+      }
+    }
+    if (!concepts || concepts.length === 0) return void 0;
+    const conceptCodes = new Set(concepts.map(({ code }) => code));
+    const values = field.enum.values;
+    if (values.length !== conceptCodes.size || !values.every((value) => conceptCodes.has(value))) return void 0;
+    const bySystem = /* @__PURE__ */ new Map();
+    for (const concept of concepts) {
+      if (!concept.system) continue;
+      const codes = bySystem.get(concept.system) ?? /* @__PURE__ */ new Set();
+      codes.add(concept.code);
+      bySystem.set(concept.system, codes);
+    }
+    const spreads = [];
+    const covered = /* @__PURE__ */ new Set();
+    const imports = /* @__PURE__ */ new Map();
+    for (const [system, codes] of bySystem) {
+      const indexed = this.terminologyCodeIndex.get(system);
+      if (!indexed) continue;
+      if (codes.size !== indexed.codes.size || ![...codes].every((code) => indexed.codes.has(code))) continue;
+      spreads.push(`...${indexed.symbol}.codes`);
+      for (const code of codes) covered.add(code);
+      const symbols = imports.get(indexed.moduleDir) ?? /* @__PURE__ */ new Set();
+      symbols.add(indexed.symbol);
+      imports.set(indexed.moduleDir, symbols);
+    }
+    if (spreads.length === 0) return void 0;
+    const literals = values.filter((value) => !covered.has(value)).map((value) => JSON.stringify(value));
+    return { expr: `[${[...spreads, ...literals].join(", ")}]`, imports };
+  }
+  enumTerminologyLinks(tsIndex, snapshot) {
+    const exprs = /* @__PURE__ */ new Map();
+    const imports = /* @__PURE__ */ new Map();
+    if (this.terminologyCodeIndex.size === 0) return { exprs, imports };
+    for (const [name, field] of Object.entries(snapshot.fields)) {
+      const link = this.linkFieldEnum(tsIndex, field);
+      if (!link) continue;
+      exprs.set(name, link.expr);
+      for (const [dir, symbols] of link.imports) {
+        const merged = imports.get(dir) ?? /* @__PURE__ */ new Set();
+        for (const symbol of symbols) merged.add(symbol);
+        imports.set(dir, merged);
+      }
+    }
+    return { exprs, imports };
+  }
+  generateTerminologyModule(packageDir) {
+    const allocatedEntries = this.terminologyModules.get(packageDir) ?? [];
+    this.cat("terminology.ts", () => {
+      this.generateDisclaimer();
+      const anyCoded = allocatedEntries.some(({ entry }) => "codes" in entry);
+      const typeImports = anyCoded ? ["TerminologyEntry", "CodedTerminologyEntry"] : ["TerminologyEntry"];
+      this.tsImport("../terminology-types", ...typeImports, { typeOnly: true });
+      this.line();
+      allocatedEntries.forEach(({ entry, symbol }, index) => {
+        const coded = "codes" in entry;
+        const codeName = symbol.endsWith("CodeSystem") ? symbol.replace(CODE_SYSTEM_SUFFIX_RE, "Code") : `${symbol}Code`;
+        if (coded) {
+          const union = entry.codes.map((code) => JSON.stringify(code)).join(" | ") || "never";
+          this.lineSM(`export type ${codeName} = ${union}`);
+        }
+        const satisfiesClause = coded ? ` as const satisfies CodedTerminologyEntry<${codeName}>;` : " as const satisfies TerminologyEntry;";
+        this.curlyBlock(["export", "const", symbol, "="], () => {
+          this.line(`canonicalUrl: ${JSON.stringify(entry.canonicalUrl)},`);
+          this.line(`packageId: ${JSON.stringify(entry.packageId)},`);
+          this.line(`packageVersion: ${JSON.stringify(entry.packageVersion)},`);
+          this.line(`verification: ${JSON.stringify(entry.verification)},`);
+          this.line(`resourceType: ${JSON.stringify(entry.resourceType)},`);
+          if ("contentMode" in entry && entry.contentMode !== void 0)
+            this.line(`contentMode: ${JSON.stringify(entry.contentMode)},`);
+          if (coded) {
+            this.line(`codes: [${entry.codes.map((code) => JSON.stringify(code)).join(", ")}],`);
+            this.curlyBlock(["displays:"], () => {
+              for (const code of entry.codes) {
+                const display = entry.displays[code];
+                if (display === void 0) continue;
+                this.line(`${tsObjectKey(code)}: ${JSON.stringify(display)},`);
+              }
+            }, [","]);
+          }
+        }, [satisfiesClause]);
+        if (index < allocatedEntries.length - 1) this.line();
+      });
+    });
+  }
   async generate(tsIndex) {
     const typesToGenerate = [
       ...tsIndex.collectComplexTypes(),
@@ -7607,20 +8203,103 @@ var TypeScript = class extends Writer {
       ...tsIndex.collectLogicalModels(),
       ...this.opts.generateProfile ? tsIndex.collectSnapshotProfiles() : []
     ];
-    const grouped = groupByPackages(typesToGenerate);
+    const terminologyPackages = this.opts.terminology?.packages;
+    const terminology = this.opts.terminology?.enabled ? (tsIndex.register?.allTerminology() ?? []).filter(
+      ({ packageMeta: pkg, resources }) => resources.length > 0 && (terminologyPackages === void 0 || terminologyPackages.includes(packageMetaToNpm(pkg)))
+    ) : [];
+    const logicalUnits = /* @__PURE__ */ new Map();
+    for (const schema of typesToGenerate) {
+      const pkg = packageMeta(schema);
+      const identity = packageMetaToNpm(pkg);
+      const unit = logicalUnits.get(identity) ?? { packageMeta: pkg, packageSchemas: [] };
+      unit.packageSchemas.push(schema);
+      logicalUnits.set(identity, unit);
+    }
+    for (const packageTerminology of terminology) {
+      const identity = packageMetaToNpm(packageTerminology.packageMeta);
+      const unit = logicalUnits.get(identity) ?? {
+        packageMeta: packageTerminology.packageMeta,
+        packageSchemas: []
+      };
+      unit.terminology = packageTerminology;
+      logicalUnits.set(identity, unit);
+    }
+    const identitiesByPackageName = /* @__PURE__ */ new Map();
+    for (const [identity, { packageMeta: pkg }] of logicalUnits) {
+      const identities = identitiesByPackageName.get(pkg.name) ?? [];
+      identities.push(identity);
+      identitiesByPackageName.set(pkg.name, identities);
+    }
+    const unitsByBaseDir = /* @__PURE__ */ new Map();
+    for (const [identity, { packageMeta: pkg, packageSchemas, terminology: packageTerminology }] of logicalUnits) {
+      const directorySource = (identitiesByPackageName.get(pkg.name)?.length ?? 0) > 1 ? packageMetaToNpm(pkg) : pkg.name;
+      const baseDir = safePackageDir(directorySource);
+      const units = unitsByBaseDir.get(baseDir) ?? [];
+      const schemasByIdentity = new Map(
+        packageSchemas.map((schema) => [JSON.stringify(schema.identifier), schema])
+      );
+      const sortedSchemas = [...schemasByIdentity.values()].sort(
+        (left, right) => left.identifier.name.localeCompare(right.identifier.name)
+      );
+      units.push({ identity, packageSchemas: sortedSchemas, terminology: packageTerminology });
+      unitsByBaseDir.set(baseDir, units);
+    }
+    const generationUnits = /* @__PURE__ */ new Map();
+    const usedPackageDirs = /* @__PURE__ */ new Set();
+    for (const [baseDir, units] of unitsByBaseDir) {
+      if (units.length !== 1) continue;
+      const unit = units[0];
+      if (!unit) continue;
+      generationUnits.set(baseDir, unit);
+      usedPackageDirs.add(baseDir);
+    }
+    for (const [baseDir, units] of [...unitsByBaseDir].sort(([left], [right]) => left.localeCompare(right))) {
+      if (units.length < 2) continue;
+      let suffix = 1;
+      for (const unit of units.sort((left, right) => left.identity.localeCompare(right.identity))) {
+        let packageDir = `${baseDir}--${suffix}`;
+        while (usedPackageDirs.has(packageDir)) {
+          suffix += 1;
+          packageDir = `${baseDir}--${suffix}`;
+        }
+        generationUnits.set(packageDir, unit);
+        usedPackageDirs.add(packageDir);
+        suffix += 1;
+      }
+    }
+    this.packageDirectories = new Map(
+      [...generationUnits].flatMap(([packageDir, unit]) => {
+        if (unit.terminology) {
+          return [[packageMetaToNpm(unit.terminology.packageMeta), packageDir]];
+        }
+        const schema = unit.packageSchemas[0];
+        return schema ? [[packageMetaToNpm(packageMeta(schema)), packageDir]] : [];
+      })
+    );
     const hasProfiles = this.opts.generateProfile && typesToGenerate.some(isSnapshotProfileTypeSchema);
+    this.prepareTerminology(generationUnits);
     this.cd("/", () => {
       if (hasProfiles) {
         this.cp("profile-helpers.ts", "profile-helpers.ts");
       }
-      for (const [packageName, packageSchemas] of Object.entries(grouped)) {
-        const packageDir = tsPackageDir(packageName);
+      if (terminology.length > 0) {
+        const codeSystemSchema = typesToGenerate.find(
+          (schema) => schema.identifier.url === "http://hl7.org/fhir/StructureDefinition/CodeSystem"
+        );
+        this.generateTerminologyTypes(
+          codeSystemSchema ? `./${this.packageDir(codeSystemSchema.identifier)}/CodeSystem` : void 0
+        );
+      }
+      for (const [packageDir, { packageSchemas, terminology: terminology2 }] of [...generationUnits].sort(
+        ([left], [right]) => left.localeCompare(right)
+      )) {
         this.cd(packageDir, () => {
           for (const schema of packageSchemas) {
             this.generateResourceModule(tsIndex, schema);
           }
           generateProfileIndexFile(this, tsIndex, packageSchemas.filter(isSnapshotProfileTypeSchema));
-          this.generateFhirPackageIndexFile(packageSchemas);
+          if (terminology2) this.generateTerminologyModule(packageDir);
+          this.generateFhirPackageIndexFile(packageSchemas, terminology2 !== void 0);
         });
       }
     });
@@ -7638,11 +8317,27 @@ var formatLoc = (loc) => {
   if (loc >= 1e3) return `${(loc / 1e3).toFixed(1)} kloc`;
   return `${loc} loc`;
 };
+var formatReportEntry = (entry) => {
+  const pkg = (p) => `${p.name}@${p.version}`;
+  switch (entry.kind) {
+    case "exclusion":
+      return `excluded ${entry.url} (${pkg(entry.package)}): ${entry.reason}`;
+    case "index-recovery":
+      return `recovered index for ${pkg(entry.package)}: ${entry.reason}, ${entry.recovered} resources`;
+    case "deprecation":
+      return `deprecation: ${entry.message}`;
+    default:
+      return JSON.stringify(entry);
+  }
+};
 var prettyReport = (report, options = {}) => {
-  const { success, filesGenerated, errors, warnings, duration } = report;
+  const { success, filesGenerated, errors, warnings, duration, inputReport } = report;
   const fileLimit = options.fileLimit ?? 20;
   const errorsStr = errors.length > 0 ? `Errors: ${errors.join(", ")}` : void 0;
   const warningsStr = warnings.length > 0 ? `Warnings: ${warnings.join(", ")}` : void 0;
+  const inputFixesStr = inputReport && inputReport.length > 0 ? [`Input fixes (${inputReport.length}):`, ...inputReport.map((e) => `  - ${formatReportEntry(e)}`)].join(
+    "\n"
+  ) : void 0;
   let totalFiles = 0;
   let totalLoc = 0;
   const aggregateByDir = (files) => {
@@ -7681,6 +8376,7 @@ ${fileLines}`;
   return [
     `Generated files (${totalFiles} files, ${formatLoc(totalLoc)}):`,
     ...groupStrs,
+    inputFixesStr,
     errorsStr,
     warningsStr,
     `Duration: ${Math.round(duration)}ms`,
@@ -7707,40 +8403,69 @@ var APIBuilder = class {
     const defaultOpts = {
       outputDir: "./generated",
       cleanOutput: true,
-      throwException: false,
-      registry: void 0,
-      dropCanonicalManagerCache: false
+      throwException: false
     };
     const apiBuilderKeys = [
       "outputDir",
       "cleanOutput",
       "throwException",
-      "typeSchema",
-      "registry",
-      "dropCanonicalManagerCache"
+      "typeSchema"
     ];
     const opts = {
       ...defaultOpts,
       ...Object.fromEntries(apiBuilderKeys.filter((k) => userOpts[k] !== void 0).map((k) => [k, userOpts[k]]))
     };
-    if (userOpts.manager && userOpts.register) {
-      throw new Error("Cannot provide both 'manager' and 'register' options. Use one or the other.");
-    }
     this.managerInput = {
       npmPackages: [],
       localSDs: [],
       localTgzPackages: []
     };
     this.prebuiltRegister = userOpts.register;
-    this.manager = userOpts.manager ?? CanonicalManager({
+    this.logger = userOpts.logger ?? mkLogger({ prefix: "api" });
+    const isManagerInstance = (value) => typeof value.init === "function";
+    if (userOpts.manager)
+      this.logger.warn("'manager' is deprecated; pass the instance via 'canonicalManager' instead.");
+    const injectedManager = userOpts.manager ?? (userOpts.canonicalManager && isManagerInstance(userOpts.canonicalManager) ? userOpts.canonicalManager : void 0);
+    if (injectedManager && userOpts.register) {
+      throw new Error("Cannot provide both a CanonicalManager instance and 'register'. Use one or the other.");
+    }
+    const cmOptions = userOpts.canonicalManager && !isManagerInstance(userOpts.canonicalManager) ? userOpts.canonicalManager : void 0;
+    const cm = { ...cmOptions };
+    const deprecatedCmOptions = [
+      ["registry", "registry", userOpts.registry],
+      ["packageIndex", "packageIndex", userOpts.packageIndex],
+      ["dropCache", "dropCanonicalManagerCache", userOpts.dropCanonicalManagerCache],
+      ["patches", "patches", userOpts.patches]
+    ];
+    for (const [key, oldName, value] of deprecatedCmOptions) {
+      if (value === void 0) continue;
+      if (cm[key] !== void 0)
+        throw new Error(`Cannot set both 'canonicalManager.${key}' and the deprecated '${oldName}'.`);
+      this.logger.warn(
+        `'${oldName}' is deprecated; use 'canonicalManager: { ${key} }' \u2014 it configures the CanonicalManager package loader.`
+      );
+      cm[key] = value;
+    }
+    this.manager = injectedManager ?? CanonicalManager({
       packages: [],
-      workingDir: ".codegen-cache/canonical-manager-cache",
-      registry: userOpts.registry,
-      dropCache: userOpts.dropCanonicalManagerCache,
+      workingDir: cm.workingDir ?? ".codegen-cache/canonical-manager-cache",
+      registry: cm.registry,
+      dropCache: cm.dropCache,
+      patches: {
+        packageJson: cm.patches?.packageJson ?? [],
+        indexEntry: [
+          ...userOpts.builtinPatches ?? true ? builtinPatches.indexEntry ?? [] : [],
+          ...cm.patches?.indexEntry ?? []
+        ],
+        fhirResource: cm.patches?.fhirResource ?? []
+      },
       preprocessPackage: userOpts.preprocessPackage,
+      packageIndex: cm.packageIndex,
       ignorePackageIndex: userOpts.ignorePackageIndex
     });
-    this.logger = userOpts.logger ?? mkLogger({ prefix: "api" });
+    if (cmOptions && (injectedManager || userOpts.register)) {
+      this.logger.warn("loader configuration is ignored when a prebuilt manager/`register` is provided.");
+    }
     this.options = opts;
   }
   fromPackage(packageName, version) {
@@ -7785,7 +8510,7 @@ var APIBuilder = class {
   typescript(userOpts) {
     const defaultWriterOpts = {
       logger: this.logger,
-      outputDir: Path5.join(this.options.outputDir, "/types"),
+      outputDir: this.generatorOutputDir("/types"),
       tabSize: 4,
       withDebugComment: false,
       commentLinePrefix: "//",
@@ -7800,6 +8525,7 @@ var APIBuilder = class {
       ...defaultTsOpts,
       ...Object.fromEntries(Object.entries(userOpts).filter(([_, v]) => v !== void 0))
     };
+    if (opts.terminology?.enabled) this.wantsTerminologyTypes = true;
     const generator = new TypeScript(opts);
     this.generators.push({ name: "typescript", writer: generator });
     this.logger.debug(`Configured TypeScript generator (${JSON.stringify(opts, void 0, 2)})`);
@@ -7852,7 +8578,7 @@ var APIBuilder = class {
   csharp(userOptions) {
     const defaultWriterOpts = {
       logger: this.logger,
-      outputDir: Path5.join(this.options.outputDir, "/types"),
+      outputDir: this.generatorOutputDir("/types"),
       tabSize: 4,
       withDebugComment: false,
       commentLinePrefix: "//"
@@ -7870,12 +8596,21 @@ var APIBuilder = class {
     this.logger.debug(`Configured C# generator`);
     return this;
   }
+  /** Set by `outputTo`, to tell an explicit output directory from the default one. */
+  explicitOutputDir;
+  /** Output directory for a generator being configured now. `subdir` applies only when
+   *  `outputTo` never named one. */
+  generatorOutputDir(subdir) {
+    if (this.explicitOutputDir !== void 0) return this.explicitOutputDir;
+    return subdir === void 0 ? this.options.outputDir : Path5.join(this.options.outputDir, subdir);
+  }
   /**
-   * Set the output directory for all generators
+   * Set the output directory for all generators, whenever they are configured
    */
   outputTo(directory) {
     this.logger.debug(`Setting output directory: ${directory}`);
     this.options.outputDir = directory;
+    this.explicitOutputDir = directory;
     for (const gen of this.generators) {
       gen.writer.setOutputDir(directory);
     }
@@ -7889,6 +8624,10 @@ var APIBuilder = class {
     this.options.cleanOutput = enabled;
     return this;
   }
+  /** Set when a TypeScript generator wants terminology modules: the emitted
+   *  terminology types are derived from the generated CodeSystem type, so it
+   *  must survive tree shaking even when the user's rules don't ask for it. */
+  wantsTerminologyTypes = false;
   typeSchema(cfg) {
     this.options.typeSchema ??= {};
     if (cfg.treeShake) {
@@ -7938,7 +8677,8 @@ var APIBuilder = class {
     };
     this.logger.debug(`Starting generation with ${this.generators.length} generators`);
     try {
-      if (this.options.cleanOutput) await cleanup(this.options, this.logger);
+      const writesToDisk = this.generators.some((gen) => !gen.writer.opts.inMemoryOnly);
+      if (this.options.cleanOutput && writesToDisk) await cleanup(this.options, this.logger);
       let register;
       if (this.prebuiltRegister) {
         this.logger.info("Using prebuilt register");
@@ -7960,6 +8700,7 @@ var APIBuilder = class {
           logger: this.logger.fork("reg"),
           focusedPackages: packageMetas
         });
+        result.inputReport = this.manager.report();
       }
       const tsLogger = this.logger.fork("ts");
       const { schemas: typeSchemas, collisions } = await generateTypeSchemas(
@@ -7973,12 +8714,18 @@ var APIBuilder = class {
       };
       const tsIndexOpts = { register, irReport, logger: tsLogger };
       let tsIndex = mkTypeSchemaIndex(typeSchemas, tsIndexOpts);
-      if (this.options.typeSchema?.treeShake)
-        tsIndex = treeShake(
-          tsIndex,
-          this.options.typeSchema.treeShake,
-          this.options.typeSchema.treeShakeDefaults
-        );
+      if (this.options.typeSchema?.treeShake) {
+        let shake = this.options.typeSchema.treeShake;
+        if (this.wantsTerminologyTypes) {
+          const codeSystemCanonical = "http://hl7.org/fhir/StructureDefinition/CodeSystem";
+          const provider = tsIndex.schemas.find((schema) => schema.identifier.url === codeSystemCanonical);
+          if (provider) {
+            const pkg = provider.identifier.package;
+            shake = { ...shake, [pkg]: { ...shake[pkg] ?? {}, [codeSystemCanonical]: {} } };
+          }
+        }
+        tsIndex = treeShake(tsIndex, shake, this.options.typeSchema.treeShakeDefaults);
+      }
       if (this.options.typeSchema?.promoteLogical)
         tsIndex = promoteLogical(tsIndex, this.options.typeSchema.promoteLogical);
       tsLogger.printTagSummary();