@atomic-ehr/codegen 0.0.6 → 0.0.7-canary.20260224101452.ccac84d

package/dist/index.js

@@ -7,6 +7,7 @@ import Path5__default from 'path';
 import { CanonicalManager } from '@atomic-ehr/fhir-canonical-manager';
 import { fileURLToPath } from 'url';
 import * as fsPromises from 'fs/promises';
+import { createHash } from 'crypto';
 import * as YAML from 'yaml';
 import YAML__default from 'yaml';
 import * as fhirschema from '@atomic-ehr/fhirschema';
@@ -106,7 +107,7 @@ var CodegenLogger = class _CodegenLogger {
   warn(message) {
     this.tryWriteToConsole(2 /* WARN */, this.formatMessage("!", message, pc.yellow));
   }
-  dry_warn(message) {
+  dryWarn(message) {
     if (!this.dryWarnSet.has(message)) {
       this.warn(message);
       this.dryWarnSet.add(message);
@@ -258,6 +259,10 @@ var FileSystemWriter = class {
     if (this.currentFile) throw new Error("Can't open file when another file is open");
     if (fn.includes("/")) throw new Error(`Change file path separatly: ${fn}`);
     const relPath = Path5.normalize(`${this.currentDir}/${fn}`);
+    if (this.writtenFilesBuffer[relPath]) {
+      this.logger()?.warn(`File will be rewritten '${relPath}'`);
+      this.logger()?.debug(`File content: ${this.writtenFilesBuffer[relPath].tokens.join("")}`);
+    }
     try {
       const descriptor = this.onDiskOpenFile(relPath);
       this.logger()?.debug(`cat > '${relPath}'`);
@@ -402,8 +407,6 @@ var Writer = class extends FileSystemWriter {
     this.line(`]${endTokens?.filter(Boolean).join(" ") ?? ""}`);
   }
 };
-
-// src/typeschema/types.ts
 var extractNameFromCanonical = (canonical, dropFragment = true) => {
   let localName = canonical.split("/").pop();
   if (!localName) return void 0;
@@ -424,10 +427,11 @@ var packageMeta = (schema) => {
 };
 var packageMetaToFhir = (packageMeta2) => `${packageMeta2.name}#${packageMeta2.version}`;
 var packageMetaToNpm = (packageMeta2) => `${packageMeta2.name}@${packageMeta2.version}`;
+var hashSchema = (schema) => {
+  const json = JSON.stringify(schema);
+  return createHash("sha256").update(json).digest("hex").slice(0, 16);
+};
 var enrichFHIRSchema = (schema, packageMeta2) => {
-  if (!packageMeta2) {
-    packageMeta2 = { name: "undefined", version: "undefined" };
-  }
   return {
     ...schema,
     package_meta: schema.package_meta || packageMeta2,
@@ -681,7 +685,7 @@ var CSharp = class extends Writer {
   }
   determineFieldType(fieldName, field, packageName) {
     let typeName = this.getBaseTypeName(field);
-    if ("enum" in field && field.enum) {
+    if ("enum" in field && field.enum && !field.enum.isOpen) {
       typeName = this.registerAndGetEnumType(fieldName, field, packageName);
     }
     typeName = prefixReservedTypeName(typeName);
@@ -704,7 +708,7 @@ var CSharp = class extends Writer {
     const enumName = formatName(field.binding?.name ?? fieldName);
     const enumTypeName = `${enumName}Enum`;
     if (!this.enums[packageName]) this.enums[packageName] = {};
-    if (field.enum) this.enums[packageName][enumTypeName] = field.enum;
+    if (field.enum) this.enums[packageName][enumTypeName] = field.enum.values;
     return enumTypeName;
   }
   includeHelperMethods() {
@@ -1480,8 +1484,8 @@ var Python = class extends Writer {
   }
   determineFieldType(field) {
     let fieldType = field ? this.getBaseFieldType(field) : "";
-    if ("enum" in field && field.enum) {
-      const s = field.enum.map((e) => `"${e}"`).join(", ");
+    if ("enum" in field && field.enum && !field.enum.isOpen) {
+      const s = field.enum.values.map((e) => `"${e}"`).join(", ");
       fieldType = `Literal[${s}]`;
     }
     if (field.array) {
@@ -1758,7 +1762,8 @@ function mkValueSetIdentifierByUrl(register, pkg, fullValueSetUrl) {
     url: valueSetUrl
   };
 }
-function mkBindingIdentifier(fhirSchema, path, bindingName) {
+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 {
@@ -1770,6 +1775,146 @@ function mkBindingIdentifier(fhirSchema, path, bindingName) {
   };
 }
 
+// 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) => {
+      assert3(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 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(`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);
+  if (codes.length > MAX_ENUM_LENGTH) {
+    logger?.dryWarn(
+      `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/nested-types.ts
 function mkNestedIdentifier(register, fhirSchema, path, logger) {
   const nestedTypeOrigins = {};
@@ -1972,24 +2117,24 @@ function buildFieldType(register, fhirSchema, path, element, logger) {
   } else if (fhirSchema.derivation === "constraint") {
     return void 0;
   } else {
-    logger?.error(
-      `Can't recognize element type: <${fhirSchema.url}>.${path.join(".")} (pkg: '${packageMetaToFhir(fhirSchema.package_meta)}'): ${JSON.stringify(element, void 0, 2)}`
+    logger?.dryWarn(
+      `Can't recognize element type: <${fhirSchema.url}>.${path.join(".")} (pkg: '${packageMetaToFhir(fhirSchema.package_meta)}'): missing type info`
     );
-    throw new Error(`Unrecognized element type`);
+    return void 0;
   }
 }
 var mkField = (register, fhirSchema, path, element, logger) => {
   let binding;
-  let enumValues;
+  let enumResult;
   if (element.binding) {
-    binding = mkBindingIdentifier(fhirSchema, path, element.binding.bindingName);
-    if (element.binding.strength === "required" && element.type === "code") {
-      enumValues = buildEnum(register, fhirSchema, element, logger);
+    binding = mkBindingIdentifier(fhirSchema, path, element);
+    if (BINDABLE_TYPES.has(element.type ?? "")) {
+      enumResult = buildEnum(register, fhirSchema, element, logger);
     }
   }
   const fieldType = buildFieldType(register, fhirSchema, path, element, logger);
   if (!fieldType)
-    logger?.dry_warn(`Field type not found for '${fhirSchema.url}#${path.join(".")}' (${fhirSchema.derivation})`);
+    logger?.dryWarn(`Field type not found for '${fhirSchema.url}#${path.join(".")}' (${fhirSchema.derivation})`);
   return {
     type: fieldType,
     required: isRequired(register, fhirSchema, path),
@@ -2002,13 +2147,18 @@ var mkField = (register, fhirSchema, path, element, logger) => {
     choices: element.choices,
     choiceOf: element.choiceOf,
     binding,
-    enum: enumValues
+    enum: enumResult
   };
 };
 function isNestedElement(element) {
   const isBackbone = element.type === "BackboneElement";
   const isElement = element.type === "Element" && element.elements !== void 0 && Object.keys(element.elements).length > 0;
-  const elementsWithoutType = element.type === void 0 && element.choiceOf === void 0 && element.elements !== void 0 && Object.keys(element.elements).length > 0;
+  const elementsWithoutType = (
+    // FIXME: understand and make a decision.
+    // Problem example: http://hl7.org/cda/stds/core/StructureDefinition/SubstanceAdministration -> consumable
+    // Don't generate nested type for that field, but defetly expect it.
+    element.type === void 0 && element.choiceOf === void 0 && element.elements !== void 0 && Object.keys(element.elements).length > 0
+  );
   return isBackbone || isElement || elementsWithoutType;
 }
 function mkNestedField(register, fhirSchema, path, element, logger) {
@@ -2022,138 +2172,6 @@ function mkNestedField(register, fhirSchema, path, element, logger) {
   };
 }
 
-// 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) => {
-      assert3(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;
-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;
-  const shouldGenerateEnum = strength === "required" || strength === "extensible" && (element.type === "code" || element.type === "Coding") || strength === "preferred" && (element.type === "code" || element.type === "Coding");
-  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);
-  if (codes.length > MAX_ENUM_LENGTH) {
-    logger?.dry_warn(
-      `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 codes.length > 0 ? codes : void 0;
-}
-function generateBindingSchema(register, fhirSchema, path, element, logger) {
-  if (!element.binding?.valueSet) return void 0;
-  const identifier = mkBindingIdentifier(fhirSchema, path, element.binding.bindingName);
-  const fieldType = buildFieldType(register, fhirSchema, path, element, logger);
-  const valueSetIdentifier = mkValueSetIdentifierByUrl(
-    register,
-    fhirSchema.package_meta,
-    element.binding.valueSet
-  );
-  const dependencies = [];
-  if (fieldType) {
-    dependencies.push(fieldType);
-  }
-  dependencies.push(valueSetIdentifier);
-  const enumValues = buildEnum(register, fhirSchema, element, logger);
-  return {
-    identifier,
-    type: fieldType,
-    valueset: valueSetIdentifier,
-    strength: element.binding.strength,
-    enum: enumValues,
-    dependencies
-  };
-}
-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/transformer.ts
 function mkFields(register, fhirSchema, parentPath, elements, logger) {
   if (!elements) return void 0;
@@ -2188,21 +2206,6 @@ function extractFieldDependencies(fields) {
   }
   return deps;
 }
-function isExtensionSchema(fhirSchema, _identifier) {
-  if (fhirSchema.base === "Extension" || fhirSchema.base === "http://hl7.org/fhir/StructureDefinition/Extension") {
-    return true;
-  }
-  if (fhirSchema.url?.includes("/extension/") || fhirSchema.url?.includes("-extension")) {
-    return true;
-  }
-  if (fhirSchema.name?.toLowerCase().includes("extension")) {
-    return true;
-  }
-  if (fhirSchema.type === "Extension") {
-    return true;
-  }
-  return false;
-}
 async function transformValueSet(register, valueSet, logger) {
   if (!valueSet.url) throw new Error("ValueSet URL is required");
   const identifier = mkValueSetIdentifierByUrl(register, valueSet.package_meta, valueSet.url);
@@ -2284,15 +2287,13 @@ function extractExtensionValueTypes(register, fhirSchema, extensionUrl, logger)
   const uniq = new Map(valueTypes.map((type) => [type.url, type]));
   return Array.from(uniq.values());
 }
-function extractSubExtensions(register, fhirSchema, extensionUrl, logger) {
-  const extensionSchema = register.resolveFs(fhirSchema.package_meta, extensionUrl);
-  if (!extensionSchema?.elements) return void 0;
+var extractLegacySubExtensions = (register, extensionSchema, logger) => {
   const subExtensions = [];
+  if (!extensionSchema.elements) return subExtensions;
   for (const [key, element] of Object.entries(extensionSchema.elements)) {
     if (!key.startsWith("extension:")) continue;
     const sliceName = key.split(":")[1];
     if (!sliceName) continue;
-    const sliceUrl = element.url ?? sliceName;
     let valueType;
     for (const [elemKey, elemValue] of Object.entries(element.elements ?? {})) {
       if (elemValue.choiceOf !== "value" && !elemKey.startsWith("value")) continue;
@@ -2301,48 +2302,57 @@ function extractSubExtensions(register, fhirSchema, extensionUrl, logger) {
     }
     subExtensions.push({
       name: sliceName,
-      url: sliceUrl,
+      url: element.url ?? sliceName,
       valueType,
       min: element.min,
       max: element.max !== void 0 ? String(element.max) : void 0
     });
   }
-  const extensionElement = extensionSchema.elements.extension;
+  return subExtensions;
+};
+var extractSlicingSubExtensions = (extensionSchema) => {
+  const subExtensions = [];
+  const extensionElement = extensionSchema.elements?.extension;
   const slices = extensionElement?.slicing?.slices;
-  if (slices && typeof slices === "object") {
-    for (const [sliceName, sliceData] of Object.entries(slices)) {
-      const slice = sliceData;
-      const schema = slice.schema;
-      if (!schema) continue;
-      const sliceUrl = slice.match?.url ?? sliceName;
-      let valueType;
-      const schemaElements = schema.elements ?? {};
-      for (const [elemKey, elemValue] of Object.entries(schemaElements)) {
-        const elem = elemValue;
-        if (elem.choiceOf !== "value" && !elemKey.startsWith("value")) continue;
-        if (elem.type) {
-          valueType = {
-            kind: "complex-type",
-            package: extensionSchema.package_meta.name,
-            version: extensionSchema.package_meta.version,
-            name: elem.type,
-            url: `http://hl7.org/fhir/StructureDefinition/${elem.type}`
-          };
-          break;
-        }
+  if (!slices || typeof slices !== "object") return subExtensions;
+  for (const [sliceName, sliceData] of Object.entries(slices)) {
+    const slice = sliceData;
+    const schema = slice.schema;
+    if (!schema) continue;
+    let valueType;
+    for (const [elemKey, elemValue] of Object.entries(schema.elements ?? {})) {
+      const elem = elemValue;
+      if (elem.choiceOf !== "value" && !elemKey.startsWith("value")) continue;
+      if (elem.type) {
+        valueType = {
+          kind: "complex-type",
+          package: extensionSchema.package_meta.name,
+          version: extensionSchema.package_meta.version,
+          name: elem.type,
+          url: `http://hl7.org/fhir/StructureDefinition/${elem.type}`
+        };
+        break;
       }
-      subExtensions.push({
-        name: sliceName,
-        url: sliceUrl,
-        valueType,
-        min: schema._required ? 1 : schema.min ?? 0,
-        // biome-ignore lint/style/noNestedTernary : okay here
-        max: schema.max !== void 0 ? String(schema.max) : schema.array ? "*" : "1"
-      });
     }
+    subExtensions.push({
+      name: sliceName,
+      url: slice.match?.url ?? sliceName,
+      valueType,
+      min: schema._required ? 1 : schema.min ?? 0,
+      // biome-ignore lint/style/noNestedTernary : okay here
+      max: schema.max !== void 0 ? String(schema.max) : schema.array ? "*" : "1"
+    });
   }
+  return subExtensions;
+};
+var extractSubExtensions = (register, fhirSchema, extensionUrl, logger) => {
+  const extensionSchema = register.resolveFs(fhirSchema.package_meta, extensionUrl);
+  if (!extensionSchema?.elements) return void 0;
+  const legacySubs = extractLegacySubExtensions(register, extensionSchema, logger);
+  const slicingSubs = extractSlicingSubExtensions(extensionSchema);
+  const subExtensions = [...legacySubs, ...slicingSubs];
   return subExtensions.length > 0 ? subExtensions : void 0;
-}
+};
 function extractProfileExtensions(register, fhirSchema, logger) {
   const extensions = [];
   const addExtensionEntry = (path, name, schema) => {
@@ -2387,268 +2397,67 @@ function extractProfileExtensions(register, fhirSchema, logger) {
   return extensions;
 }
 async function transformFhirSchema(register, fhirSchema, logger) {
-  const schemas = transformFhirSchemaResource(register, fhirSchema, logger);
-  if (isExtensionSchema(fhirSchema, mkIdentifier(fhirSchema))) {
-    const schema = schemas[0];
-    if (!schema) throw new Error(`Expected schema to be defined`);
-    schema.metadata = {
-      isExtension: true
-      // Mark as extension for file organization
-    };
-  }
-  return schemas;
+  return transformFhirSchemaResource(register, fhirSchema, logger);
 }
 
-// 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 readPackageDependencies = async (manager, packageMeta2) => {
-  const packageJSON = await manager.packageJson(packageMeta2.name);
-  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: {}
-  };
-};
-var mkPackageAwareResolver = async (manager, pkg, deep, acc, logger) => {
-  const pkgId = packageMetaToFhir(pkg);
-  logger?.info(`${" ".repeat(deep * 2)}+ ${pkgId}`);
-  if (acc[pkgId]) return acc[pkgId];
-  const index = mkEmptyPkgIndex(pkg);
-  for (const resource of await manager.search({ package: pkg })) {
-    const rawUrl = resource.url;
-    if (!rawUrl) continue;
-    if (!(isStructureDefinition(resource) || isValueSet(resource) || isCodeSystem(resource))) continue;
-    const url = rawUrl;
-    if (index.canonicalResolution[url]) logger?.dry_warn(`Duplicate canonical URL: ${url} at ${pkgId}.`);
-    index.canonicalResolution[url] = [{ deep, pkg, pkgId, resource }];
-  }
-  const deps = await readPackageDependencies(manager, pkg);
-  for (const depPkg of deps) {
-    const { canonicalResolution } = await mkPackageAwareResolver(manager, depPkg, deep + 1, acc, logger);
-    for (const [surl, resolutions] of Object.entries(canonicalResolution)) {
-      const url = surl;
-      index.canonicalResolution[url] = [...index.canonicalResolution[url] || [], ...resolutions];
-    }
-  }
-  for (const resolutionOptions of Object.values(index.canonicalResolution)) {
-    resolutionOptions.sort((a, b) => a.deep - b.deep);
-  }
-  acc[pkgId] = index;
-  return index;
-};
-var enrichResolver = (resolver, logger) => {
-  for (const { pkg, canonicalResolution } of Object.values(resolver)) {
-    const pkgId = packageMetaToFhir(pkg);
-    if (!resolver[pkgId]) throw new Error(`Package ${pkgId} not found`);
-    for (const [_url, options] of Object.entries(canonicalResolution)) {
-      const resolition = options[0];
-      if (!resolition) throw new Error(`Resource not found`);
-      const resource = resolition.resource;
-      const resourcePkg = resolition.pkg;
-      if (isStructureDefinition(resource)) {
-        const fs7 = fhirschema.translate(resource);
-        const rfs = enrichFHIRSchema(fs7, resourcePkg);
-        resolver[pkgId].fhirSchemas[rfs.url] = rfs;
-      }
-      if (isValueSet(resource)) {
-        const rvs = enrichValueSet(resource, resourcePkg);
-        resolver[pkgId].valueSets[rvs.url] = rvs;
-      }
-    }
-  }
-};
-var packageAgnosticResolveCanonical = (resolver, url, _logger) => {
-  const options = Object.values(resolver).flatMap((pkg) => pkg.canonicalResolution[url]);
-  if (!options) throw new Error(`No canonical resolution found for ${url} in any package`);
-  return options[0]?.resource;
-};
-var registerFromManager = async (manager, { logger, fallbackPackageForNameResolution, focusedPackages }) => {
-  const packages = focusedPackages ?? await manager.packages();
-  const resolver = {};
-  for (const pkg of packages) {
-    await mkPackageAwareResolver(manager, pkg, 0, resolver, logger);
-  }
-  enrichResolver(resolver);
-  const resolveFs = (pkg, canonicalUrl) => {
-    return resolver[packageMetaToFhir(pkg)]?.fhirSchemas[canonicalUrl] || fallbackPackageForNameResolution && resolver[packageMetaToFhir(fallbackPackageForNameResolution)]?.fhirSchemas[canonicalUrl];
-  };
-  const resolveVs = (pkg, canonicalUrl) => {
-    return resolver[packageMetaToFhir(pkg)]?.valueSets[canonicalUrl] || fallbackPackageForNameResolution && resolver[packageMetaToFhir(fallbackPackageForNameResolution)]?.valueSets[canonicalUrl];
-  };
-  const ensureSpecializationCanonicalUrl = (name) => {
-    if (name.includes("|")) name = name.split("|")[0];
-    if (name.match(/^[a-zA-Z0-9]+$/)) {
-      return `http://hl7.org/fhir/StructureDefinition/${name}`;
-    }
-    return name;
-  };
-  const resolveFsGenealogy = (pkg, canonicalUrl) => {
-    let fs7 = resolveFs(pkg, canonicalUrl);
-    if (fs7 === void 0) throw new Error(`Failed to resolve FHIR Schema: '${canonicalUrl}'`);
-    const genealogy = [fs7];
-    while (fs7?.base) {
-      const pkg2 = fs7.package_meta;
-      const baseUrl = ensureSpecializationCanonicalUrl(fs7.base);
-      fs7 = resolveFs(pkg2, baseUrl);
-      if (fs7 === void 0)
-        throw new Error(
-          `Failed to resolve FHIR Schema base for '${canonicalUrl}'. Problem: '${baseUrl}' from '${packageMetaToFhir(pkg2)}'`
-        );
-      genealogy.push(fs7);
-    }
-    return genealogy;
-  };
-  const resolveFsSpecializations = (pkg, canonicalUrl) => {
-    return resolveFsGenealogy(pkg, canonicalUrl).filter((fs7) => fs7.derivation === "specialization");
-  };
-  const resolveElementSnapshot = (fhirSchema, path) => {
-    const geneology = resolveFsGenealogy(fhirSchema.package_meta, fhirSchema.url);
-    const elemGeneology = resolveFsElementGenealogy(geneology, path);
-    const elemSnapshot = fsElementSnapshot(elemGeneology);
-    return elemSnapshot;
-  };
-  const getAllElementKeys = (elems) => {
-    const keys = /* @__PURE__ */ new Set();
-    for (const [key, elem] of Object.entries(elems)) {
-      keys.add(key);
-      for (const choiceKey of elem?.choices || []) {
-        if (!elems[choiceKey]) {
-          keys.add(choiceKey);
-        }
-      }
-    }
-    return Array.from(keys);
-  };
-  let cachedResolutionTree;
-  return {
-    testAppendFs(fs7) {
-      const rfs = enrichFHIRSchema(fs7);
-      const pkgId = packageMetaToFhir(rfs.package_meta);
-      if (!resolver[pkgId]) resolver[pkgId] = mkEmptyPkgIndex(rfs.package_meta);
-      resolver[pkgId].fhirSchemas[rfs.url] = rfs;
-      cachedResolutionTree = void 0;
-    },
-    resolveFs,
-    resolveFsGenealogy,
-    resolveFsSpecializations,
-    ensureSpecializationCanonicalUrl,
-    resolveSd: (pkg, canonicalUrl) => {
-      const res = resolver[packageMetaToFhir(pkg)]?.canonicalResolution[canonicalUrl]?.[0]?.resource;
-      if (isStructureDefinition(res)) return res;
-      return void 0;
-    },
-    allSd: () => Object.values(resolver).flatMap(
-      (pkgIndex) => Object.values(pkgIndex.canonicalResolution).flatMap(
-        (resolutions) => resolutions.map((r) => {
-          const sd = r.resource;
-          if (!sd.package_name) {
-            return {
-              ...sd,
-              package_name: pkgIndex.pkg.name,
-              package_version: pkgIndex.pkg.version
-            };
-          }
-          return sd;
-        })
-      )
-    ).filter((r) => isStructureDefinition(r)).sort((sd1, sd2) => sd1.url.localeCompare(sd2.url)),
-    patchSd: (fn) => {
-      Object.values(resolver).flatMap(
-        (pkgIndex) => Object.values(pkgIndex.canonicalResolution).forEach((resolutions) => {
-          resolutions.forEach((e) => {
-            if (isStructureDefinition(e.resource)) {
-              const sd = e.resource;
-              const newSd = fn(pkgIndex.pkg, sd);
-              if (sd.url !== newSd.url)
-                throw new Error(`Patch update StructureDefinition URL: ${sd.url} !== ${newSd.url}`);
-              e.resource = newSd;
-            }
-          });
-        })
+// src/typeschema/index.ts
+var deduplicateSchemas = (schemasWithSources, logger) => {
+  const groups = {};
+  for (const item of schemasWithSources) {
+    const key = `${item.schema.identifier.url}|${item.schema.identifier.package}`;
+    const hash = hashSchema(item.schema);
+    groups[key] ??= {};
+    groups[key][hash] ??= { typeSchema: item.schema, sources: [] };
+    groups[key][hash].sources.push(item);
+  }
+  const schemas = [];
+  const collisions = {};
+  for (const versions of Object.values(groups)) {
+    const sorted = Object.values(versions).sort((a, b) => b.sources.length - a.sources.length);
+    const best = sorted[0];
+    if (!best) continue;
+    schemas.push(best.typeSchema);
+    if (sorted.length > 1) {
+      const pkg = best.typeSchema.identifier.package;
+      const url = best.typeSchema.identifier.url;
+      logger?.dryWarn(`'${url}' from '${pkg}'' has ${sorted.length} versions`);
+      collisions[pkg] ??= {};
+      collisions[pkg][url] = sorted.flatMap(
+        (v) => v.sources.map((s) => ({
+          typeSchema: v.typeSchema,
+          sourcePackage: s.sourcePackage,
+          sourceCanonical: s.sourceCanonical
+        }))
       );
-      enrichResolver(resolver);
-      cachedResolutionTree = void 0;
-    },
-    allFs: () => Object.values(resolver).flatMap((pkgIndex) => Object.values(pkgIndex.fhirSchemas)),
-    allVs: () => Object.values(resolver).flatMap((pkgIndex) => Object.values(pkgIndex.valueSets)),
-    resolveVs,
-    resolveAny: (canonicalUrl) => packageAgnosticResolveCanonical(resolver, canonicalUrl),
-    resolveElementSnapshot,
-    getAllElementKeys,
-    resolver,
-    resolutionTree: () => {
-      if (cachedResolutionTree) return cachedResolutionTree;
-      const res = {};
-      for (const [_pkgId, pkgIndex] of Object.entries(resolver)) {
-        const pkgName = pkgIndex.pkg.name;
-        res[pkgName] = {};
-        for (const [surl, resolutions] of Object.entries(pkgIndex.canonicalResolution)) {
-          const url = surl;
-          res[pkgName][url] = [];
-          for (const resolution of resolutions) {
-            res[pkgName][url].push({ deep: resolution.deep, pkg: resolution.pkg });
-          }
-        }
-      }
-      cachedResolutionTree = res;
-      return res;
     }
-  };
-};
-var resolveFsElementGenealogy = (genealogy, path) => {
-  const [top, ...rest] = path;
-  if (top === void 0) return [];
-  return genealogy.map((fs7) => {
-    if (!fs7.elements) return void 0;
-    let elem = fs7.elements?.[top];
-    for (const k of rest) {
-      elem = elem?.elements?.[k];
-    }
-    return elem;
-  }).filter((elem) => elem !== void 0);
+  }
+  return { schemas, collisions };
 };
-function fsElementSnapshot(genealogy) {
-  const revGenealogy = genealogy.reverse();
-  const snapshot = Object.assign({}, ...revGenealogy);
-  snapshot.elements = void 0;
-  return snapshot;
-}
-
-// src/typeschema/index.ts
 var generateTypeSchemas = async (register, logger) => {
-  const fhirSchemas = [];
+  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?.dry_warn(`Skip ${fhirSchema.url} from ${pkgId}. Reason: ${skipCheck.reason}`);
+      logger?.dryWarn(`Skip ${fhirSchema.url} from ${pkgId}. Reason: ${skipCheck.reason}`);
       continue;
     }
-    fhirSchemas.push(...await transformFhirSchema(register, fhirSchema, logger));
+    for (const schema of await transformFhirSchema(register, fhirSchema, logger)) {
+      schemasWithSources.push({
+        schema,
+        sourcePackage: pkgId,
+        sourceCanonical: fhirSchema.url
+      });
+    }
   }
   for (const vsSchema of register.allVs()) {
-    fhirSchemas.push(await transformValueSet(register, vsSchema));
+    schemasWithSources.push({
+      schema: await transformValueSet(register, vsSchema),
+      sourcePackage: packageMetaToFhir(vsSchema.package_meta),
+      sourceCanonical: vsSchema.url
+    });
   }
-  return fhirSchemas;
+  return deduplicateSchemas(schemasWithSources, logger);
 };
 
 // src/typeschema/ir/logic-promotion.ts
@@ -2829,38 +2638,316 @@ var treeShake = (tsIndex, treeShake2) => {
     for (const schema of schemas) {
       acc[JSON.stringify(schema.identifier)] = schema;
     }
-    const newSchemas = [];
-    for (const schema of schemas) {
-      if (isSpecializationTypeSchema(schema) || isProfileTypeSchema(schema)) {
-        if (!schema.dependencies) continue;
-        schema.dependencies.forEach((dep) => {
-          const depSchema = tsIndex.resolve(dep);
-          if (!depSchema)
-            throw new Error(
-              `Dependent schema ${JSON.stringify(dep)} not found for ${JSON.stringify(schema.identifier)}`
-            );
-          const id = JSON.stringify(depSchema.identifier);
-          if (!acc[id]) newSchemas.push(depSchema);
-        });
-        if (schema.nested) {
-          for (const nest of schema.nested) {
-            if (isNestedIdentifier(nest.identifier)) continue;
-            const id = JSON.stringify(nest.identifier);
-            if (!acc[id]) newSchemas.push(nest);
+    const newSchemas = [];
+    for (const schema of schemas) {
+      if (isSpecializationTypeSchema(schema) || isProfileTypeSchema(schema)) {
+        if (!schema.dependencies) continue;
+        schema.dependencies.forEach((dep) => {
+          const depSchema = tsIndex.resolve(dep);
+          if (!depSchema)
+            throw new Error(
+              `Dependent schema ${JSON.stringify(dep)} not found for ${JSON.stringify(schema.identifier)}`
+            );
+          const id = JSON.stringify(depSchema.identifier);
+          if (!acc[id]) newSchemas.push(depSchema);
+        });
+        if (schema.nested) {
+          for (const nest of schema.nested) {
+            if (isNestedIdentifier(nest.identifier)) continue;
+            const id = JSON.stringify(nest.identifier);
+            if (!acc[id]) newSchemas.push(nest);
+          }
+        }
+      }
+    }
+    return collectDeps(newSchemas, acc);
+  };
+  const shaked = collectDeps(focusedSchemas, {});
+  const shakedIndex = tsIndex.replaceSchemas(shaked);
+  const treeShakeReport = { skippedPackages: [], packages: {} };
+  const irReport = shakedIndex.irReport();
+  irReport.treeShake = treeShakeReport;
+  mutableFillReport(treeShakeReport, tsIndex, shakedIndex);
+  return shakedIndex;
+};
+
+// 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 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: {}
+  };
+};
+var mkPackageAwareResolver = async (manager, pkg, deep, acc, logger) => {
+  const pkgId = packageMetaToFhir(pkg);
+  logger?.info(`${" ".repeat(deep * 2)}+ ${pkgId}`);
+  if (acc[pkgId]) return acc[pkgId];
+  const index = mkEmptyPkgIndex(pkg);
+  for (const resource of await manager.search({ package: pkg })) {
+    const rawUrl = resource.url;
+    if (!rawUrl) continue;
+    if (!(isStructureDefinition(resource) || isValueSet(resource) || isCodeSystem(resource))) continue;
+    const url = rawUrl;
+    if (index.canonicalResolution[url]) logger?.dryWarn(`Duplicate canonical URL: ${url} at ${pkgId}.`);
+    index.canonicalResolution[url] = [{ deep, pkg, pkgId, resource }];
+  }
+  const deps = await readPackageDependencies(manager, pkg);
+  for (const depPkg of deps) {
+    const { canonicalResolution } = await mkPackageAwareResolver(manager, depPkg, deep + 1, acc, logger);
+    for (const [surl, resolutions] of Object.entries(canonicalResolution)) {
+      const url = surl;
+      index.canonicalResolution[url] = [...index.canonicalResolution[url] || [], ...resolutions];
+    }
+  }
+  for (const resolutionOptions of Object.values(index.canonicalResolution)) {
+    resolutionOptions.sort((a, b) => a.deep - b.deep);
+  }
+  acc[pkgId] = index;
+  return index;
+};
+var enrichResolver = (resolver, logger) => {
+  for (const { pkg, canonicalResolution } of Object.values(resolver)) {
+    const pkgId = packageMetaToFhir(pkg);
+    if (!resolver[pkgId]) throw new Error(`Package ${pkgId} not found`);
+    for (const [_url, options] of Object.entries(canonicalResolution)) {
+      const resolition = options[0];
+      if (!resolition) throw new Error(`Resource not found`);
+      const resource = resolition.resource;
+      const resourcePkg = resolition.pkg;
+      if (isStructureDefinition(resource)) {
+        const fs7 = fhirschema.translate(resource);
+        const rfs = enrichFHIRSchema(fs7, resourcePkg);
+        resolver[pkgId].fhirSchemas[rfs.url] = rfs;
+      }
+      if (isValueSet(resource)) {
+        const rvs = enrichValueSet(resource, resourcePkg);
+        resolver[pkgId].valueSets[rvs.url] = rvs;
+      }
+    }
+  }
+};
+var packageAgnosticResolveCanonical = (resolver, url, _logger) => {
+  const options = Object.values(resolver).flatMap((pkg) => pkg.canonicalResolution[url]);
+  if (!options) throw new Error(`No canonical resolution found for ${url} in any package`);
+  return options[0]?.resource;
+};
+var registerFromManager = async (manager, { logger, focusedPackages }) => {
+  const packages = focusedPackages ?? await manager.packages();
+  const resolver = {};
+  for (const pkg of packages) {
+    await mkPackageAwareResolver(manager, pkg, 0, resolver, logger);
+  }
+  enrichResolver(resolver);
+  const resolveFs = (pkg, canonicalUrl) => {
+    const pkgIndex = resolver[packageMetaToFhir(pkg)];
+    if (pkgIndex) {
+      const resolution = pkgIndex.canonicalResolution[canonicalUrl]?.[0];
+      if (resolution) {
+        return resolver[resolution.pkgId]?.fhirSchemas[canonicalUrl];
+      }
+    }
+    for (const idx of Object.values(resolver)) {
+      const fs7 = idx.fhirSchemas[canonicalUrl];
+      if (fs7 && fs7.package_meta.name === pkg.name) return fs7;
+    }
+    for (const idx of Object.values(resolver)) {
+      const fs7 = idx.fhirSchemas[canonicalUrl];
+      if (fs7) return fs7;
+    }
+    return void 0;
+  };
+  const resolveVs = (pkg, canonicalUrl) => {
+    const pkgIndex = resolver[packageMetaToFhir(pkg)];
+    if (pkgIndex) {
+      const resolution = pkgIndex.canonicalResolution[canonicalUrl]?.[0];
+      if (resolution) {
+        return resolver[resolution.pkgId]?.valueSets[canonicalUrl];
+      }
+    }
+    for (const idx of Object.values(resolver)) {
+      const vs = idx.valueSets[canonicalUrl];
+      if (vs && vs.package_meta.name === pkg.name) return vs;
+    }
+    for (const idx of Object.values(resolver)) {
+      const vs = idx.valueSets[canonicalUrl];
+      if (vs) return vs;
+    }
+    return void 0;
+  };
+  const ensureSpecializationCanonicalUrl = (name) => {
+    if (name.includes("|")) name = name.split("|")[0];
+    if (name.match(/^[a-zA-Z0-9]+$/)) {
+      return `http://hl7.org/fhir/StructureDefinition/${name}`;
+    }
+    return name;
+  };
+  const resolveFsGenealogy = (pkg, canonicalUrl) => {
+    let fs7 = resolveFs(pkg, canonicalUrl);
+    if (fs7 === void 0) throw new Error(`Failed to resolve FHIR Schema: '${canonicalUrl}'`);
+    const genealogy = [fs7];
+    while (fs7?.base) {
+      const pkg2 = fs7.package_meta;
+      const baseUrl = ensureSpecializationCanonicalUrl(fs7.base);
+      fs7 = resolveFs(pkg2, baseUrl);
+      if (fs7 === void 0)
+        throw new Error(
+          `Failed to resolve FHIR Schema base for '${canonicalUrl}'. Problem: '${baseUrl}' from '${packageMetaToFhir(pkg2)}'`
+        );
+      genealogy.push(fs7);
+    }
+    return genealogy;
+  };
+  const resolveFsSpecializations = (pkg, canonicalUrl) => {
+    return resolveFsGenealogy(pkg, canonicalUrl).filter((fs7) => fs7.derivation === "specialization");
+  };
+  const resolveElementSnapshot = (fhirSchema, path) => {
+    const geneology = resolveFsGenealogy(fhirSchema.package_meta, fhirSchema.url);
+    const elemGeneology = resolveFsElementGenealogy(geneology, path);
+    const elemSnapshot = fsElementSnapshot(elemGeneology);
+    return elemSnapshot;
+  };
+  const getAllElementKeys = (elems) => {
+    const keys = /* @__PURE__ */ new Set();
+    for (const [key, elem] of Object.entries(elems)) {
+      keys.add(key);
+      for (const choiceKey of elem?.choices || []) {
+        if (!elems[choiceKey]) {
+          keys.add(choiceKey);
+        }
+      }
+    }
+    return Array.from(keys);
+  };
+  let cachedResolutionTree;
+  return {
+    testAppendFs(rfs) {
+      const pkgId = packageMetaToFhir(rfs.package_meta);
+      if (!resolver[pkgId]) resolver[pkgId] = mkEmptyPkgIndex(rfs.package_meta);
+      resolver[pkgId].fhirSchemas[rfs.url] = rfs;
+      cachedResolutionTree = void 0;
+    },
+    resolveFs,
+    resolveFsGenealogy,
+    resolveFsSpecializations,
+    ensureSpecializationCanonicalUrl,
+    resolveSd: (pkg, canonicalUrl) => {
+      const res = resolver[packageMetaToFhir(pkg)]?.canonicalResolution[canonicalUrl]?.[0]?.resource;
+      if (isStructureDefinition(res)) return res;
+      return void 0;
+    },
+    allSd: () => Object.values(resolver).flatMap(
+      (pkgIndex) => Object.values(pkgIndex.canonicalResolution).flatMap(
+        (resolutions) => resolutions.map((r) => {
+          const sd = r.resource;
+          if (!sd.package_name) {
+            return {
+              ...sd,
+              package_name: pkgIndex.pkg.name,
+              package_version: pkgIndex.pkg.version
+            };
+          }
+          return sd;
+        })
+      )
+    ).filter((r) => isStructureDefinition(r)).sort((sd1, sd2) => sd1.url.localeCompare(sd2.url)),
+    patchSd: (fn) => {
+      Object.values(resolver).flatMap(
+        (pkgIndex) => Object.values(pkgIndex.canonicalResolution).forEach((resolutions) => {
+          resolutions.forEach((e) => {
+            if (isStructureDefinition(e.resource)) {
+              const sd = e.resource;
+              const newSd = fn(pkgIndex.pkg, sd);
+              if (sd.url !== newSd.url)
+                throw new Error(`Patch update StructureDefinition URL: ${sd.url} !== ${newSd.url}`);
+              e.resource = newSd;
+            }
+          });
+        })
+      );
+      enrichResolver(resolver);
+      cachedResolutionTree = void 0;
+    },
+    allFs: () => Object.values(resolver).flatMap((pkgIndex) => Object.values(pkgIndex.fhirSchemas)),
+    allVs: () => Object.values(resolver).flatMap((pkgIndex) => Object.values(pkgIndex.valueSets)),
+    resolveVs,
+    resolveAny: (canonicalUrl) => packageAgnosticResolveCanonical(resolver, canonicalUrl),
+    resolveElementSnapshot,
+    getAllElementKeys,
+    resolver,
+    resolutionTree: () => {
+      if (cachedResolutionTree) return cachedResolutionTree;
+      const res = {};
+      for (const [_pkgId, pkgIndex] of Object.entries(resolver)) {
+        const pkgName = pkgIndex.pkg.name;
+        res[pkgName] = {};
+        for (const [surl, resolutions] of Object.entries(pkgIndex.canonicalResolution)) {
+          const url = surl;
+          res[pkgName][url] = [];
+          for (const resolution of resolutions) {
+            res[pkgName][url].push({ deep: resolution.deep, pkg: resolution.pkg });
           }
         }
       }
+      cachedResolutionTree = res;
+      return res;
     }
-    return collectDeps(newSchemas, acc);
   };
-  const shaked = collectDeps(focusedSchemas, {});
-  const shakedIndex = tsIndex.replaceSchemas(shaked);
-  const treeShakeReport = { skippedPackages: [], packages: {} };
-  const irReport = shakedIndex.irReport();
-  irReport.treeShake = treeShakeReport;
-  mutableFillReport(treeShakeReport, tsIndex, shakedIndex);
-  return shakedIndex;
 };
+var registerFromPackageMetas = async (packageMetas, conf) => {
+  const packageNames = packageMetas.map(packageMetaToNpm);
+  conf?.logger?.step(`Loading FHIR packages: ${packageNames.join(", ")}`);
+  const manager = CanonicalManager({
+    packages: packageNames,
+    workingDir: "tmp/fhir",
+    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((fs7) => {
+    if (!fs7.elements) return void 0;
+    let elem = fs7.elements?.[top];
+    for (const k of rest) {
+      elem = elem?.elements?.[k];
+    }
+    return elem;
+  }).filter((elem) => elem !== void 0);
+};
+function fsElementSnapshot(genealogy) {
+  const revGenealogy = genealogy.reverse();
+  const snapshot = Object.assign({}, ...revGenealogy);
+  snapshot.elements = void 0;
+  return snapshot;
+}
 var normalizeFileName = (str) => {
   const res = str.replace(/[^a-zA-Z0-9\-_.@#()]/g, "");
   if (res.length === 0) return "unknown";
@@ -2902,23 +2989,60 @@ var IntrospectionWriter = class extends FileSystemWriter {
       this.logger()?.info(`IntrospectionWriter: Type tree written to ${this.opts.typeTree}`);
     }
     if (this.opts.typeSchemas) {
-      const outputPath = this.opts.typeSchemas;
-      const typeSchemas = tsIndex.schemas;
-      if (Path5.extname(outputPath) === ".ndjson") {
-        this.writeNdjson(typeSchemas, outputPath, typeSchemaToJson);
+      if (Path5.extname(this.opts.typeSchemas) === ".ndjson") {
+        this.writeNdjson(tsIndex.schemas, this.opts.typeSchemas, typeSchemaToJson);
       } else {
-        this.writeJsonFiles(
-          typeSchemas.map((ts) => typeSchemaToJson(ts, true)),
-          outputPath
-        );
+        const items = tsIndex.schemas.map((ts) => typeSchemaToJson(ts, true));
+        const seenFilenames = /* @__PURE__ */ new Set();
+        const dedupedItems = items.filter((item) => {
+          if (seenFilenames.has(item.filename)) return false;
+          seenFilenames.add(item.filename);
+          return true;
+        });
+        this.cd(this.opts.typeSchemas, () => {
+          for (const { filename, genContent } of dedupedItems) {
+            const fileName = `${filename}.json`;
+            this.cd(Path5.dirname(fileName), () => {
+              this.cat(Path5.basename(fileName), () => {
+                this.write(genContent());
+              });
+            });
+          }
+          for (const [pkg, canonicals] of Object.entries(tsIndex.irReport().collisions ?? {})) {
+            this.cd(`${normalizeFileName(pkg)}`, () => {
+              for (const [canonical, entries] of Object.entries(canonicals)) {
+                if (entries.length <= 1) continue;
+                const firstEntry = entries[0];
+                assert3(firstEntry);
+                const name = normalizeFileName(
+                  `${firstEntry.typeSchema.identifier.name}(${extractNameFromCanonical(canonical)})`
+                );
+                this.cd(Path5.join("collisions", name), () => {
+                  for (let i = 0; i < entries.length; i++) {
+                    const entry = entries[i];
+                    this.cat(`${i + 1}.json`, () => {
+                      this.write(JSON.stringify(entry, null, 2));
+                    });
+                  }
+                });
+              }
+            });
+          }
+        });
       }
       this.logger()?.info(
-        `IntrospectionWriter: ${typeSchemas.length} TypeSchema written to ${this.opts.typeSchemas}`
+        `IntrospectionWriter: ${tsIndex.schemas.length} TypeSchema written to ${this.opts.typeSchemas}`
       );
     }
     if (this.opts.fhirSchemas && tsIndex.register) {
       const outputPath = this.opts.fhirSchemas;
-      const fhirSchemas = tsIndex.register.allFs();
+      const allFs = tsIndex.register.allFs();
+      const seenUrls = /* @__PURE__ */ new Set();
+      const fhirSchemas = allFs.filter((fs7) => {
+        if (seenUrls.has(fs7.url)) return false;
+        seenUrls.add(fs7.url);
+        return true;
+      });
       if (Path5.extname(outputPath) === ".ndjson") {
         this.writeNdjson(fhirSchemas, outputPath, fhirSchemaToJson);
       } else {
@@ -2931,7 +3055,13 @@ var IntrospectionWriter = class extends FileSystemWriter {
     }
     if (this.opts.structureDefinitions && tsIndex.register) {
       const outputPath = this.opts.structureDefinitions;
-      const structureDefinitions = tsIndex.register.allSd();
+      const allSd = tsIndex.register.allSd();
+      const seenUrls = /* @__PURE__ */ new Set();
+      const structureDefinitions = allSd.filter((sd) => {
+        if (seenUrls.has(sd.url)) return false;
+        seenUrls.add(sd.url);
+        return true;
+      });
       if (Path5.extname(outputPath) === ".ndjson") {
         this.writeNdjson(structureDefinitions, outputPath, structureDefinitionToJson);
       } else {
@@ -2984,58 +3114,118 @@ var IntrospectionWriter = class extends FileSystemWriter {
 };
 
 // src/typeschema/ir/report.ts
-var generateIrReportReadme = (report) => {
-  const lines = ["# IR Report", ""];
-  const allPackages = /* @__PURE__ */ new Set([
-    ...Object.keys(report.treeShake?.packages ?? {}),
-    ...Object.keys(report.logicalPromotion?.packages ?? {})
-  ]);
-  if (allPackages.size === 0) {
-    lines.push("No IR modifications applied.");
-    return lines.join("\n");
+var generateSkippedPackagesSection = (lines, skippedPackages) => {
+  lines.push("## Skipped Packages", "");
+  for (const pkg of skippedPackages) {
+    lines.push(`- ${pkg}`);
   }
-  if (report.treeShake?.skippedPackages.length) {
-    lines.push("## Skipped Packages", "");
-    for (const pkg of report.treeShake.skippedPackages) {
-      lines.push(`- ${pkg}`);
+  lines.push("");
+};
+var generatePackageSection = (lines, pkgName, treeShakePkg, promotedCanonicals) => {
+  lines.push(`## Package: \`${pkgName}\``, "");
+  if (promotedCanonicals?.length) {
+    lines.push("### Promoted Logical Models", "");
+    for (const canonical of promotedCanonicals) {
+      lines.push(`- \`${canonical}\``);
     }
     lines.push("");
   }
-  for (const pkgName of [...allPackages].sort()) {
-    lines.push(`## Package: \`${pkgName}\``, "");
-    const treeShakePkg = report.treeShake?.packages[pkgName];
-    const logicalPromotionPkg = report.logicalPromotion?.packages[pkgName];
-    if (logicalPromotionPkg?.promotedCanonicals.length) {
-      lines.push("### Promoted Logical Models", "");
-      for (const canonical of logicalPromotionPkg.promotedCanonicals) {
-        lines.push(`- \`${canonical}\``);
+  if (!treeShakePkg) return;
+  const canonicalsWithChanges = Object.entries(treeShakePkg.canonicals).filter(
+    ([_, data]) => data.skippedFields.length > 0
+  );
+  if (canonicalsWithChanges.length > 0) {
+    lines.push("### Modified Canonicals", "");
+    for (const [canonical, data] of canonicalsWithChanges) {
+      lines.push(`#### \`${canonical}\``, "");
+      lines.push("Skipped fields:", "");
+      for (const field of data.skippedFields) {
+        lines.push(`- \`${field}\``);
       }
       lines.push("");
     }
-    if (treeShakePkg) {
-      const canonicalsWithChanges = Object.entries(treeShakePkg.canonicals).filter(
-        ([_, data]) => data.skippedFields.length > 0
-      );
-      if (canonicalsWithChanges.length > 0) {
-        lines.push("### Modified Canonicals", "");
-        for (const [canonical, data] of canonicalsWithChanges) {
-          lines.push(`#### \`${canonical}\``, "");
-          lines.push("Skipped fields:", "");
-          for (const field of data.skippedFields) {
-            lines.push(`- \`${field}\``);
-          }
-          lines.push("");
-        }
-      }
-      if (treeShakePkg.skippedCanonicals.length > 0) {
-        lines.push("### Skipped Canonicals", "");
-        for (const canonical of treeShakePkg.skippedCanonicals) {
-          lines.push(`- \`${canonical}\``);
-        }
-        lines.push("");
+  }
+  if (treeShakePkg.skippedCanonicals.length > 0) {
+    lines.push("### Skipped Canonicals", "");
+    for (const canonical of treeShakePkg.skippedCanonicals) {
+      lines.push(`- \`${canonical}\``);
+    }
+    lines.push("");
+  }
+};
+var generateCollisionVersionLines = (entries) => {
+  const uniqueSchemas = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const key = JSON.stringify(entry.typeSchema);
+    if (!uniqueSchemas.has(key)) uniqueSchemas.set(key, []);
+    uniqueSchemas.get(key)?.push(entry);
+  }
+  const versionLines = [];
+  const sortedVersions = [...uniqueSchemas.values()].sort((a, b) => b.length - a.length);
+  let version = 1;
+  for (const schemaEntries of sortedVersions) {
+    const sourceList = schemaEntries.map((e) => {
+      const name = extractNameFromCanonical(e.sourceCanonical) ?? e.sourceCanonical;
+      return `${name} (${e.sourcePackage})`;
+    }).join(", ");
+    versionLines.push(`  - Version ${version++}: ${sourceList}`);
+  }
+  return versionLines;
+};
+var generateCollisionsSection = (lines, collisions) => {
+  if (!collisions) return;
+  lines.push("## Schema Collisions", "");
+  lines.push("The following canonicals have multiple schema versions with different content.");
+  lines.push("To inspect collision versions, export TypeSchemas using `.introspection({ typeSchemas: 'path' })`");
+  lines.push("and check `<pkg>/collisions/<name>/1.json, 2.json, ...` files.", "");
+  const collisionPackages = Object.keys(collisions).sort();
+  for (const pkgName of collisionPackages) {
+    const collisionsPkg = collisions[pkgName];
+    if (!collisionsPkg) throw new Error(`Missing collisions for package ${pkgName}`);
+    const sortedEntries = Object.entries(collisionsPkg).sort(([a], [b]) => {
+      const nameA = a.split("/").pop() ?? a;
+      const nameB = b.split("/").pop() ?? b;
+      return nameA.localeCompare(nameB);
+    });
+    if (sortedEntries.length > 0) {
+      lines.push(`### \`${pkgName}\``, "");
+      for (const [canonical, entries] of sortedEntries) {
+        const versionLines = generateCollisionVersionLines(entries);
+        lines.push(`- \`${canonical}\` (${versionLines.length} versions)`);
+        lines.push(...versionLines);
       }
+      lines.push("");
     }
   }
+};
+var generateIrReportReadme = (report) => {
+  const lines = ["# IR Report", ""];
+  const irPackages = [
+    .../* @__PURE__ */ new Set([
+      ...Object.keys(report.treeShake?.packages ?? {}),
+      ...Object.keys(report.logicalPromotion?.packages ?? {})
+    ])
+  ].sort();
+  const hasIrChanges = irPackages.length > 0 || (report.treeShake?.skippedPackages.length ?? 0) > 0;
+  const hasCollisions = Object.keys(report.collisions ?? {}).length > 0;
+  if (!hasIrChanges && !hasCollisions) {
+    lines.push("No IR modifications applied.");
+    return lines.join("\n");
+  }
+  if (report.treeShake?.skippedPackages.length) {
+    generateSkippedPackagesSection(lines, report.treeShake.skippedPackages);
+  }
+  for (const pkgName of irPackages) {
+    generatePackageSection(
+      lines,
+      pkgName,
+      report.treeShake?.packages[pkgName],
+      report.logicalPromotion?.packages[pkgName]?.promotedCanonicals
+    );
+  }
+  if (hasCollisions) {
+    generateCollisionsSection(lines, report.collisions);
+  }
   return lines.join("\n");
 };
 
@@ -3407,25 +3597,27 @@ var ViewModelFactory = class {
       hasFields: fields.length > 0,
       hasNestedComplexTypes: nestedComplexTypes.length > 0,
       hasNestedEnums: nestedEnums.length > 0,
-      fields: fields.filter(([_fieldName, fieldSchema]) => !!fieldSchema.type).sort((a, b) => a[0].localeCompare(b[0])).map(([fieldName, fieldSchema]) => {
+      fields: fields.filter(
+        (entry) => isNotChoiceDeclarationField(entry[1])
+      ).sort((a, b) => a[0].localeCompare(b[0])).map(([fieldName, field]) => {
         return {
           owner: name,
-          schema: fieldSchema,
+          schema: field,
           name: fieldName,
           saveName: this.nameGenerator.generateField(fieldName),
-          typeName: this.nameGenerator.generateFieldType(fieldSchema),
-          isArray: fieldSchema.array,
-          isRequired: fieldSchema.required,
-          isEnum: !!fieldSchema.enum,
-          isSizeConstrained: fieldSchema.min !== void 0 || fieldSchema.max !== void 0,
-          min: fieldSchema.min,
-          max: fieldSchema.max,
-          isResource: this._createIsResource(fieldSchema.type),
-          isComplexType: this._createIsComplexType(fieldSchema.type),
-          isPrimitive: this._createIsPrimitiveType(fieldSchema.type),
-          isCode: fieldSchema.type?.name === "code",
-          isIdentifier: fieldSchema.type?.name === "Identifier",
-          isReference: fieldSchema.type?.name === "Reference"
+          typeName: this.nameGenerator.generateFieldType(field),
+          isArray: field.array ?? false,
+          isRequired: field.required ?? false,
+          isEnum: !!field.enum && !field.enum.isOpen,
+          isSizeConstrained: field.min !== void 0 || field.max !== void 0,
+          min: field.min,
+          max: field.max,
+          isResource: this._createIsResource(field.type),
+          isComplexType: this._createIsComplexType(field.type),
+          isPrimitive: this._createIsPrimitiveType(field.type),
+          isCode: field.type?.name === "code",
+          isIdentifier: field.type?.name === "Identifier",
+          isReference: field.type?.name === "Reference"
         };
       })
     };
@@ -3501,11 +3693,11 @@ var ViewModelFactory = class {
   _collectNestedEnums(fields) {
     const nestedEnumValues = {};
     fields.forEach(([fieldName, fieldSchema]) => {
-      if ("enum" in fieldSchema && fieldSchema.enum) {
+      if ("enum" in fieldSchema && fieldSchema.enum && !fieldSchema.enum.isOpen) {
         const name = ("binding" in fieldSchema && fieldSchema.binding?.name) ?? fieldName;
         if (typeof name === "string") {
           nestedEnumValues[name] = nestedEnumValues[name] ?? /* @__PURE__ */ new Set();
-          fieldSchema.enum?.forEach(nestedEnumValues[name].add.bind(nestedEnumValues[name]));
+          fieldSchema.enum.values.forEach(nestedEnumValues[name].add.bind(nestedEnumValues[name]));
         }
       }
     });
@@ -3734,13 +3926,22 @@ var tsFhirPackageDir = (name) => {
 var tsModuleName = (id) => {
   return uppercaseFirstLetter(normalizeTsName(id.name));
 };
+var tsProfileModuleName = (tsIndex, schema) => {
+  const resourceSchema = tsIndex.findLastSpecialization(schema);
+  const resourceName = uppercaseFirstLetter(normalizeTsName(resourceSchema.identifier.name));
+  const profileName = extractNameFromCanonical(schema.identifier.url);
+  if (profileName) {
+    return `${resourceName}_${normalizeTsName(profileName)}`;
+  }
+  return `${resourceName}_${normalizeTsName(schema.identifier.name)}`;
+};
 var tsModuleFileName = (id) => {
   return `${tsModuleName(id)}.ts`;
 };
+var tsProfileModuleFileName = (tsIndex, schema) => {
+  return `${tsProfileModuleName(tsIndex, schema)}.ts`;
+};
 var tsModulePath = (id) => {
-  if (isProfileIdentifier(id)) {
-    return `${tsFhirPackageDir(id.package)}/profiles/${tsModuleName(id)}`;
-  }
   return `${tsFhirPackageDir(id.package)}/${tsModuleName(id)}`;
 };
 var canonicalToName3 = (canonical, dropFragment = true) => {
@@ -3752,9 +3953,9 @@ var canonicalToName3 = (canonical, dropFragment = true) => {
 var tsResourceName = (id) => {
   if (id.kind === "nested") {
     const url = id.url;
-    const path = canonicalToName3(url, false);
-    if (!path) return "";
-    const [resourceName, fragment] = path.split("#");
+    const localName = extractNameFromCanonical(url, false);
+    if (!localName) return "";
+    const [resourceName, fragment] = localName.split("#");
     const name = uppercaseFirstLetterOfEach((fragment ?? "").split(".")).join("");
     return normalizeTsName([resourceName, name].join(""));
   }
@@ -3768,14 +3969,37 @@ var tsFieldName = (n) => {
 };
 var normalizeTsName = (n) => {
   if (tsKeywords.has(n)) n = `${n}_`;
-  return n.replace(/\[x\]/g, "_x_").replace(/[- :]/g, "_");
+  return n.replace(/\[x\]/g, "_x_").replace(/[- :.]/g, "_");
 };
 var tsGet = (object, tsFieldName2) => {
   if (tsFieldName2.startsWith('"')) return `${object}[${tsFieldName2}]`;
   return `${object}.${tsFieldName2}`;
 };
-var tsEnumType = (enumValues) => {
-  return `(${enumValues.map((e) => `"${e}"`).join(" | ")})`;
+var tsEnumType = (enumDef) => {
+  const values = enumDef.values.map((e) => `"${e}"`).join(" | ");
+  return enumDef.isOpen ? `(${values} | string)` : `(${values})`;
+};
+var rewriteFieldTypeDefs = {
+  Coding: { code: () => "T" },
+  // biome-ignore lint: that is exactly string what we want
+  Reference: { reference: () => "`${T}/${string}`" },
+  CodeableConcept: { coding: () => "Coding<T>" }
+};
+var resolveFieldTsType = (schemaName, tsName, field) => {
+  const rewriteFieldType = rewriteFieldTypeDefs[schemaName]?.[tsName];
+  if (rewriteFieldType) return rewriteFieldType();
+  if (field.enum) {
+    if (field.type.name === "Coding") return `Coding<${tsEnumType(field.enum)}>`;
+    if (field.type.name === "CodeableConcept") return `CodeableConcept<${tsEnumType(field.enum)}>`;
+    return tsEnumType(field.enum);
+  }
+  if (field.reference && field.reference.length > 0) {
+    const references = field.reference.map((ref) => `"${ref.name}"`).join(" | ");
+    return `Reference<${references}>`;
+  }
+  if (isPrimitiveIdentifier(field.type)) return resolvePrimitiveType(field.type.name);
+  if (isNestedIdentifier(field.type)) return tsResourceName(field.type);
+  return field.type.name;
 };
 var tsTypeFromIdentifier = (id) => {
   if (isNestedIdentifier(id)) return tsResourceName(id);
@@ -3784,8 +4008,12 @@ var tsTypeFromIdentifier = (id) => {
   if (primitiveType !== void 0) return primitiveType;
   return id.name;
 };
-var tsProfileClassName = (id) => {
-  return `${uppercaseFirstLetter(normalizeTsName(id.name))}Profile`;
+var tsProfileClassName = (schema) => {
+  const profileName = extractNameFromCanonical(schema.identifier.url);
+  if (profileName) {
+    return `${normalizeTsName(profileName)}Profile`;
+  }
+  return `${normalizeTsName(schema.identifier.name)}Profile`;
 };
 var tsSliceInputTypeName = (profileName, fieldName, sliceName) => {
   return `${uppercaseFirstLetter(profileName)}_${uppercaseFirstLetter(normalizeTsName(fieldName))}_${uppercaseFirstLetter(normalizeTsName(sliceName))}SliceInput`;
@@ -3821,21 +4049,33 @@ var TypeScript = class extends Writer {
   tsImportType(tsPackageName, ...entities) {
     this.lineSM(`import type { ${entities.join(", ")} } from "${tsPackageName}"`);
   }
-  generateProfileIndexFile(profiles) {
-    if (profiles.length === 0) return;
+  generateProfileIndexFile(tsIndex, initialProfiles) {
+    if (initialProfiles.length === 0) return;
     this.cd("profiles", () => {
       this.cat("index.ts", () => {
-        const seen = /* @__PURE__ */ new Set();
-        const uniqueProfiles = profiles.filter((profile) => {
-          const className = tsProfileClassName(profile.identifier);
-          if (seen.has(className)) return false;
-          seen.add(className);
-          return true;
+        const profiles = initialProfiles.map((profile) => {
+          const className = tsProfileClassName(profile);
+          const resourceName = tsResourceName(profile.identifier);
+          const overrides = this.detectFieldOverrides(tsIndex, profile);
+          let typeExport;
+          if (overrides.size > 0) typeExport = resourceName;
+          return [profile, className, typeExport];
         });
-        if (uniqueProfiles.length === 0) return;
-        for (const profile of uniqueProfiles) {
-          const className = tsProfileClassName(profile.identifier);
-          this.lineSM(`export { ${className} } from "./${tsModuleName(profile.identifier)}"`);
+        if (profiles.length === 0) return;
+        const classExports = /* @__PURE__ */ new Map();
+        const typeExports = /* @__PURE__ */ new Map();
+        for (const [profile, className, typeName] of profiles) {
+          const moduleName = tsProfileModuleName(tsIndex, profile);
+          if (!classExports.has(className)) {
+            classExports.set(className, `export { ${className} } from "./${moduleName}"`);
+          }
+          if (typeName && !typeExports.has(typeName)) {
+            typeExports.set(typeName, `export type { ${typeName} } from "./${moduleName}"`);
+          }
+        }
+        const allExports = [...classExports.values(), ...typeExports.values()].sort();
+        for (const exp of allExports) {
+          this.lineSM(exp);
         }
       });
     });
@@ -3929,14 +4169,16 @@ var TypeScript = class extends Writer {
       this.line();
     }
   }
-  addFieldExtension(fieldName) {
+  addFieldExtension(fieldName, isArray) {
     const extFieldName = tsFieldName(`_${fieldName}`);
-    this.lineSM(`${extFieldName}?: Element`);
+    const typeExpr = isArray ? "(Element | null)[]" : "Element";
+    this.lineSM(`${extFieldName}?: ${typeExpr}`);
   }
   generateType(tsIndex, schema) {
     let name;
-    if (schema.identifier.name === "Reference") {
-      name = "Reference<T extends string = string>";
+    const genericTypes = ["Reference", "Coding", "CodeableConcept"];
+    if (genericTypes.includes(schema.identifier.name)) {
+      name = `${schema.identifier.name}<T extends string = string>`;
     } else if (schema.identifier.kind === "nested") {
       name = tsResourceName(schema.identifier);
     } else {
@@ -3963,29 +4205,16 @@ var TypeScript = class extends Writer {
       const fields = Object.entries(schema.fields).sort((a, b) => a[0].localeCompare(b[0]));
       for (const [fieldName, field] of fields) {
         if (isChoiceDeclarationField(field)) continue;
+        if (!field.type) continue;
         this.debugComment(fieldName, ":", field);
         const tsName = tsFieldName(fieldName);
-        let tsType;
-        if (field.enum) {
-          tsType = tsEnumType(field.enum);
-        } else if (schema.identifier.name === "Reference" && tsName === "reference") {
-          tsType = "`${T}/${string}`";
-        } else if (field.reference && field.reference.length > 0) {
-          const references = field.reference.map((ref) => `"${ref.name}"`).join(" | ");
-          tsType = `Reference<${references}>`;
-        } else if (isPrimitiveIdentifier(field.type)) {
-          tsType = resolvePrimitiveType(field.type.name);
-        } else if (isNestedIdentifier(field.type)) {
-          tsType = tsResourceName(field.type);
-        } else {
-          tsType = field.type.name;
-        }
+        const tsType = resolveFieldTsType(schema.identifier.name, tsName, field);
         const optionalSymbol = field.required ? "" : "?";
         const arraySymbol = field.array ? "[]" : "";
         this.lineSM(`${tsName}${optionalSymbol}: ${tsType}${arraySymbol}`);
         if (this.withPrimitiveTypeExtension(schema)) {
           if (isPrimitiveIdentifier(field.type)) {
-            this.addFieldExtension(fieldName);
+            this.addFieldExtension(fieldName, field.array ?? false);
           }
         }
       }
@@ -4021,10 +4250,16 @@ var TypeScript = class extends Writer {
     if (!isNotChoiceDeclarationField(field)) {
       throw new Error(`Choice declaration fields not supported for '${fieldName}'`);
     }
+    let tsType;
     if (field.enum) {
-      return tsEnumType(field.enum);
-    }
-    if (field.reference && field.reference.length > 0) {
+      if (field.type?.name === "Coding") {
+        tsType = `Coding<${tsEnumType(field.enum)}>`;
+      } else if (field.type?.name === "CodeableConcept") {
+        tsType = `CodeableConcept<${tsEnumType(field.enum)}>`;
+      } else {
+        tsType = tsEnumType(field.enum);
+      }
+    } else if (field.reference && field.reference.length > 0) {
       const specialization = tsIndex.findLastSpecialization(flatProfile);
       if (!isSpecializationTypeSchema(specialization))
         throw new Error(`Invalid specialization for ${flatProfile.identifier}`);
@@ -4041,20 +4276,20 @@ var TypeScript = class extends Writer {
       }).join(" | ");
       if (sRefs.length === 1 && sRefs[0] === "Resource" && references !== '"Resource"') {
         const cleanRefs = references.replace(/\/\*[^*]*\*\//g, "").trim();
-        return `Reference<"Resource" /* ${cleanRefs} */ >`;
+        tsType = `Reference<"Resource" /* ${cleanRefs} */ >`;
+      } else {
+        tsType = `Reference<${references}>`;
       }
-      return `Reference<${references}>`;
-    }
-    if (isNestedIdentifier(field.type)) {
-      return tsResourceName(field.type);
-    }
-    if (isPrimitiveIdentifier(field.type)) {
-      return resolvePrimitiveType(field.type.name);
-    }
-    if (field.type === void 0) {
+    } else if (isPrimitiveIdentifier(field.type)) {
+      tsType = resolvePrimitiveType(field.type.name);
+    } else if (isNestedIdentifier(field.type)) {
+      tsType = tsResourceName(field.type);
+    } else if (field.type === void 0) {
       throw new Error(`Undefined type for '${fieldName}' field at ${typeSchemaInfo(flatProfile)}`);
+    } else {
+      tsType = field.type.name;
     }
-    return field.type.name;
+    return tsType;
   }
   generateProfileType(tsIndex, flatProfile) {
     this.debugComment("flatProfile", flatProfile);
@@ -4358,104 +4593,95 @@ var TypeScript = class extends Writer {
       this.lineSM(`import { ${imports.join(", ")} } from "../../profile-helpers"`);
     }
   }
-  generateProfileImports(tsIndex, flatProfile) {
-    const usedTypes = /* @__PURE__ */ new Map();
-    const getModulePath = (typeId) => {
-      if (isNestedIdentifier(typeId)) {
-        const url = typeId.url;
-        const path = canonicalToName3(url, true);
-        if (path) {
-          return `../../${tsFhirPackageDir(typeId.package)}/${pascalCase(path)}`;
-        }
-      }
-      return `../../${tsModulePath(typeId)}`;
-    };
-    const addType = (typeId) => {
-      if (typeId.kind === "primitive-type") return;
-      const tsName = tsResourceName(typeId);
-      if (!usedTypes.has(tsName)) {
-        usedTypes.set(tsName, {
-          importPath: getModulePath(typeId),
-          tsName
-        });
-      }
-    };
-    addType(flatProfile.base);
-    const fields = flatProfile.fields ?? {};
-    for (const [_fieldName, field] of Object.entries(fields)) {
+  collectTypesFromSlices(flatProfile, addType) {
+    for (const field of Object.values(flatProfile.fields ?? {})) {
       if (!isNotChoiceDeclarationField(field) || !field.slicing?.slices || !field.type) continue;
-      for (const [_sliceName, slice] of Object.entries(field.slicing.slices)) {
-        const match = slice.match ?? {};
-        if (Object.keys(match).length === 0) continue;
-        addType(field.type);
+      for (const slice of Object.values(field.slicing.slices)) {
+        if (Object.keys(slice.match ?? {}).length > 0) {
+          addType(field.type);
+        }
       }
     }
-    const extensions = flatProfile.extensions ?? [];
+  }
+  collectTypesFromExtensions(tsIndex, flatProfile, addType) {
     let needsExtensionType = false;
-    for (const ext of extensions) {
+    for (const ext of flatProfile.extensions ?? []) {
       if (ext.isComplex && ext.subExtensions) {
         needsExtensionType = true;
         for (const sub of ext.subExtensions) {
-          if (sub.valueType) {
-            const resolvedType = tsIndex.resolveByUrl(
-              flatProfile.identifier.package,
-              sub.valueType.url
-            );
-            if (resolvedType) {
-              addType(resolvedType.identifier);
-            } else {
-              addType(sub.valueType);
-            }
-          }
+          if (!sub.valueType) continue;
+          const resolvedType = tsIndex.resolveByUrl(
+            flatProfile.identifier.package,
+            sub.valueType.url
+          );
+          addType(resolvedType?.identifier ?? sub.valueType);
         }
       } else if (ext.valueTypes && ext.valueTypes.length === 1) {
         needsExtensionType = true;
-        const valueType = ext.valueTypes[0];
-        if (valueType) {
-          addType(valueType);
+        if (ext.valueTypes[0]) {
+          const resolvedType = tsIndex.resolveByUrl(
+            flatProfile.identifier.package,
+            ext.valueTypes[0].url
+          );
+          addType(resolvedType?.identifier ?? ext.valueTypes[0]);
         }
       } else {
         needsExtensionType = true;
       }
     }
-    if (needsExtensionType) {
-      const extensionUrl = "http://hl7.org/fhir/StructureDefinition/Extension";
-      const extensionSchema = tsIndex.resolveByUrl(flatProfile.identifier.package, extensionUrl);
-      if (extensionSchema) {
-        addType(extensionSchema.identifier);
-      }
-    }
+    return needsExtensionType;
+  }
+  collectTypesFromFieldOverrides(tsIndex, flatProfile, addType) {
     const referenceUrl = "http://hl7.org/fhir/StructureDefinition/Reference";
     const referenceSchema = tsIndex.resolveByUrl(flatProfile.identifier.package, referenceUrl);
     const specialization = tsIndex.findLastSpecialization(flatProfile);
-    if (isSpecializationTypeSchema(specialization)) {
-      for (const [fieldName, pField] of Object.entries(flatProfile.fields ?? {})) {
-        if (!isNotChoiceDeclarationField(pField)) continue;
-        const sField = specialization.fields?.[fieldName];
-        if (!sField || isChoiceDeclarationField(sField)) continue;
-        if (pField.reference && sField.reference && pField.reference.length < sField.reference.length) {
-          if (referenceSchema) {
-            addType(referenceSchema.identifier);
-          }
-        } else if (pField.required && !sField.required) {
-          if (pField.type) {
-            addType(pField.type);
-          }
-        }
+    if (!isSpecializationTypeSchema(specialization)) return;
+    for (const [fieldName, pField] of Object.entries(flatProfile.fields ?? {})) {
+      if (!isNotChoiceDeclarationField(pField)) continue;
+      const sField = specialization.fields?.[fieldName];
+      if (!sField || isChoiceDeclarationField(sField)) continue;
+      if (pField.reference && sField.reference && pField.reference.length < sField.reference.length) {
+        if (referenceSchema) addType(referenceSchema.identifier);
+      } else if (pField.required && !sField.required && pField.type) {
+        addType(pField.type);
+      }
+    }
+  }
+  generateProfileImports(tsIndex, flatProfile) {
+    const usedTypes = /* @__PURE__ */ new Map();
+    const getModulePath = (typeId) => {
+      if (isNestedIdentifier(typeId)) {
+        const path = canonicalToName3(typeId.url, true);
+        if (path) return `../../${tsFhirPackageDir(typeId.package)}/${pascalCase(path)}`;
+      }
+      return `../../${tsModulePath(typeId)}`;
+    };
+    const addType = (typeId) => {
+      if (typeId.kind === "primitive-type") return;
+      const tsName = tsResourceName(typeId);
+      if (!usedTypes.has(tsName)) {
+        usedTypes.set(tsName, { importPath: getModulePath(typeId), tsName });
       }
+    };
+    addType(flatProfile.base);
+    this.collectTypesFromSlices(flatProfile, addType);
+    const needsExtensionType = this.collectTypesFromExtensions(tsIndex, flatProfile, addType);
+    this.collectTypesFromFieldOverrides(tsIndex, flatProfile, addType);
+    if (needsExtensionType) {
+      const extensionUrl = "http://hl7.org/fhir/StructureDefinition/Extension";
+      const extensionSchema = tsIndex.resolveByUrl(flatProfile.identifier.package, extensionUrl);
+      if (extensionSchema) addType(extensionSchema.identifier);
     }
     const sortedImports = Array.from(usedTypes.values()).sort((a, b) => a.tsName.localeCompare(b.tsName));
     for (const { importPath, tsName } of sortedImports) {
       this.tsImportType(importPath, tsName);
     }
-    if (sortedImports.length > 0) {
-      this.line();
-    }
+    if (sortedImports.length > 0) this.line();
   }
   generateProfileClass(tsIndex, flatProfile) {
     const tsBaseResourceName = tsTypeFromIdentifier(flatProfile.base);
     const tsProfileName = tsResourceName(flatProfile.identifier);
-    const profileClassName = tsProfileClassName(flatProfile.identifier);
+    const profileClassName = tsProfileClassName(flatProfile);
     const polymorphicBaseNames = /* @__PURE__ */ new Set([
       "value",
       "effective",
@@ -4887,7 +5113,7 @@ var TypeScript = class extends Writer {
   generateResourceModule(tsIndex, schema) {
     if (isProfileTypeSchema(schema)) {
       this.cd("profiles", () => {
-        this.cat(`${tsModuleFileName(schema.identifier)}`, () => {
+        this.cat(`${tsProfileModuleFileName(tsIndex, schema)}`, () => {
           this.generateDisclaimer();
           const flatProfile = tsIndex.flatProfile(schema);
           this.generateProfileImports(tsIndex, flatProfile);
@@ -4937,7 +5163,7 @@ var TypeScript = class extends Writer {
           for (const schema of packageSchemas) {
             this.generateResourceModule(tsIndex, schema);
           }
-          this.generateProfileIndexFile(packageSchemas.filter(isProfileTypeSchema));
+          this.generateProfileIndexFile(tsIndex, packageSchemas.filter(isProfileTypeSchema));
           this.generateFhirPackageIndexFile(packageSchemas);
         });
       }
@@ -4994,7 +5220,8 @@ var APIBuilder = class {
       treeShake: void 0,
       promoteLogical: void 0,
       registry: void 0,
-      logLevel: parseLogLevel("INFO")
+      logLevel: parseLogLevel("INFO"),
+      dropCanonicalManagerCache: false
     };
     const opts = {
       ...defaultOpts,
@@ -5016,7 +5243,8 @@ var APIBuilder = class {
     this.manager = userOpts.manager ?? CanonicalManager({
       packages: [],
       workingDir: ".codegen-cache/canonical-manager-cache",
-      registry: userOpts.registry
+      registry: userOpts.registry,
+      dropCache: userOpts.dropCanonicalManagerCache
     });
     this.logger = userOpts.logger ?? createLogger({ prefix: "API", level: opts.logLevel });
     this.options = opts;
@@ -5030,14 +5258,6 @@ var APIBuilder = class {
     this.managerInput.npmPackages.push(packageRef);
     return this;
   }
-  /**
-   * Set a custom FHIR package registry URL
-   * @param url The registry URL (default: https://fs.get-ig.org/pkgs/)
-   */
-  registry(url) {
-    this.options.registry = url;
-    return this;
-  }
   localStructureDefinitions(config) {
     this.logger.info(`Registering local StructureDefinitions for ${config.package.name}@${config.package.version}`);
     this.managerInput.localSDs.push({
@@ -5241,10 +5461,11 @@ var APIBuilder = class {
           focusedPackages: packageMetas
         });
       }
-      const typeSchemas = await generateTypeSchemas(register, this.logger);
+      const { schemas: typeSchemas, collisions } = await generateTypeSchemas(register, this.logger);
       const tsIndexOpts = {
         register,
-        logger: this.logger
+        logger: this.logger,
+        irReport: Object.keys(collisions).length > 0 ? { collisions } : {}
       };
       let tsIndex = mkTypeSchemaIndex(typeSchemas, tsIndexOpts);
       if (this.options.treeShake) tsIndex = treeShake(tsIndex, this.options.treeShake);
@@ -5298,6 +5519,6 @@ var APIBuilder = class {
   }
 };
 
-export { APIBuilder, LogLevel, prettyReport };
+export { APIBuilder, LogLevel, prettyReport, registerFromPackageMetas };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map