@atomic-ehr/codegen 0.0.5 → 0.0.6

package/dist/index.js

@@ -1,14 +1,14 @@
 import pc from 'picocolors';
+import assert3 from 'assert';
 import * as fs from 'fs';
-import fs__default, { existsSync } from 'fs';
-import * as afs2 from 'fs/promises';
-import { readFile } from 'fs/promises';
-import * as Path from 'path';
-import Path__default, { resolve } from 'path';
+import fs__default 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 assert3 from 'assert';
+import * as fsPromises from 'fs/promises';
 import * as YAML from 'yaml';
+import YAML__default from 'yaml';
 import * as fhirschema from '@atomic-ehr/fhirschema';
 import { isStructureDefinition } from '@atomic-ehr/fhirschema';
 import { spawn } from 'child_process';
@@ -247,23 +247,24 @@ var FileSystemWriter = class {
   }
   cd(path, gen) {
     const prev = this.currentDir;
-    this.currentDir = path.startsWith("/") ? Path.join(this.opts.outputDir, path) : Path.join(this.currentDir ?? this.opts.outputDir, path);
+    this.currentDir = path.startsWith("/") ? Path5.join(this.opts.outputDir, path) : Path5.join(this.currentDir ?? this.opts.outputDir, path);
     this.onDiskMkDir(this.currentDir);
     this.logger()?.debug(`cd '${this.currentDir}'`);
     gen();
     this.currentDir = prev;
   }
   cat(fn, gen) {
+    if (!this.currentDir) throw new Error("Should be in a directory (`cd`)");
     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 = Path.normalize(`${this.currentDir}/${fn}`);
+    const relPath = Path5.normalize(`${this.currentDir}/${fn}`);
     try {
       const descriptor = this.onDiskOpenFile(relPath);
       this.logger()?.debug(`cat > '${relPath}'`);
       this.currentFile = { descriptor, relPath };
       this.writtenFilesBuffer[this.currentFile.relPath] = {
         relPath,
-        absPath: Path.resolve(relPath),
+        absPath: Path5.resolve(relPath),
         tokens: []
       };
       gen();
@@ -279,14 +280,23 @@ var FileSystemWriter = class {
     if (!buf) throw new Error("No buffer found");
     buf.tokens.push(str);
   }
+  copyAssets(source, destination) {
+    const content = fs.readFileSync(source, "utf8");
+    this.writtenFilesBuffer[destination] = {
+      relPath: destination,
+      absPath: Path5.resolve(destination),
+      tokens: [content]
+    };
+    fs.cpSync(source, destination);
+  }
   cp(source, destination) {
     if (!this.opts.resolveAssets) throw new Error("resolveAssets is not defined");
-    source = Path.resolve(this.opts.resolveAssets(source));
-    destination = Path.normalize(`${this.currentDir ?? this.opts.outputDir}/${destination}`);
+    source = Path5.resolve(this.opts.resolveAssets(source));
+    destination = Path5.normalize(`${this.currentDir ?? this.opts.outputDir}/${destination}`);
     const content = fs.readFileSync(source, "utf8");
     this.writtenFilesBuffer[destination] = {
       relPath: destination,
-      absPath: Path.resolve(destination),
+      absPath: Path5.resolve(destination),
       tokens: [content]
     };
     fs.cpSync(source, destination);
@@ -296,6 +306,25 @@ var FileSystemWriter = class {
       return { relPath, absPath, content: tokens.join("") };
     }).sort((a, b) => a.relPath.localeCompare(b.relPath));
   }
+  async flushAsync() {
+    const files = this.writtenFiles();
+    const dirs = /* @__PURE__ */ new Set();
+    for (const file of files) {
+      dirs.add(Path5.dirname(file.absPath));
+    }
+    await Promise.all(Array.from(dirs).map((dir) => fsPromises.mkdir(dir, { recursive: true })));
+    await Promise.all(files.map((file) => fsPromises.writeFile(file.absPath, file.content)));
+  }
+  async generateAsync(tsIndex) {
+    const originalInMemoryOnly = this.opts.inMemoryOnly;
+    this.opts.inMemoryOnly = true;
+    try {
+      await this.generate(tsIndex);
+    } finally {
+      this.opts.inMemoryOnly = originalInMemoryOnly;
+    }
+    await this.flushAsync();
+  }
 };
 var Writer = class extends FileSystemWriter {
   currentIndent = 0;
@@ -387,15 +416,21 @@ var extractNameFromCanonical = (canonical, dropFragment = true) => {
   }
   return localName;
 };
-var packageMetaToFhir = (packageMeta) => `${packageMeta.name}#${packageMeta.version}`;
-var packageMetaToNpm = (packageMeta) => `${packageMeta.name}@${packageMeta.version}`;
-var enrichFHIRSchema = (schema, packageMeta) => {
-  if (!packageMeta) {
-    packageMeta = { name: "undefined", version: "undefined" };
+var packageMeta = (schema) => {
+  return {
+    name: schema.identifier.package,
+    version: schema.identifier.version
+  };
+};
+var packageMetaToFhir = (packageMeta2) => `${packageMeta2.name}#${packageMeta2.version}`;
+var packageMetaToNpm = (packageMeta2) => `${packageMeta2.name}@${packageMeta2.version}`;
+var enrichFHIRSchema = (schema, packageMeta2) => {
+  if (!packageMeta2) {
+    packageMeta2 = { name: "undefined", version: "undefined" };
   }
   return {
     ...schema,
-    package_meta: schema.package_meta || packageMeta,
+    package_meta: schema.package_meta || packageMeta2,
     name: schema.name,
     url: schema.url,
     base: schema.base
@@ -452,12 +487,12 @@ var isChoiceInstanceField = (field) => {
   if (!field) return false;
   return field.choiceOf !== void 0;
 };
-var enrichValueSet = (vs, packageMeta) => {
+var enrichValueSet = (vs, packageMeta2) => {
   if (!vs.url) throw new Error("ValueSet must have a URL");
   if (!vs.name) throw new Error("ValueSet must have a name");
   return {
     ...vs,
-    package_meta: vs.package_meta || packageMeta,
+    package_meta: vs.package_meta || packageMeta2,
     name: vs.name,
     url: vs.url
   };
@@ -511,12 +546,12 @@ function formatName(input) {
 
 // src/api/writer-generator/csharp/csharp.ts
 var resolveCSharpAssets = (fn) => {
-  const __filename2 = fileURLToPath(import.meta.url);
-  const __dirname = Path__default.dirname(__filename2);
-  if (__filename2.endsWith("dist/index.js")) {
-    return Path__default.resolve(__dirname, "..", "assets", "api", "writer-generator", "csharp", 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);
   } else {
-    return Path__default.resolve(__dirname, "../../../..", "assets", "api", "writer-generator", "csharp", fn);
+    return Path5__default.resolve(__dirname, "../../../..", "assets", "api", "writer-generator", "csharp", fn);
   }
 };
 var PRIMITIVE_TYPE_MAP = {
@@ -787,7 +822,7 @@ var CSharp = class extends Writer {
   generateHelperFile() {
     if (this.opts.inMemoryOnly) return;
     const sourceFile = resolveCSharpAssets("Helper.cs");
-    const destFile = Path__default.join(this.opts.outputDir, "Helper.cs");
+    const destFile = Path5__default.join(this.opts.outputDir, "Helper.cs");
     fs__default.copyFileSync(sourceFile, destFile);
   }
 };
@@ -862,51 +897,87 @@ var resourceRelatives = (schemas) => {
     (e) => isResourceTypeSchema(e) || isLogicalTypeSchema(e) || isComplexTypeTypeSchema(e)
   );
   const directPairs = [];
+  const childrenByParent = /* @__PURE__ */ new Map();
   for (const schema of regularSchemas) {
     if (schema.base) {
       directPairs.push({ parent: schema.base, child: schema.identifier });
+      const parentName = schema.base.name;
+      let children = childrenByParent.get(parentName);
+      if (!children) {
+        children = [];
+        childrenByParent.set(parentName, children);
+      }
+      children.push(schema.identifier);
     }
   }
-  const allPairs = [...directPairs];
-  const findTransitiveRelatives = (parentRef) => {
-    const directChildren = directPairs.filter((pair) => pair.parent.name === parentRef.name).map((pair) => pair.child);
-    const transitiveChildren = [];
+  const transitiveCache = /* @__PURE__ */ new Map();
+  const getTransitiveChildren = (parentName) => {
+    const cached = transitiveCache.get(parentName);
+    if (cached) return cached;
+    const directChildren = childrenByParent.get(parentName) ?? [];
+    const result = [...directChildren];
     for (const child of directChildren) {
-      transitiveChildren.push(...findTransitiveRelatives(child));
+      result.push(...getTransitiveChildren(child.name));
     }
-    return [...directChildren, ...transitiveChildren];
+    transitiveCache.set(parentName, result);
+    return result;
   };
+  const seen = /* @__PURE__ */ new Set();
+  const allPairs = [];
   for (const pair of directPairs) {
-    const transitiveChildren = findTransitiveRelatives(pair.child);
-    for (const transitiveChild of transitiveChildren) {
-      if (!directPairs.some((dp) => dp.parent.name === pair.parent.name && dp.child.name === transitiveChild.name)) {
+    const key = `${pair.parent.name}|${pair.child.name}`;
+    seen.add(key);
+    allPairs.push(pair);
+    for (const transitiveChild of getTransitiveChildren(pair.child.name)) {
+      const transitiveKey = `${pair.parent.name}|${transitiveChild.name}`;
+      if (!seen.has(transitiveKey)) {
+        seen.add(transitiveKey);
         allPairs.push({ parent: pair.parent, child: transitiveChild });
       }
     }
   }
   return allPairs;
 };
-var mkTypeSchemaIndex = (schemas, { resolutionTree, logger }) => {
+var mkTypeSchemaIndex = (schemas, {
+  register,
+  logger,
+  irReport = {}
+}) => {
   const index = {};
+  const nestedIndex = {};
   const append = (schema) => {
     const url = schema.identifier.url;
     const pkg = schema.identifier.package;
     if (!index[url]) index[url] = {};
-    if (index[url][schema.identifier.package] && pkg !== "shared") {
+    if (index[url][pkg] && pkg !== "shared") {
       const r1 = JSON.stringify(schema.identifier, void 0, 2);
       const r2 = JSON.stringify(index[url][pkg]?.identifier, void 0, 2);
       if (r1 !== r2) throw new Error(`Duplicate schema: ${r1} and ${r2}`);
       return;
     }
     index[url][pkg] = schema;
+    if (isSpecializationTypeSchema(schema) || isProfileTypeSchema(schema)) {
+      if (schema.nested) {
+        schema.nested.forEach((nschema) => {
+          const nurl = nschema.identifier.url;
+          const npkg = nschema.identifier.package;
+          nestedIndex[nurl] ??= {};
+          nestedIndex[nurl][npkg] = nschema;
+        });
+      }
+    }
   };
   for (const schema of schemas) {
     append(schema);
   }
   const relations = resourceRelatives(schemas);
-  const resolve6 = (id) => index[id.url]?.[id.package];
+  const resolve5 = (id) => {
+    if (id.kind === "nested") return nestedIndex[id.url]?.[id.package];
+    return index[id.url]?.[id.package];
+  };
   const resolveByUrl = (pkgName, url) => {
-    if (resolutionTree) {
+    if (register) {
+      const resolutionTree = register.resolutionTree();
       const resolution = resolutionTree[pkgName]?.[url]?.[0];
       if (resolution) {
         return index[url]?.[resolution.pkg.name];
@@ -924,7 +995,7 @@ var mkTypeSchemaIndex = (schemas, { resolutionTree, logger }) => {
       res.push(cur);
       const base = cur.base;
       if (base === void 0) break;
-      const resolved = resolve6(base);
+      const resolved = resolve5(base);
       if (!resolved) {
         logger?.warn(
           `Failed to resolve base type: ${res.map((e) => `${e.identifier.url} (${e.identifier.kind})`).join(", ")}`
@@ -950,7 +1021,7 @@ var mkTypeSchemaIndex = (schemas, { resolutionTree, logger }) => {
     return nonConstraintSchema;
   };
   const findLastSpecializationByIdentifier = (id) => {
-    const schema = resolve6(id);
+    const schema = resolve5(id);
     if (!schema) return id;
     return findLastSpecialization(schema).identifier;
   };
@@ -980,11 +1051,21 @@ var mkTypeSchemaIndex = (schemas, { resolutionTree, logger }) => {
       deps[e.url] = e;
     }
     const dependencies = Object.values(deps);
+    const extensionMap = /* @__PURE__ */ new Map();
+    for (const anySchema of constraintSchemas.slice().reverse()) {
+      const extensions = anySchema.extensions ?? [];
+      for (const ext of extensions) {
+        const key = `${ext.path}|${ext.name}|${ext.url ?? ""}`;
+        extensionMap.set(key, ext);
+      }
+    }
+    const mergedExtensions = Array.from(extensionMap.values());
     return {
       ...schema,
       base: nonConstraintSchema.identifier,
       fields: mergedFields,
-      dependencies
+      dependencies,
+      extensions: mergedExtensions.length > 0 ? mergedExtensions : void 0
     };
   };
   const isWithMetaField = (profile) => {
@@ -994,7 +1075,7 @@ var mkTypeSchemaIndex = (schemas, { resolutionTree, logger }) => {
       return schema.fields?.meta !== void 0;
     });
   };
-  const exportTree = async (filename) => {
+  const entityTree = () => {
     const tree = {};
     for (const [pkgId, shemas] of Object.entries(groupByPackages(schemas))) {
       tree[pkgId] = {
@@ -1011,18 +1092,25 @@ var mkTypeSchemaIndex = (schemas, { resolutionTree, logger }) => {
         tree[pkgId][schema.identifier.kind][schema.identifier.url] = {};
       }
     }
+    return tree;
+  };
+  const exportTree = async (filename) => {
+    const tree = entityTree();
     const raw = filename.endsWith(".yaml") ? YAML.stringify(tree) : JSON.stringify(tree, void 0, 2);
-    await afs2.mkdir(Path.dirname(filename), { recursive: true });
-    await afs2.writeFile(filename, raw);
+    await fsPromises.mkdir(Path5.dirname(filename), { recursive: true });
+    await fsPromises.writeFile(filename, raw);
   };
   return {
     _schemaIndex: index,
     _relations: relations,
+    schemas,
+    schemasByPackage: groupByPackages(schemas),
+    register,
     collectComplexTypes: () => schemas.filter(isComplexTypeTypeSchema),
     collectResources: () => schemas.filter(isResourceTypeSchema),
     collectLogicalModels: () => schemas.filter(isLogicalTypeSchema),
     collectProfiles: () => schemas.filter(isProfileTypeSchema),
-    resolve: resolve6,
+    resolve: resolve5,
     resolveByUrl,
     resourceChildren,
     tryHierarchy,
@@ -1031,7 +1119,10 @@ var mkTypeSchemaIndex = (schemas, { resolutionTree, logger }) => {
     findLastSpecializationByIdentifier,
     flatProfile,
     isWithMetaField,
-    exportTree
+    entityTree,
+    exportTree,
+    irReport: () => irReport,
+    replaceSchemas: (newSchemas) => mkTypeSchemaIndex(newSchemas, { register, logger, irReport: { ...irReport } })
   };
 };
 
@@ -1106,9 +1197,6 @@ var MAX_IMPORT_LINE_LENGTH = 100;
 var fixReservedWords = (name) => {
   return PYTHON_KEYWORDS.has(name) ? `${name}_` : name;
 };
-var injectSuperClasses = (name) => {
-  return name === "Resource" || name === "Element" ? ["BaseModel"] : [];
-};
 var canonicalToName2 = (canonical, dropFragment = true) => {
   if (!canonical) return void 0;
   let localName = canonical.split("/").pop();
@@ -1134,19 +1222,22 @@ var deriveResourceName = (id) => {
   return pascalCase(id.name);
 };
 var resolvePyAssets = (fn) => {
-  const __dirname = Path.dirname(fileURLToPath(import.meta.url));
+  const __dirname = Path5.dirname(fileURLToPath(import.meta.url));
+  const __filename = fileURLToPath(import.meta.url);
   if (__filename.endsWith("dist/index.js")) {
-    return Path.resolve(__dirname, "..", "assets", "api", "writer-generator", "python", fn);
+    return Path5.resolve(__dirname, "..", "assets", "api", "writer-generator", "python", fn);
   } else {
-    return Path.resolve(__dirname, "../../..", "assets", "api", "writer-generator", "python", fn);
+    return Path5.resolve(__dirname, "../../..", "assets", "api", "writer-generator", "python", fn);
   }
 };
 var Python = class extends Writer {
   nameFormatFunction;
   tsIndex;
+  forFhirpyClient;
   constructor(options) {
     super({ ...options, resolveAssets: options.resolveAssets ?? resolvePyAssets });
     this.nameFormatFunction = this.getFieldFormatFunction(options.fieldFormat);
+    this.forFhirpyClient = options.fhirpyClient ?? false;
   }
   async generate(tsIndex) {
     this.tsIndex = tsIndex;
@@ -1159,7 +1250,12 @@ var Python = class extends Writer {
   }
   generateRootPackages(groups) {
     this.generateRootInitFile(groups);
-    this.cp(resolvePyAssets("requirements.txt"), "requirements.txt");
+    if (this.forFhirpyClient)
+      this.copyAssets(
+        resolvePyAssets("fhirpy_base_model.py"),
+        Path5.resolve(this.opts.outputDir, "fhirpy_base_model.py")
+      );
+    this.copyAssets(resolvePyAssets("requirements.txt"), Path5.resolve(this.opts.outputDir, "requirements.txt"));
   }
   generateSDKPackages(groups) {
     this.generateComplexTypesPackages(groups.groupedComplexTypes);
@@ -1310,6 +1406,7 @@ var Python = class extends Writer {
     this.cat(`${snakeCase(schema.identifier.name)}.py`, () => {
       this.generateDisclaimer();
       this.generateDefaultImports();
+      this.generateFhirBaseModelImport();
       this.line();
       this.generateDependenciesImports(schema);
       this.line();
@@ -1318,6 +1415,10 @@ var Python = class extends Writer {
       this.generateType(schema);
     });
   }
+  generateFhirBaseModelImport() {
+    if (this.forFhirpyClient)
+      this.pyImportFrom(`${this.opts.rootPackageName}.fhirpy_base_model`, "FhirpyBaseModel");
+  }
   generateType(schema) {
     const className = deriveResourceName(schema.identifier);
     const superClasses = this.getSuperClasses(schema);
@@ -1328,7 +1429,7 @@ var Python = class extends Writer {
     this.line();
   }
   getSuperClasses(schema) {
-    return [...schema.base ? [schema.base.name] : [], ...injectSuperClasses(schema.identifier.name)];
+    return [...schema.base ? [schema.base.name] : [], ...this.injectSuperClasses(schema.identifier.url)];
   }
   generateClassBody(schema) {
     this.generateModelConfig();
@@ -1526,7 +1627,9 @@ var Python = class extends Writer {
   }
   generateFamilyDefinition(familyName, resources) {
     const listName = `${familyName}_resources`;
-    this.line(`${listName} = [${resources.map((r) => `'${r}'`).join(", ")}]`);
+    this.line(
+      `${listName} = [${resources.map((r) => `'${r}'`).sort().join(", ")}]`
+    );
     this.line();
     this.line(`def validate_and_downcast_${familyName}(v: Any) -> Any:`);
     this.line(`   return validate_and_downcast(v, packages, ${listName})`);
@@ -1564,7 +1667,43 @@ var Python = class extends Writer {
     }
     return AVAILABLE_STRING_FORMATS[format2];
   }
+  injectSuperClasses(url) {
+    const name = canonicalToName2(url);
+    if (name === "resource") return this.forFhirpyClient ? ["FhirpyBaseModel"] : ["BaseModel"];
+    if (name === "element") return ["BaseModel"];
+    return [];
+  }
+};
+
+// 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/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."
+  }
 };
+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) {
@@ -1643,10 +1782,13 @@ function mkNestedIdentifier(register, fhirSchema, path, logger) {
   }
   const nestedName = path.join(".");
   const url = nestedTypeOrigins[nestedName] ?? `${fhirSchema.url}#${nestedName}`;
+  const baseUrl = url.split("#")[0];
+  const baseFs = register.resolveFs(fhirSchema.package_meta, baseUrl);
+  const packageMeta2 = baseFs?.package_meta ?? fhirSchema.package_meta;
   return {
     kind: "nested",
-    package: fhirSchema.package_meta.name,
-    version: fhirSchema.package_meta.version,
+    package: packageMeta2.name,
+    version: packageMeta2.version,
     name: nestedName,
     url
   };
@@ -1770,6 +1912,49 @@ var buildReferences = (register, fhirSchema, element) => {
     return mkIdentifier(fs7);
   });
 };
+var extractSliceFieldNames = (schema) => {
+  const required = /* @__PURE__ */ new Set();
+  const excluded = /* @__PURE__ */ new Set();
+  if (schema.required) {
+    for (const name of schema.required) required.add(name);
+  }
+  if (schema.excluded) {
+    for (const name of schema.excluded) excluded.add(name);
+  }
+  if (schema.elements) {
+    for (const [name, element] of Object.entries(schema.elements)) {
+      if (element.min !== void 0 && element.min > 0) {
+        required.add(name);
+      }
+    }
+  }
+  return {
+    required: required.size > 0 ? Array.from(required) : void 0,
+    excluded: excluded.size > 0 ? Array.from(excluded) : void 0
+  };
+};
+var buildSlicing = (element) => {
+  const slicing = element.slicing;
+  if (!slicing) return void 0;
+  const slices = {};
+  for (const [name, slice] of Object.entries(slicing.slices ?? {})) {
+    if (!slice) continue;
+    const { required, excluded } = slice.schema ? extractSliceFieldNames(slice.schema) : {};
+    slices[name] = {
+      min: slice.min,
+      max: slice.max,
+      match: slice.match,
+      required,
+      excluded
+    };
+  }
+  return {
+    discriminator: slicing.discriminator,
+    rules: slicing.rules,
+    ordered: slicing.ordered,
+    slices: Object.keys(slices).length > 0 ? slices : void 0
+  };
+};
 function buildFieldType(register, fhirSchema, path, element, logger) {
   if (element.elementReference) {
     const refPath = element.elementReference.slice(1).filter((_, i) => i % 2 === 1);
@@ -1779,7 +1964,7 @@ function buildFieldType(register, fhirSchema, path, element, logger) {
     const fieldFs = register.resolveFs(fhirSchema.package_meta, url);
     if (!fieldFs)
       throw new Error(
-        `Could not resolve field type: '${element.type}' (from '${fhirSchema.url}' in '${packageMetaToFhir(fhirSchema.package_meta)}')`
+        `Could not resolve field type: <${fhirSchema.url}>.${path.join(".")}: <${element.type}> (pkg: '${packageMetaToFhir(fhirSchema.package_meta)}'))`
       );
     return mkIdentifier(fieldFs);
   } else if (element.choices) {
@@ -1788,7 +1973,7 @@ function buildFieldType(register, fhirSchema, path, element, logger) {
     return void 0;
   } else {
     logger?.error(
-      `Can't recognize element type '${fhirSchema.url}' (${fhirSchema.derivation}) at '${path.join(".")}': ${JSON.stringify(element, void 0, 2)}`
+      `Can't recognize element type: <${fhirSchema.url}>.${path.join(".")} (pkg: '${packageMetaToFhir(fhirSchema.package_meta)}'): ${JSON.stringify(element, void 0, 2)}`
     );
     throw new Error(`Unrecognized element type`);
   }
@@ -1804,7 +1989,7 @@ var mkField = (register, fhirSchema, path, element, logger) => {
   }
   const fieldType = buildFieldType(register, fhirSchema, path, element, logger);
   if (!fieldType)
-    logger?.warn(`Field type not found for '${fhirSchema.url}#${path.join(".")}' (${fhirSchema.derivation})`);
+    logger?.dry_warn(`Field type not found for '${fhirSchema.url}#${path.join(".")}' (${fhirSchema.derivation})`);
   return {
     type: fieldType,
     required: isRequired(register, fhirSchema, path),
@@ -1813,6 +1998,7 @@ var mkField = (register, fhirSchema, path, element, logger) => {
     array: element.array || false,
     min: element.min,
     max: element.max,
+    slicing: buildSlicing(element),
     choices: element.choices,
     choiceOf: element.choiceOf,
     binding,
@@ -1831,7 +2017,8 @@ function mkNestedField(register, fhirSchema, path, element, logger) {
     type: nestedIdentifier,
     array: element.array || false,
     required: isRequired(register, fhirSchema, path),
-    excluded: isExcluded(register, fhirSchema, path)
+    excluded: isExcluded(register, fhirSchema, path),
+    slicing: buildSlicing(element)
   };
 }
 
@@ -1940,10 +2127,11 @@ function collectBindingSchemas(register, fhirSchema, logger) {
     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 (element.binding) {
-        const binding = generateBindingSchema(register, fhirSchema, path, element, logger);
+      if (elemSnapshot.binding) {
+        const binding = generateBindingSchema(register, fhirSchema, path, elemSnapshot, logger);
         if (binding) {
           bindings.push(binding);
         }
@@ -1973,6 +2161,13 @@ 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(
+        `Skipping field ${path} for ${fcurl} due to skip hack ${shouldSkipCanonical(fhirSchema.package_meta, fcurl).reason}`
+      );
+      continue;
+    }
     if (isNestedElement(elemSnapshot)) {
       fields[key] = mkNestedField(register, fhirSchema, path, elemSnapshot, logger);
     } else {
@@ -2054,18 +2249,143 @@ function transformFhirSchemaResource(register, fhirSchema, logger) {
   }
   const fields = mkFields(register, fhirSchema, [], fhirSchema.elements, logger);
   const nested = mkNestedTypes(register, fhirSchema, logger);
+  const extensions = fhirSchema.derivation === "constraint" ? extractProfileExtensions(register, fhirSchema, logger) : void 0;
   const dependencies = extractDependencies(identifier, base, fields, nested);
+  const extensionDeps = extensions?.flatMap((ext) => ext.valueTypes ?? []) ?? [];
+  const mergedDeps = (() => {
+    if (!dependencies && extensionDeps.length === 0) return dependencies;
+    const depMap = {};
+    for (const dep of dependencies ?? []) depMap[dep.url] = dep;
+    for (const dep of extensionDeps) depMap[dep.url] = dep;
+    return Object.values(depMap);
+  })();
   const typeSchema = {
     identifier,
     base,
     fields,
     nested,
     description: fhirSchema.description,
-    dependencies
+    dependencies: mergedDeps,
+    ...extensions && extensions.length > 0 ? { extensions } : {}
   };
   const bindingSchemas = collectBindingSchemas(register, fhirSchema, logger);
   return [typeSchema, ...bindingSchemas];
 }
+function extractExtensionValueTypes(register, fhirSchema, extensionUrl, logger) {
+  const extensionSchema = register.resolveFs(fhirSchema.package_meta, extensionUrl);
+  if (!extensionSchema?.elements) return void 0;
+  const valueTypes = [];
+  for (const [key, element] of Object.entries(extensionSchema.elements)) {
+    if (element.choiceOf !== "value" && !key.startsWith("value")) continue;
+    const fieldType = buildFieldType(register, extensionSchema, [key], element, logger);
+    if (fieldType) valueTypes.push(fieldType);
+  }
+  if (valueTypes.length === 0) return void 0;
+  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;
+  const 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;
+      valueType = buildFieldType(register, extensionSchema, [key, elemKey], elemValue, logger);
+      if (valueType) break;
+    }
+    subExtensions.push({
+      name: sliceName,
+      url: sliceUrl,
+      valueType,
+      min: element.min,
+      max: element.max !== void 0 ? String(element.max) : void 0
+    });
+  }
+  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;
+        }
+      }
+      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"
+      });
+    }
+  }
+  return subExtensions.length > 0 ? subExtensions : void 0;
+}
+function extractProfileExtensions(register, fhirSchema, logger) {
+  const extensions = [];
+  const addExtensionEntry = (path, name, schema) => {
+    const url = schema.url;
+    const valueTypes = url ? extractExtensionValueTypes(register, fhirSchema, url, logger) : void 0;
+    const subExtensions = url ? extractSubExtensions(register, fhirSchema, url, logger) : void 0;
+    const isComplex = subExtensions !== void 0 && subExtensions.length > 0;
+    extensions.push({
+      name,
+      path: [...path, "extension"].join("."),
+      url,
+      min: schema.min,
+      max: schema.max !== void 0 ? String(schema.max) : void 0,
+      mustSupport: schema.mustSupport,
+      valueTypes,
+      subExtensions,
+      isComplex
+    });
+  };
+  const walkElement = (path, element) => {
+    if (element.extensions) {
+      for (const [name, schema] of Object.entries(element.extensions)) {
+        addExtensionEntry(path, name, schema);
+      }
+    }
+    if (element.elements) {
+      for (const [key, child] of Object.entries(element.elements)) {
+        walkElement([...path, key], child);
+      }
+    }
+  };
+  if (fhirSchema.extensions) {
+    for (const [name, schema] of Object.entries(fhirSchema.extensions)) {
+      addExtensionEntry([], name, schema);
+    }
+  }
+  if (fhirSchema.elements) {
+    for (const [key, element] of Object.entries(fhirSchema.elements)) {
+      walkElement([key], element);
+    }
+  }
+  return extensions;
+}
 async function transformFhirSchema(register, fhirSchema, logger) {
   const schemas = transformFhirSchemaResource(register, fhirSchema, logger);
   if (isExtensionSchema(fhirSchema, mkIdentifier(fhirSchema))) {
@@ -2090,8 +2410,8 @@ var isValueSet = (resource) => {
 };
 
 // src/typeschema/register.ts
-var readPackageDependencies = async (manager, packageMeta) => {
-  const packageJSON = await manager.packageJson(packageMeta.name);
+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]) => {
@@ -2135,33 +2455,18 @@ var mkPackageAwareResolver = async (manager, pkg, deep, acc, logger) => {
   acc[pkgId] = index;
   return index;
 };
-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);
-  }
+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`);
-    let counter = 0;
-    logger?.info(`FHIR Schema conversion for '${packageMetaToFhir(pkg)}' begins...`);
     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 rfs = enrichFHIRSchema(
-          fhirschema.translate(resource),
-          resourcePkg
-        );
-        counter++;
+        const fs7 = fhirschema.translate(resource);
+        const rfs = enrichFHIRSchema(fs7, resourcePkg);
         resolver[pkgId].fhirSchemas[rfs.url] = rfs;
       }
       if (isValueSet(resource)) {
@@ -2169,15 +2474,33 @@ var registerFromManager = async (manager, { logger, fallbackPackageForNameResolu
         resolver[pkgId].valueSets[rvs.url] = rvs;
       }
     }
-    logger?.info(`FHIR Schema conversion for '${packageMetaToFhir(pkg)}' completed: ${counter} successful`);
   }
+};
+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) => name.match(/^[a-zA-Z0-9]+$/) && `http://hl7.org/fhir/StructureDefinition/${name}` || name;
+  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}'`);
@@ -2215,23 +2538,56 @@ var registerFromManager = async (manager, { logger, fallbackPackageForNameResolu
     }
     return Array.from(keys);
   };
+  let cachedResolutionTree;
   return {
-    ...manager,
     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 = packageAgnosticResolveCanonical(resolver, canonicalUrl);
+    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,
@@ -2240,6 +2596,7 @@ var registerFromManager = async (manager, { logger, fallbackPackageForNameResolu
     getAllElementKeys,
     resolver,
     resolutionTree: () => {
+      if (cachedResolutionTree) return cachedResolutionTree;
       const res = {};
       for (const [_pkgId, pkgIndex] of Object.entries(resolver)) {
         const pkgName = pkgIndex.pkg.name;
@@ -2252,6 +2609,7 @@ var registerFromManager = async (manager, { logger, fallbackPackageForNameResolu
           }
         }
       }
+      cachedResolutionTree = res;
       return res;
     }
   };
@@ -2276,27 +2634,13 @@ function fsElementSnapshot(genealogy) {
 }
 
 // src/typeschema/index.ts
-var codeableReferenceInR4 = "Use CodeableReference which is not provided by FHIR R4.";
-var availabilityInR4 = "Use Availability which is not provided by FHIR R4.";
-var skipMe = {
-  "hl7.fhir.uv.extensions.r4#1.0.0": {
-    "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."
-  }
-};
 var generateTypeSchemas = async (register, logger) => {
   const fhirSchemas = [];
   for (const fhirSchema of register.allFs()) {
     const pkgId = packageMetaToFhir(fhirSchema.package_meta);
-    if (skipMe[pkgId]?.[fhirSchema.url]) {
-      logger?.dry_warn(`Skip ${fhirSchema.url} from ${pkgId}. Reason: ${skipMe[pkgId]?.[fhirSchema.url]}`);
+    const skipCheck = shouldSkipCanonical(fhirSchema.package_meta, fhirSchema.url);
+    if (skipCheck.shouldSkip) {
+      logger?.dry_warn(`Skip ${fhirSchema.url} from ${pkgId}. Reason: ${skipCheck.reason}`);
       continue;
     }
     fhirSchemas.push(...await transformFhirSchema(register, fhirSchema, logger));
@@ -2306,6 +2650,57 @@ var generateTypeSchemas = async (register, logger) => {
   }
   return fhirSchemas;
 };
+
+// src/typeschema/ir/logic-promotion.ts
+var promoteLogical = (tsIndex, promotes) => {
+  const promoteSets = Object.fromEntries(
+    Object.entries(promotes).map(([pkg, urls]) => [pkg, new Set(urls)])
+  );
+  const identifierToString = (i) => `${i.package}-${i.version}-${i.kind}-${i.url}`;
+  const renames = Object.fromEntries(
+    tsIndex.schemas.map((schema) => {
+      const promo = promoteSets[schema.identifier.package]?.has(schema.identifier.url);
+      if (!promo) return void 0;
+      if (schema.identifier.kind !== "logical")
+        throw new Error(`Unexpected schema kind: ${JSON.stringify(schema.identifier)}`);
+      return [identifierToString(schema.identifier), { ...schema.identifier, kind: "resource" }];
+    }).filter((e) => e !== void 0)
+  );
+  const replace = (i) => renames[identifierToString(i)] || i;
+  const replaceInFields = (fields) => {
+    if (!fields) return void 0;
+    return Object.fromEntries(
+      Object.entries(fields).map(([k, f]) => {
+        if (isChoiceDeclarationField(f)) return [k, f];
+        return [k, { ...f, type: f.type ? replace(f.type) : void 0 }];
+      })
+    );
+  };
+  const schemas = tsIndex.schemas.map((schema) => {
+    if (isPrimitiveTypeSchema(schema) || isValueSetTypeSchema(schema)) return schema;
+    const cloned = JSON.parse(JSON.stringify(schema));
+    cloned.identifier = replace(cloned.identifier);
+    cloned.dependencies = cloned.dependencies?.map(replace);
+    if (isSpecializationTypeSchema(cloned) || isProfileTypeSchema(cloned)) {
+      cloned.fields = replaceInFields(cloned.fields);
+      cloned.nested = cloned.nested?.map((n) => {
+        return {
+          ...n,
+          base: replace(n.base),
+          nested: replaceInFields(n.fields)
+        };
+      });
+    }
+    return cloned;
+  });
+  const promotedIndex = tsIndex.replaceSchemas(schemas);
+  promotedIndex.irReport().logicalPromotion = {
+    packages: Object.fromEntries(
+      Object.entries(promotes).map(([pkgName, urls]) => [pkgName, { promotedCanonicals: [...urls].sort() }])
+    )
+  };
+  return promotedIndex;
+};
 var mutableSelectFields = (schema, selectFields) => {
   const selectedFields = {};
   const selectPolimorphic = {};
@@ -2359,8 +2754,38 @@ var mutableIgnoreFields = (schema, ignoreFields) => {
     }
   }
 };
+var mutableFillReport = (report, tsIndex, shakedIndex) => {
+  const packages = Object.keys(tsIndex.schemasByPackage);
+  const shakedPackages = Object.keys(shakedIndex.schemasByPackage);
+  const skippedPackages = packages.filter((pkg) => !shakedPackages.includes(pkg));
+  report.skippedPackages = skippedPackages;
+  for (const [pkgName, shakedSchemas] of Object.entries(shakedIndex.schemasByPackage)) {
+    if (skippedPackages.includes(pkgName)) continue;
+    const tsSchemas = tsIndex.schemasByPackage[pkgName];
+    assert3(tsSchemas);
+    report.packages[pkgName] = {
+      skippedCanonicals: tsSchemas.filter((schema) => !shakedSchemas.includes(schema)).map((schema) => schema.identifier.url).sort(),
+      canonicals: Object.fromEntries(
+        shakedSchemas.map((shakedSchema) => {
+          const schema = tsIndex.resolve(shakedSchema.identifier);
+          assert3(schema);
+          if (!isSpecializationTypeSchema(schema)) return void 0;
+          assert3(isSpecializationTypeSchema(shakedSchema));
+          if (!schema.fields) return void 0;
+          if (!shakedSchema.fields) {
+            return [shakedSchema.identifier.url, Object.keys(schema.fields)];
+          }
+          const shakedFieldNames = Object.keys(shakedSchema.fields);
+          const skippedFields = Object.keys(schema.fields).filter((field) => !shakedFieldNames.includes(field)).sort();
+          if (skippedFields.length === 0) return void 0;
+          return [shakedSchema.identifier.url, { skippedFields }];
+        }).filter((e) => e !== void 0)
+      )
+    };
+  }
+};
 var treeShakeTypeSchema = (schema, rule, _logger) => {
-  schema = structuredClone(schema);
+  schema = JSON.parse(JSON.stringify(schema));
   if (isPrimitiveTypeSchema(schema) || isValueSetTypeSchema(schema) || isBindingSchema(schema)) return schema;
   if (rule.selectFields) {
     if (rule.ignoreFields) throw new Error("Cannot use both ignoreFields and selectFields in the same rule");
@@ -2389,7 +2814,7 @@ var treeShakeTypeSchema = (schema, rule, _logger) => {
   schema.dependencies = extractDependencies(schema.identifier, schema.base, schema.fields, schema.nested);
   return schema;
 };
-var treeShake = (tsIndex, treeShake2, { resolutionTree, logger }) => {
+var treeShake = (tsIndex, treeShake2) => {
   const focusedSchemas = [];
   for (const [pkgId, requires] of Object.entries(treeShake2)) {
     for (const [url, rule] of Object.entries(requires)) {
@@ -2406,7 +2831,7 @@ var treeShake = (tsIndex, treeShake2, { resolutionTree, logger }) => {
     }
     const newSchemas = [];
     for (const schema of schemas) {
-      if (isSpecializationTypeSchema(schema)) {
+      if (isSpecializationTypeSchema(schema) || isProfileTypeSchema(schema)) {
         if (!schema.dependencies) continue;
         schema.dependencies.forEach((dep) => {
           const depSchema = tsIndex.resolve(dep);
@@ -2429,7 +2854,202 @@ var treeShake = (tsIndex, treeShake2, { resolutionTree, logger }) => {
     return collectDeps(newSchemas, acc);
   };
   const shaked = collectDeps(focusedSchemas, {});
-  return mkTypeSchemaIndex(shaked, { resolutionTree, logger });
+  const shakedIndex = tsIndex.replaceSchemas(shaked);
+  const treeShakeReport = { skippedPackages: [], packages: {} };
+  const irReport = shakedIndex.irReport();
+  irReport.treeShake = treeShakeReport;
+  mutableFillReport(treeShakeReport, tsIndex, shakedIndex);
+  return shakedIndex;
+};
+var normalizeFileName = (str) => {
+  const res = str.replace(/[^a-zA-Z0-9\-_.@#()]/g, "");
+  if (res.length === 0) return "unknown";
+  return res;
+};
+var typeSchemaToJson = (ts, pretty) => {
+  const pkgPath = normalizeFileName(ts.identifier.package);
+  const name = normalizeFileName(`${ts.identifier.name}(${extractNameFromCanonical(ts.identifier.url)})`);
+  const baseName = Path5.join(pkgPath, name);
+  return {
+    filename: baseName,
+    genContent: () => JSON.stringify(ts, null, pretty ? 2 : void 0)
+  };
+};
+var fhirSchemaToJson = (fs7, pretty) => {
+  const pkgPath = normalizeFileName(fs7.package_meta.name);
+  const name = normalizeFileName(`${fs7.name}(${extractNameFromCanonical(fs7.url)})`);
+  const baseName = Path5.join(pkgPath, name);
+  return {
+    filename: baseName,
+    genContent: () => JSON.stringify(fs7, null, pretty ? 2 : void 0)
+  };
+};
+var structureDefinitionToJson = (sd, pretty) => {
+  const pkgPath = normalizeFileName(sd.package_name ?? "unknown");
+  const name = normalizeFileName(`${sd.name}(${extractNameFromCanonical(sd.url)})`);
+  const baseName = Path5.join(pkgPath, name);
+  return {
+    filename: baseName,
+    // HACK: for some reason ID may change between CI and local install
+    genContent: () => JSON.stringify({ ...sd, id: void 0 }, null, pretty ? 2 : void 0)
+  };
+};
+var IntrospectionWriter = class extends FileSystemWriter {
+  async generate(tsIndex) {
+    this.logger()?.info(`IntrospectionWriter: Begin`);
+    if (this.opts.typeTree) {
+      await this.writeTypeTree(tsIndex);
+      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);
+      } else {
+        this.writeJsonFiles(
+          typeSchemas.map((ts) => typeSchemaToJson(ts, true)),
+          outputPath
+        );
+      }
+      this.logger()?.info(
+        `IntrospectionWriter: ${typeSchemas.length} TypeSchema written to ${this.opts.typeSchemas}`
+      );
+    }
+    if (this.opts.fhirSchemas && tsIndex.register) {
+      const outputPath = this.opts.fhirSchemas;
+      const fhirSchemas = tsIndex.register.allFs();
+      if (Path5.extname(outputPath) === ".ndjson") {
+        this.writeNdjson(fhirSchemas, outputPath, fhirSchemaToJson);
+      } else {
+        this.writeJsonFiles(
+          fhirSchemas.map((fs7) => fhirSchemaToJson(fs7, true)),
+          outputPath
+        );
+      }
+      this.logger()?.info(`IntrospectionWriter: ${fhirSchemas.length} FHIR schema written to ${outputPath}`);
+    }
+    if (this.opts.structureDefinitions && tsIndex.register) {
+      const outputPath = this.opts.structureDefinitions;
+      const structureDefinitions = tsIndex.register.allSd();
+      if (Path5.extname(outputPath) === ".ndjson") {
+        this.writeNdjson(structureDefinitions, outputPath, structureDefinitionToJson);
+      } else {
+        this.writeJsonFiles(
+          structureDefinitions.map((sd) => structureDefinitionToJson(sd, true)),
+          outputPath
+        );
+      }
+      this.logger()?.info(
+        `IntrospectionWriter: ${structureDefinitions.length} StructureDefinitions written to ${outputPath}`
+      );
+    }
+  }
+  async writeNdjson(items, outputFile, toJson) {
+    this.cd(Path5.dirname(outputFile), () => {
+      this.cat(Path5.basename(outputFile), () => {
+        for (const item of items) {
+          const { genContent } = toJson(item, false);
+          this.write(`${genContent()}
+`);
+        }
+      });
+    });
+  }
+  async writeJsonFiles(items, outputDir) {
+    this.cd(outputDir, () => {
+      for (const { filename, genContent } of items) {
+        const fileName = `${filename}.json`;
+        this.cd(Path5.dirname(fileName), () => {
+          this.cat(Path5.basename(fileName), () => {
+            this.write(genContent());
+          });
+        });
+      }
+    });
+  }
+  async writeTypeTree(tsIndex) {
+    const filename = this.opts.typeTree;
+    if (!filename) return;
+    const tree = tsIndex.entityTree();
+    const raw = filename.endsWith(".yaml") ? YAML__default.stringify(tree) : JSON.stringify(tree, void 0, 2);
+    const dir = Path5.dirname(filename);
+    const file = Path5.basename(filename);
+    this.cd(dir, () => {
+      this.cat(file, () => {
+        this.write(raw);
+      });
+    });
+  }
+};
+
+// 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");
+  }
+  if (report.treeShake?.skippedPackages.length) {
+    lines.push("## Skipped Packages", "");
+    for (const pkg of report.treeShake.skippedPackages) {
+      lines.push(`- ${pkg}`);
+    }
+    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}\``);
+      }
+      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("");
+      }
+    }
+  }
+  return lines.join("\n");
+};
+
+// src/api/writer-generator/ir-report.ts
+var IrReportWriterWriter = class extends FileSystemWriter {
+  async generate(tsIndex) {
+    const report = tsIndex.irReport();
+    const md = generateIrReportReadme(report);
+    this.cd("/", () => {
+      this.cat(this.opts.rootReadmeFileName, () => {
+        this.write(md);
+      });
+    });
+  }
 };
 
 // src/api/mustache/generator/DebugMixinProvider.ts
@@ -2570,7 +3190,7 @@ var TemplateFileCache = class {
   templateBaseDir;
   templateCache = {};
   constructor(templateBaseDir) {
-    this.templateBaseDir = Path__default.resolve(templateBaseDir);
+    this.templateBaseDir = Path5__default.resolve(templateBaseDir);
   }
   _normalizeName(name) {
     if (name.endsWith(".mustache")) {
@@ -2585,7 +3205,7 @@ var TemplateFileCache = class {
     const normalizedName = this._normalizeName(name);
     if (!this.templateCache[normalizedName]) {
       this.templateCache[normalizedName] = fs__default.readFileSync(
-        Path__default.join(this.templateBaseDir, normalizedName),
+        Path5__default.join(this.templateBaseDir, normalizedName),
         "utf-8"
       );
     }
@@ -2912,7 +3532,7 @@ var ViewModelFactory = class {
   }
 };
 function loadMustacheGeneratorConfig(templatePath, logger) {
-  const filePath = Path.resolve(templatePath, "config.json");
+  const filePath = Path5.resolve(templatePath, "config.json");
   try {
     const raw = fs.readFileSync(filePath, "utf-8");
     const parsed = JSON.parse(raw);
@@ -2950,21 +3570,21 @@ var createGenerator = (templatePath, apiOpts) => {
     ...apiOpts,
     ...actualFileOpts,
     sources: {
-      staticSource: Path.resolve(templatePath, "static"),
-      templateSource: Path.resolve(templatePath, "templates")
+      staticSource: Path5.resolve(templatePath, "static"),
+      templateSource: Path5.resolve(templatePath, "templates")
     }
   };
   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}`));
     });
   });
@@ -3002,7 +3622,7 @@ var MustacheGenerator = class extends FileSystemWriter {
     return;
   }
   copyStaticFiles() {
-    const staticDir = Path.resolve(this.opts.sources.staticSource);
+    const staticDir = Path5.resolve(this.opts.sources.staticSource);
     if (!staticDir) {
       throw new Error("staticDir must be set in subclass.");
     }
@@ -3112,13 +3732,15 @@ var tsFhirPackageDir = (name) => {
   return kebabCase(name);
 };
 var tsModuleName = (id) => {
-  if (id.kind === "profile") return `${tsResourceName(id)}_profile`;
-  return pascalCase(id.name);
+  return uppercaseFirstLetter(normalizeTsName(id.name));
 };
 var tsModuleFileName = (id) => {
   return `${tsModuleName(id)}.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) => {
@@ -3146,7 +3768,7 @@ var tsFieldName = (n) => {
 };
 var normalizeTsName = (n) => {
   if (tsKeywords.has(n)) n = `${n}_`;
-  return n.replace(/[- ]/g, "_");
+  return n.replace(/\[x\]/g, "_x_").replace(/[- :]/g, "_");
 };
 var tsGet = (object, tsFieldName2) => {
   if (tsFieldName2.startsWith('"')) return `${object}[${tsFieldName2}]`;
@@ -3155,42 +3777,114 @@ var tsGet = (object, tsFieldName2) => {
 var tsEnumType = (enumValues) => {
   return `(${enumValues.map((e) => `"${e}"`).join(" | ")})`;
 };
+var tsTypeFromIdentifier = (id) => {
+  if (isNestedIdentifier(id)) return tsResourceName(id);
+  if (isPrimitiveIdentifier(id)) return resolvePrimitiveType(id.name);
+  const primitiveType = primitiveType2tsType[id.name];
+  if (primitiveType !== void 0) return primitiveType;
+  return id.name;
+};
+var tsProfileClassName = (id) => {
+  return `${uppercaseFirstLetter(normalizeTsName(id.name))}Profile`;
+};
+var tsSliceInputTypeName = (profileName, fieldName, sliceName) => {
+  return `${uppercaseFirstLetter(profileName)}_${uppercaseFirstLetter(normalizeTsName(fieldName))}_${uppercaseFirstLetter(normalizeTsName(sliceName))}SliceInput`;
+};
+var tsExtensionInputTypeName = (profileName, extensionName) => {
+  return `${uppercaseFirstLetter(profileName)}_${uppercaseFirstLetter(normalizeTsName(extensionName))}Input`;
+};
+var safeCamelCase = (name) => {
+  if (!name) return "";
+  const normalized = name.replace(/\[x\]/g, "").replace(/:/g, "_");
+  return camelCase(normalized);
+};
+var tsSliceMethodName = (sliceName) => {
+  const normalized = safeCamelCase(sliceName);
+  return `set${uppercaseFirstLetter(normalized || "Slice")}`;
+};
+var tsExtensionMethodName = (name) => {
+  const normalized = safeCamelCase(name);
+  return `set${uppercaseFirstLetter(normalized || "Extension")}`;
+};
+var tsExtensionMethodFallback = (name, path) => {
+  const rawPath = path?.split(".").filter((p) => p && p !== "extension").join("_") ?? "";
+  const pathPart = rawPath ? uppercaseFirstLetter(safeCamelCase(rawPath)) : "";
+  const normalized = safeCamelCase(name);
+  return `setExtension${pathPart}${uppercaseFirstLetter(normalized || "Extension")}`;
+};
+var tsSliceMethodFallback = (fieldName, sliceName) => {
+  const fieldPart = uppercaseFirstLetter(safeCamelCase(fieldName) || "Field");
+  const slicePart = uppercaseFirstLetter(safeCamelCase(sliceName) || "Slice");
+  return `setSlice${fieldPart}${slicePart}`;
+};
 var TypeScript = class extends Writer {
   tsImportType(tsPackageName, ...entities) {
     this.lineSM(`import type { ${entities.join(", ")} } from "${tsPackageName}"`);
   }
+  generateProfileIndexFile(profiles) {
+    if (profiles.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;
+        });
+        if (uniqueProfiles.length === 0) return;
+        for (const profile of uniqueProfiles) {
+          const className = tsProfileClassName(profile.identifier);
+          this.lineSM(`export { ${className} } from "./${tsModuleName(profile.identifier)}"`);
+        }
+      });
+    });
+  }
   generateFhirPackageIndexFile(schemas) {
     this.cat("index.ts", () => {
-      let exports = schemas.flatMap((schema) => [
-        {
-          identifier: schema.identifier,
-          tsPackageName: tsModuleName(schema.identifier),
-          resourceName: tsResourceName(schema.identifier),
-          nestedTypes: isResourceTypeSchema(schema) && schema.nested || isLogicalTypeSchema(schema) && schema.nested ? schema.nested.map((n) => tsResourceName(n.identifier)) : [],
-          helpers: isResourceTypeSchema(schema) || isLogicalTypeSchema(schema) ? [`is${tsResourceName(schema.identifier)}`] : []
-        }
-      ]).sort((a, b) => a.resourceName.localeCompare(b.resourceName));
+      const profiles = schemas.filter(isProfileTypeSchema);
+      if (profiles.length > 0) {
+        this.lineSM(`export * from "./profiles"`);
+      }
+      let exports = schemas.flatMap((schema) => {
+        const resourceName = tsResourceName(schema.identifier);
+        const typeExports = isProfileTypeSchema(schema) ? [] : [
+          resourceName,
+          ...isResourceTypeSchema(schema) && schema.nested || isLogicalTypeSchema(schema) && schema.nested ? schema.nested.map((n) => tsResourceName(n.identifier)) : []
+        ];
+        const valueExports = isResourceTypeSchema(schema) ? [`is${resourceName}`] : [];
+        return [
+          {
+            identifier: schema.identifier,
+            tsPackageName: tsModuleName(schema.identifier),
+            resourceName,
+            typeExports,
+            valueExports
+          }
+        ];
+      }).sort((a, b) => a.resourceName.localeCompare(b.resourceName));
       exports = Array.from(new Map(exports.map((exp) => [exp.resourceName.toLowerCase(), exp])).values()).sort(
         (a, b) => a.resourceName.localeCompare(b.resourceName)
       );
       for (const exp of exports) {
         this.debugComment(exp.identifier);
-        this.lineSM(
-          `export type { ${[exp.resourceName, ...exp.nestedTypes].join(", ")} } from "./${exp.tsPackageName}"`
-        );
-        if (exp.helpers.length > 0)
-          this.lineSM(`export { ${exp.helpers.join(", ")} } from "./${exp.tsPackageName}"`);
+        if (exp.typeExports.length > 0) {
+          this.lineSM(`export type { ${exp.typeExports.join(", ")} } from "./${exp.tsPackageName}"`);
+        }
+        if (exp.valueExports.length > 0) {
+          this.lineSM(`export { ${exp.valueExports.join(", ")} } from "./${exp.tsPackageName}"`);
+        }
       }
     });
   }
-  generateDependenciesImports(tsIndex, schema) {
+  generateDependenciesImports(tsIndex, schema, importPrefix = "../") {
     if (schema.dependencies) {
       const imports = [];
       const skipped = [];
       for (const dep of schema.dependencies) {
         if (["complex-type", "resource", "logical"].includes(dep.kind)) {
           imports.push({
-            tsPackage: `../${tsModulePath(dep)}`,
+            tsPackage: `${importPrefix}${tsModulePath(dep)}`,
             name: uppercaseFirstLetter(dep.name),
             dep
           });
@@ -3198,7 +3892,7 @@ var TypeScript = class extends Writer {
           const ndep = { ...dep };
           ndep.name = canonicalToName3(dep.url);
           imports.push({
-            tsPackage: `../${tsModulePath(ndep)}`,
+            tsPackage: `${importPrefix}${tsModulePath(ndep)}`,
             name: tsResourceName(dep),
             dep
           });
@@ -3219,7 +3913,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.tsImportType(`../${tsModulePath(element.identifier)}`, "Element");
+        this.tsImportType(`${importPrefix}${tsModulePath(element.identifier)}`, "Element");
       }
     }
   }
@@ -3256,7 +3950,7 @@ var TypeScript = class extends Writer {
       return;
     }
     this.curlyBlock(["export", "interface", name, extendsClause], () => {
-      if (isResourceTypeSchema(schema) || isLogicalTypeSchema(schema)) {
+      if (isResourceTypeSchema(schema)) {
         const possibleResourceTypes = [schema.identifier];
         possibleResourceTypes.push(...tsIndex.resourceChildren(schema.identifier));
         const openSetSuffix = this.opts.openResourceTypeSet && possibleResourceTypes.length > 1 ? " | string" : "";
@@ -3307,7 +4001,7 @@ var TypeScript = class extends Writer {
     return false;
   }
   generateResourceTypePredicate(schema) {
-    if (!isResourceTypeSchema(schema) && !isLogicalTypeSchema(schema)) return;
+    if (!isResourceTypeSchema(schema)) return;
     const name = tsResourceName(schema.identifier);
     this.curlyBlock(["export", "const", `is${name}`, "=", `(resource: unknown): resource is ${name}`, "=>"], () => {
       this.lineSM(
@@ -3323,6 +4017,45 @@ var TypeScript = class extends Writer {
       }
     }
   }
+  tsTypeForProfileField(tsIndex, flatProfile, fieldName, field) {
+    if (!isNotChoiceDeclarationField(field)) {
+      throw new Error(`Choice declaration fields not supported for '${fieldName}'`);
+    }
+    if (field.enum) {
+      return tsEnumType(field.enum);
+    }
+    if (field.reference && field.reference.length > 0) {
+      const specialization = tsIndex.findLastSpecialization(flatProfile);
+      if (!isSpecializationTypeSchema(specialization))
+        throw new Error(`Invalid specialization for ${flatProfile.identifier}`);
+      const sField = specialization.fields?.[fieldName];
+      if (sField === void 0 || isChoiceDeclarationField(sField) || sField.reference === void 0)
+        throw new Error(`Invalid field declaration for ${fieldName}`);
+      const sRefs = sField.reference.map((e) => e.name);
+      const references = field.reference.map((ref) => {
+        const resRef = tsIndex.findLastSpecializationByIdentifier(ref);
+        if (resRef.name !== ref.name) {
+          return `"${resRef.name}" /*${ref.name}*/`;
+        }
+        return `'${ref.name}'`;
+      }).join(" | ");
+      if (sRefs.length === 1 && sRefs[0] === "Resource" && references !== '"Resource"') {
+        const cleanRefs = references.replace(/\/\*[^*]*\*\//g, "").trim();
+        return `Reference<"Resource" /* ${cleanRefs} */ >`;
+      }
+      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) {
+      throw new Error(`Undefined type for '${fieldName}' field at ${typeSchemaInfo(flatProfile)}`);
+    }
+    return field.type.name;
+  }
   generateProfileType(tsIndex, flatProfile) {
     this.debugComment("flatProfile", flatProfile);
     const tsName = tsResourceName(flatProfile.identifier);
@@ -3335,38 +4068,7 @@ var TypeScript = class extends Writer {
         if (isChoiceDeclarationField(field)) continue;
         this.debugComment(fieldName, field);
         const tsName2 = tsFieldName(fieldName);
-        let tsType;
-        if (field.enum) {
-          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}`);
-          const sField = specialization.fields?.[fieldName];
-          if (sField === void 0 || isChoiceDeclarationField(sField) || sField.reference === void 0)
-            throw new Error(`Invalid field declaration for ${fieldName}`);
-          const sRefs = sField.reference.map((e) => e.name);
-          const references = field.reference.map((ref) => {
-            const resRef = tsIndex.findLastSpecializationByIdentifier(ref);
-            if (resRef.name !== ref.name) {
-              return `"${resRef.name}" /*${ref.name}*/`;
-            }
-            return `'${ref.name}'`;
-          }).join(" | ");
-          if (sRefs.length === 1 && sRefs[0] === "Resource" && references !== '"Resource"') {
-            tsType = `Reference<"Resource" /* ${references} */ >`;
-          } else {
-            tsType = `Reference<${references}>`;
-          }
-        } else if (isNestedIdentifier(field.type)) {
-          tsType = tsResourceName(field.type);
-        } else if (isPrimitiveIdentifier(field.type)) {
-          tsType = resolvePrimitiveType(field.type.name);
-        } else if (field.type === void 0) {
-          throw new Error(`Undefined type for '${fieldName}' field at ${typeSchemaInfo(flatProfile)}`);
-        } else {
-          tsType = field.type.name;
-        }
+        const tsType = this.tsTypeForProfileField(tsIndex, flatProfile, fieldName, field);
         this.lineSM(`${tsName2}${!field.required ? "?" : ""}: ${tsType}${field.array ? "[]" : ""}`);
       }
     });
@@ -3473,41 +4175,769 @@ var TypeScript = class extends Writer {
       }
     );
   }
-  generateResourceModule(tsIndex, schema) {
-    this.cat(`${tsModuleFileName(schema.identifier)}`, () => {
+  generateProfileHelpersModule() {
+    this.cat("profile-helpers.ts", () => {
       this.generateDisclaimer();
-      if (["complex-type", "resource", "logical"].includes(schema.identifier.kind)) {
+      this.curlyBlock(
+        ["export const", "isRecord", "=", "(value: unknown): value is Record<string, unknown>", "=>"],
+        () => {
+          this.lineSM('return value !== null && typeof value === "object" && !Array.isArray(value)');
+        }
+      );
+      this.line();
+      this.curlyBlock(
+        [
+          "export const",
+          "getOrCreateObjectAtPath",
+          "=",
+          "(root: Record<string, unknown>, path: string[]): Record<string, unknown>",
+          "=>"
+        ],
+        () => {
+          this.lineSM("let current: Record<string, unknown> = root");
+          this.curlyBlock(["for (const", "segment", "of", "path)"], () => {
+            this.curlyBlock(["if", "(Array.isArray(current[segment]))"], () => {
+              this.lineSM("const list = current[segment] as unknown[]");
+              this.curlyBlock(["if", "(list.length === 0)"], () => {
+                this.lineSM("list.push({})");
+              });
+              this.lineSM("current = list[0] as Record<string, unknown>");
+            });
+            this.curlyBlock(["else"], () => {
+              this.curlyBlock(["if", "(!isRecord(current[segment]))"], () => {
+                this.lineSM("current[segment] = {}");
+              });
+              this.lineSM("current = current[segment] as Record<string, unknown>");
+            });
+          });
+          this.lineSM("return current");
+        }
+      );
+      this.line();
+      this.curlyBlock(
+        [
+          "export const",
+          "mergeMatch",
+          "=",
+          "(target: Record<string, unknown>, match: Record<string, unknown>): void",
+          "=>"
+        ],
+        () => {
+          this.curlyBlock(["for (const", "[key, matchValue]", "of", "Object.entries(match))"], () => {
+            this.curlyBlock(
+              ["if", '(key === "__proto__" || key === "constructor" || key === "prototype")'],
+              () => {
+                this.lineSM("continue");
+              }
+            );
+            this.curlyBlock(["if", "(isRecord(matchValue))"], () => {
+              this.curlyBlock(["if", "(isRecord(target[key]))"], () => {
+                this.lineSM("mergeMatch(target[key] as Record<string, unknown>, matchValue)");
+              });
+              this.curlyBlock(["else"], () => {
+                this.lineSM("target[key] = { ...matchValue }");
+              });
+            });
+            this.curlyBlock(["else"], () => {
+              this.lineSM("target[key] = matchValue");
+            });
+          });
+        }
+      );
+      this.line();
+      this.curlyBlock(
+        [
+          "export const",
+          "applySliceMatch",
+          "=",
+          "<T extends Record<string, unknown>>(input: T, match: Record<string, unknown>): T",
+          "=>"
+        ],
+        () => {
+          this.lineSM("const result = { ...input } as Record<string, unknown>");
+          this.lineSM("mergeMatch(result, match)");
+          this.lineSM("return result as T");
+        }
+      );
+      this.line();
+      this.curlyBlock(
+        ["export const", "matchesValue", "=", "(value: unknown, match: unknown): boolean", "=>"],
+        () => {
+          this.curlyBlock(["if", "(Array.isArray(match))"], () => {
+            this.curlyBlock(["if", "(!Array.isArray(value))"], () => this.lineSM("return false"));
+            this.lineSM(
+              "return match.every((matchItem) => value.some((item) => matchesValue(item, matchItem)))"
+            );
+          });
+          this.curlyBlock(["if", "(isRecord(match))"], () => {
+            this.curlyBlock(["if", "(!isRecord(value))"], () => this.lineSM("return false"));
+            this.curlyBlock(["for (const", "[key, matchValue]", "of", "Object.entries(match))"], () => {
+              this.curlyBlock(
+                ["if", "(!matchesValue((value as Record<string, unknown>)[key], matchValue))"],
+                () => {
+                  this.lineSM("return false");
+                }
+              );
+            });
+            this.lineSM("return true");
+          });
+          this.lineSM("return value === match");
+        }
+      );
+      this.line();
+      this.curlyBlock(
+        [
+          "export const",
+          "matchesSlice",
+          "=",
+          "(value: unknown, match: Record<string, unknown>): boolean",
+          "=>"
+        ],
+        () => {
+          this.lineSM("return matchesValue(value, match)");
+        }
+      );
+      this.line();
+      this.curlyBlock(
+        [
+          "export const",
+          "extractComplexExtension",
+          "=",
+          "(extension: { extension?: Array<{ url?: string; [key: string]: unknown }> } | undefined, config: Array<{ name: string; valueField: string; isArray: boolean }>): Record<string, unknown> | undefined",
+          "=>"
+        ],
+        () => {
+          this.lineSM("if (!extension?.extension) return undefined");
+          this.lineSM("const result: Record<string, unknown> = {}");
+          this.curlyBlock(["for (const", "{ name, valueField, isArray }", "of", "config)"], () => {
+            this.lineSM("const subExts = extension.extension.filter(e => e.url === name)");
+            this.curlyBlock(["if", "(isArray)"], () => {
+              this.lineSM("result[name] = subExts.map(e => (e as Record<string, unknown>)[valueField])");
+            });
+            this.curlyBlock(["else if", "(subExts[0])"], () => {
+              this.lineSM("result[name] = (subExts[0] as Record<string, unknown>)[valueField]");
+            });
+          });
+          this.lineSM("return result");
+        }
+      );
+      this.line();
+      this.curlyBlock(
+        [
+          "export const",
+          "extractSliceSimplified",
+          "=",
+          "<T extends Record<string, unknown>>(slice: T, matchKeys: string[]): Partial<T>",
+          "=>"
+        ],
+        () => {
+          this.lineSM("const result = { ...slice } as Record<string, unknown>");
+          this.curlyBlock(["for (const", "key", "of", "matchKeys)"], () => {
+            this.lineSM("delete result[key]");
+          });
+          this.lineSM("return result as Partial<T>");
+        }
+      );
+    });
+  }
+  generateProfileHelpersImport(options) {
+    const imports = [];
+    if (options.needsSliceHelpers) {
+      imports.push("applySliceMatch", "matchesSlice");
+    }
+    if (options.needsGetOrCreateObjectAtPath) {
+      imports.push("getOrCreateObjectAtPath");
+    }
+    if (options.needsExtensionExtraction) {
+      imports.push("extractComplexExtension");
+    }
+    if (options.needsSliceExtraction) {
+      imports.push("extractSliceSimplified");
+    }
+    if (imports.length > 0) {
+      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)) {
+      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);
+      }
+    }
+    const extensions = flatProfile.extensions ?? [];
+    let needsExtensionType = false;
+    for (const ext of 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);
+            }
+          }
+        }
+      } else if (ext.valueTypes && ext.valueTypes.length === 1) {
+        needsExtensionType = true;
+        const valueType = ext.valueTypes[0];
+        if (valueType) {
+          addType(valueType);
+        }
+      } 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);
+      }
+    }
+    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);
+          }
+        }
+      }
+    }
+    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();
+    }
+  }
+  generateProfileClass(tsIndex, flatProfile) {
+    const tsBaseResourceName = tsTypeFromIdentifier(flatProfile.base);
+    const tsProfileName = tsResourceName(flatProfile.identifier);
+    const profileClassName = tsProfileClassName(flatProfile.identifier);
+    const polymorphicBaseNames = /* @__PURE__ */ new Set([
+      "value",
+      "effective",
+      "onset",
+      "abatement",
+      "occurrence",
+      "timing",
+      "deceased",
+      "born",
+      "age",
+      "medication",
+      "performed",
+      "serviced",
+      "collected",
+      "item",
+      "subject",
+      "bounds",
+      "amount",
+      "content",
+      "product",
+      "rate",
+      "dose",
+      "asNeeded"
+    ]);
+    const sliceDefs = Object.entries(flatProfile.fields ?? {}).filter(([_fieldName, field]) => isNotChoiceDeclarationField(field) && field.slicing?.slices).flatMap(([fieldName, field]) => {
+      if (!isNotChoiceDeclarationField(field) || !field.slicing?.slices || !field.type) return [];
+      const baseType = tsTypeFromIdentifier(field.type);
+      return Object.entries(field.slicing.slices).filter(([_sliceName, slice]) => {
+        const match = slice.match ?? {};
+        return Object.keys(match).length > 0;
+      }).map(([sliceName, slice]) => {
+        const matchFields = Object.keys(slice.match ?? {});
+        const required = slice.required ?? [];
+        const filteredRequired = required.filter(
+          (name) => !matchFields.includes(name) && !polymorphicBaseNames.has(name)
+        );
+        return {
+          fieldName,
+          baseType,
+          sliceName,
+          match: slice.match ?? {},
+          required,
+          excluded: slice.excluded ?? [],
+          array: Boolean(field.array),
+          // Input is optional when there are no required fields after filtering
+          inputOptional: filteredRequired.length === 0
+        };
+      });
+    });
+    const extensions = flatProfile.extensions ?? [];
+    const complexExtensions = extensions.filter((ext) => ext.isComplex && ext.subExtensions);
+    for (const ext of complexExtensions) {
+      const typeName = tsExtensionInputTypeName(tsProfileName, ext.name);
+      this.curlyBlock(["export", "type", typeName, "="], () => {
+        for (const sub of ext.subExtensions ?? []) {
+          const tsType = sub.valueType ? tsTypeFromIdentifier(sub.valueType) : "unknown";
+          const isArray = sub.max === "*";
+          const isRequired2 = sub.min !== void 0 && sub.min > 0;
+          this.lineSM(`${sub.name}${isRequired2 ? "" : "?"}: ${tsType}${isArray ? "[]" : ""}`);
+        }
+      });
+      this.line();
+    }
+    if (sliceDefs.length > 0) {
+      for (const sliceDef of sliceDefs) {
+        const typeName = tsSliceInputTypeName(tsProfileName, sliceDef.fieldName, sliceDef.sliceName);
+        const matchFields = Object.keys(sliceDef.match);
+        const allExcluded = [.../* @__PURE__ */ new Set([...sliceDef.excluded, ...matchFields])];
+        const excludedNames = allExcluded.map((name) => JSON.stringify(name));
+        const filteredRequired = sliceDef.required.filter(
+          (name) => !matchFields.includes(name) && !polymorphicBaseNames.has(name)
+        );
+        const requiredNames = filteredRequired.map((name) => JSON.stringify(name));
+        let typeExpr = sliceDef.baseType;
+        if (excludedNames.length > 0) {
+          typeExpr = `Omit<${typeExpr}, ${excludedNames.join(" | ")}>`;
+        }
+        if (requiredNames.length > 0) {
+          typeExpr = `${typeExpr} & Required<Pick<${sliceDef.baseType}, ${requiredNames.join(" | ")}>>`;
+        }
+        this.lineSM(`export type ${typeName} = ${typeExpr}`);
+      }
+      this.line();
+    }
+    const needsSliceHelpers = sliceDefs.length > 0;
+    const extensionsWithNestedPath = extensions.filter((ext) => {
+      const targetPath = ext.path.split(".").filter((segment) => segment !== "extension");
+      return targetPath.length > 0;
+    });
+    const needsGetOrCreateObjectAtPath = extensionsWithNestedPath.length > 0;
+    const needsExtensionExtraction = complexExtensions.length > 0;
+    const needsSliceExtraction = sliceDefs.length > 0;
+    if (needsSliceHelpers || needsGetOrCreateObjectAtPath || needsExtensionExtraction || needsSliceExtraction) {
+      this.generateProfileHelpersImport({
+        needsGetOrCreateObjectAtPath,
+        needsSliceHelpers,
+        needsExtensionExtraction,
+        needsSliceExtraction
+      });
+      this.line();
+    }
+    const hasOverrideInterface = this.detectFieldOverrides(tsIndex, flatProfile).size > 0;
+    this.curlyBlock(["export", "class", profileClassName], () => {
+      this.line(`private resource: ${tsBaseResourceName}`);
+      this.line();
+      this.curlyBlock(["constructor", `(resource: ${tsBaseResourceName})`], () => {
+        this.line("this.resource = resource");
+      });
+      this.line();
+      this.curlyBlock(["toResource", "()", `: ${tsBaseResourceName}`], () => {
+        this.line("return this.resource");
+      });
+      this.line();
+      if (hasOverrideInterface) {
+        this.curlyBlock(["toProfile", "()", `: ${tsProfileName}`], () => {
+          this.line(`return this.resource as ${tsProfileName}`);
+        });
+        this.line();
+      }
+      const extensionMethods = extensions.filter((ext) => ext.url).map((ext) => ({
+        ext,
+        baseName: tsExtensionMethodName(ext.name),
+        fallbackName: tsExtensionMethodFallback(ext.name, ext.path)
+      }));
+      const sliceMethodBases = sliceDefs.map((slice) => tsSliceMethodName(slice.sliceName));
+      const methodCounts = /* @__PURE__ */ new Map();
+      for (const name of [...sliceMethodBases, ...extensionMethods.map((m) => m.baseName)]) {
+        methodCounts.set(name, (methodCounts.get(name) ?? 0) + 1);
+      }
+      const extensionMethodNames = new Map(
+        extensionMethods.map((entry) => [
+          entry.ext,
+          (methodCounts.get(entry.baseName) ?? 0) > 1 ? entry.fallbackName : entry.baseName
+        ])
+      );
+      const sliceMethodNames = new Map(
+        sliceDefs.map((slice) => {
+          const baseName = tsSliceMethodName(slice.sliceName);
+          const needsFallback = (methodCounts.get(baseName) ?? 0) > 1;
+          const fallback = tsSliceMethodFallback(slice.fieldName, slice.sliceName);
+          return [slice, needsFallback ? fallback : baseName];
+        })
+      );
+      for (const ext of extensions) {
+        if (!ext.url) continue;
+        const methodName = extensionMethodNames.get(ext) ?? tsExtensionMethodFallback(ext.name, ext.path);
+        const valueTypes = ext.valueTypes ?? [];
+        const targetPath = ext.path.split(".").filter((segment) => segment !== "extension");
+        if (ext.isComplex && ext.subExtensions) {
+          const inputTypeName = tsExtensionInputTypeName(tsProfileName, ext.name);
+          this.curlyBlock(["public", methodName, `(input: ${inputTypeName}): this`], () => {
+            this.line("const subExtensions: Extension[] = []");
+            for (const sub of ext.subExtensions ?? []) {
+              const valueField = sub.valueType ? `value${uppercaseFirstLetter(sub.valueType.name)}` : "value";
+              const needsCast = !sub.valueType;
+              const pushSuffix = needsCast ? " as Extension" : "";
+              if (sub.max === "*") {
+                this.curlyBlock(["if", `(input.${sub.name})`], () => {
+                  this.curlyBlock(["for", `(const item of input.${sub.name})`], () => {
+                    this.line(
+                      `subExtensions.push({ url: "${sub.url}", ${valueField}: item }${pushSuffix})`
+                    );
+                  });
+                });
+              } else {
+                this.curlyBlock(["if", `(input.${sub.name} !== undefined)`], () => {
+                  this.line(
+                    `subExtensions.push({ url: "${sub.url}", ${valueField}: input.${sub.name} }${pushSuffix})`
+                  );
+                });
+              }
+            }
+            if (targetPath.length === 0) {
+              this.line("const list = (this.resource.extension ??= [])");
+              this.line(`list.push({ url: "${ext.url}", extension: subExtensions })`);
+            } else {
+              this.line(
+                `const target = getOrCreateObjectAtPath(this.resource as unknown as Record<string, unknown>, ${JSON.stringify(targetPath)})`
+              );
+              this.line("if (!Array.isArray(target.extension)) target.extension = [] as Extension[]");
+              this.line(
+                `(target.extension as Extension[]).push({ url: "${ext.url}", extension: subExtensions })`
+              );
+            }
+            this.line("return this");
+          });
+        } else if (valueTypes.length === 1 && valueTypes[0]) {
+          const firstValueType = valueTypes[0];
+          const valueType = tsTypeFromIdentifier(firstValueType);
+          const valueField = `value${uppercaseFirstLetter(firstValueType.name)}`;
+          this.curlyBlock(["public", methodName, `(value: ${valueType}): this`], () => {
+            if (targetPath.length === 0) {
+              this.line("const list = (this.resource.extension ??= [])");
+              this.line(`list.push({ url: "${ext.url}", ${valueField}: value })`);
+            } else {
+              this.line(
+                `const target = getOrCreateObjectAtPath(this.resource as unknown as Record<string, unknown>, ${JSON.stringify(
+                  targetPath
+                )})`
+              );
+              this.line("if (!Array.isArray(target.extension)) target.extension = [] as Extension[]");
+              this.line(
+                `(target.extension as Extension[]).push({ url: "${ext.url}", ${valueField}: value })`
+              );
+            }
+            this.line("return this");
+          });
+        } else {
+          this.curlyBlock(["public", methodName, `(value: Omit<Extension, "url">): this`], () => {
+            if (targetPath.length === 0) {
+              this.line("const list = (this.resource.extension ??= [])");
+              this.line(`list.push({ url: "${ext.url}", ...value })`);
+            } else {
+              this.line(
+                `const target = getOrCreateObjectAtPath(this.resource as unknown as Record<string, unknown>, ${JSON.stringify(
+                  targetPath
+                )})`
+              );
+              this.line("if (!Array.isArray(target.extension)) target.extension = [] as Extension[]");
+              this.line(`(target.extension as Extension[]).push({ url: "${ext.url}", ...value })`);
+            }
+            this.line("return this");
+          });
+        }
+        this.line();
+      }
+      for (const sliceDef of sliceDefs) {
+        const methodName = sliceMethodNames.get(sliceDef) ?? tsSliceMethodFallback(sliceDef.fieldName, sliceDef.sliceName);
+        const typeName = tsSliceInputTypeName(tsProfileName, sliceDef.fieldName, sliceDef.sliceName);
+        const matchLiteral = JSON.stringify(sliceDef.match);
+        const tsField = tsFieldName(sliceDef.fieldName);
+        const fieldAccess = tsGet("this.resource", tsField);
+        const paramSignature = sliceDef.inputOptional ? `(input?: ${typeName}): this` : `(input: ${typeName}): this`;
+        this.curlyBlock(["public", methodName, paramSignature], () => {
+          this.line(`const match = ${matchLiteral} as Record<string, unknown>`);
+          const inputExpr = sliceDef.inputOptional ? "(input ?? {}) as Record<string, unknown>" : "input as Record<string, unknown>";
+          this.line(`const value = applySliceMatch(${inputExpr}, match) as unknown as ${sliceDef.baseType}`);
+          if (sliceDef.array) {
+            this.line(`const list = (${fieldAccess} ??= [])`);
+            this.line("const index = list.findIndex((item) => matchesSlice(item, match))");
+            this.line("if (index === -1) {");
+            this.indentBlock(() => {
+              this.line("list.push(value)");
+            });
+            this.line("} else {");
+            this.indentBlock(() => {
+              this.line("list[index] = value");
+            });
+            this.line("}");
+          } else {
+            this.line(`${fieldAccess} = value`);
+          }
+          this.line("return this");
+        });
+        this.line();
+      }
+      const generatedGetMethods = /* @__PURE__ */ new Set();
+      for (const ext of extensions) {
+        if (!ext.url) continue;
+        const baseName = uppercaseFirstLetter(safeCamelCase(ext.name));
+        const getMethodName = `get${baseName}`;
+        const getExtensionMethodName = `get${baseName}Extension`;
+        if (generatedGetMethods.has(getMethodName)) continue;
+        generatedGetMethods.add(getMethodName);
+        const valueTypes = ext.valueTypes ?? [];
+        const targetPath = ext.path.split(".").filter((segment) => segment !== "extension");
+        const generateExtLookup = () => {
+          if (targetPath.length === 0) {
+            this.line(`const ext = this.resource.extension?.find(e => e.url === "${ext.url}")`);
+          } else {
+            this.line(
+              `const target = getOrCreateObjectAtPath(this.resource as unknown as Record<string, unknown>, ${JSON.stringify(targetPath)})`
+            );
+            this.line(
+              `const ext = (target.extension as Extension[] | undefined)?.find(e => e.url === "${ext.url}")`
+            );
+          }
+        };
+        if (ext.isComplex && ext.subExtensions) {
+          const inputTypeName = tsExtensionInputTypeName(tsProfileName, ext.name);
+          this.curlyBlock(["public", getMethodName, `(): ${inputTypeName} | undefined`], () => {
+            generateExtLookup();
+            this.line("if (!ext) return undefined");
+            const configItems = (ext.subExtensions ?? []).map((sub) => {
+              const valueField = sub.valueType ? `value${uppercaseFirstLetter(sub.valueType.name)}` : "value";
+              const isArray = sub.max === "*";
+              return `{ name: "${sub.url}", valueField: "${valueField}", isArray: ${isArray} }`;
+            });
+            this.line(`const config = [${configItems.join(", ")}]`);
+            this.line(
+              `return extractComplexExtension(ext as unknown as { extension?: Array<{ url?: string; [key: string]: unknown }> }, config) as ${inputTypeName}`
+            );
+          });
+          this.line();
+          this.curlyBlock(["public", getExtensionMethodName, "(): Extension | undefined"], () => {
+            generateExtLookup();
+            this.line("return ext");
+          });
+        } else if (valueTypes.length === 1 && valueTypes[0]) {
+          const firstValueType = valueTypes[0];
+          const valueType = tsTypeFromIdentifier(firstValueType);
+          const valueField = `value${uppercaseFirstLetter(firstValueType.name)}`;
+          this.curlyBlock(["public", getMethodName, `(): ${valueType} | undefined`], () => {
+            generateExtLookup();
+            this.line(`return ext?.${valueField}`);
+          });
+          this.line();
+          this.curlyBlock(["public", getExtensionMethodName, "(): Extension | undefined"], () => {
+            generateExtLookup();
+            this.line("return ext");
+          });
+        } else {
+          this.curlyBlock(["public", getMethodName, "(): Extension | undefined"], () => {
+            if (targetPath.length === 0) {
+              this.line(`return this.resource.extension?.find(e => e.url === "${ext.url}")`);
+            } else {
+              this.line(
+                `const target = getOrCreateObjectAtPath(this.resource as unknown as Record<string, unknown>, ${JSON.stringify(targetPath)})`
+              );
+              this.line(
+                `return (target.extension as Extension[] | undefined)?.find(e => e.url === "${ext.url}")`
+              );
+            }
+          });
+        }
+        this.line();
+      }
+      for (const sliceDef of sliceDefs) {
+        const baseName = uppercaseFirstLetter(safeCamelCase(sliceDef.sliceName));
+        const getMethodName = `get${baseName}`;
+        const getRawMethodName = `get${baseName}Raw`;
+        if (generatedGetMethods.has(getMethodName)) continue;
+        generatedGetMethods.add(getMethodName);
+        const typeName = tsSliceInputTypeName(tsProfileName, sliceDef.fieldName, sliceDef.sliceName);
+        const matchLiteral = JSON.stringify(sliceDef.match);
+        const matchKeys = JSON.stringify(Object.keys(sliceDef.match));
+        const tsField = tsFieldName(sliceDef.fieldName);
+        const fieldAccess = tsGet("this.resource", tsField);
+        const baseType = sliceDef.baseType;
+        const generateSliceLookup = () => {
+          this.line(`const match = ${matchLiteral} as Record<string, unknown>`);
+          if (sliceDef.array) {
+            this.line(`const list = ${fieldAccess}`);
+            this.line("if (!list) return undefined");
+            this.line("const item = list.find((item) => matchesSlice(item, match))");
+          } else {
+            this.line(`const item = ${fieldAccess}`);
+            this.line("if (!item || !matchesSlice(item, match)) return undefined");
+          }
+        };
+        this.curlyBlock(["public", getMethodName, `(): ${typeName} | undefined`], () => {
+          generateSliceLookup();
+          if (sliceDef.array) {
+            this.line("if (!item) return undefined");
+          }
+          this.line(
+            `return extractSliceSimplified(item as unknown as Record<string, unknown>, ${matchKeys}) as ${typeName}`
+          );
+        });
+        this.line();
+        this.curlyBlock(["public", getRawMethodName, `(): ${baseType} | undefined`], () => {
+          generateSliceLookup();
+          if (sliceDef.array) {
+            this.line("return item");
+          } else {
+            this.line("return item");
+          }
+        });
+        this.line();
+      }
+    });
+    this.line();
+  }
+  /**
+   * Detects fields where the profile changes cardinality or narrows Reference types
+   * compared to the base resource type.
+   */
+  detectFieldOverrides(tsIndex, flatProfile) {
+    const overrides = /* @__PURE__ */ new Map();
+    const specialization = tsIndex.findLastSpecialization(flatProfile);
+    if (!isSpecializationTypeSchema(specialization)) return overrides;
+    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) {
+        const references = pField.reference.map((ref) => {
+          const resRef = tsIndex.findLastSpecializationByIdentifier(ref);
+          if (resRef.name !== ref.name) {
+            return `"${resRef.name}"`;
+          }
+          return `"${ref.name}"`;
+        }).join(" | ");
+        overrides.set(fieldName, {
+          profileType: `Reference<${references}>`,
+          required: pField.required ?? false,
+          array: pField.array ?? false
+        });
+      } else if (pField.required && !sField.required) {
+        const tsType = this.tsTypeForProfileField(tsIndex, flatProfile, fieldName, pField);
+        overrides.set(fieldName, {
+          profileType: tsType,
+          required: true,
+          array: pField.array ?? false
+        });
+      }
+    }
+    return overrides;
+  }
+  /**
+   * Generates an override interface for profiles that narrow cardinality or Reference types.
+   * Example: export interface USCorePatient extends Patient { subject: Reference<"Patient"> }
+   */
+  generateProfileOverrideInterface(tsIndex, flatProfile) {
+    const overrides = this.detectFieldOverrides(tsIndex, flatProfile);
+    if (overrides.size === 0) return;
+    const tsProfileName = tsResourceName(flatProfile.identifier);
+    const tsBaseResourceName = tsResourceName(flatProfile.base);
+    this.curlyBlock(["export", "interface", tsProfileName, "extends", tsBaseResourceName], () => {
+      for (const [fieldName, override] of overrides) {
+        const tsField = tsFieldName(fieldName);
+        const optionalSymbol = override.required ? "" : "?";
+        const arraySymbol = override.array ? "[]" : "";
+        this.lineSM(`${tsField}${optionalSymbol}: ${override.profileType}${arraySymbol}`);
+      }
+    });
+    this.line();
+  }
+  generateResourceModule(tsIndex, schema) {
+    if (isProfileTypeSchema(schema)) {
+      this.cd("profiles", () => {
+        this.cat(`${tsModuleFileName(schema.identifier)}`, () => {
+          this.generateDisclaimer();
+          const flatProfile = tsIndex.flatProfile(schema);
+          this.generateProfileImports(tsIndex, flatProfile);
+          this.comment(
+            "CanonicalURL:",
+            schema.identifier.url,
+            `(pkg: ${packageMetaToFhir(packageMeta(schema))})`
+          );
+          this.generateProfileOverrideInterface(tsIndex, flatProfile);
+          this.generateProfileClass(tsIndex, flatProfile);
+        });
+      });
+    } else if (["complex-type", "resource", "logical"].includes(schema.identifier.kind)) {
+      this.cat(`${tsModuleFileName(schema.identifier)}`, () => {
+        this.generateDisclaimer();
         this.generateDependenciesImports(tsIndex, schema);
         this.generateComplexTypeReexports(schema);
         this.generateNestedTypes(tsIndex, schema);
-        this.comment("CanonicalURL:", schema.identifier.url);
+        this.comment(
+          "CanonicalURL:",
+          schema.identifier.url,
+          `(pkg: ${packageMetaToFhir(packageMeta(schema))})`
+        );
         this.generateType(tsIndex, schema);
         this.generateResourceTypePredicate(schema);
-      } else if (isProfileTypeSchema(schema)) {
-        const flatProfile = tsIndex.flatProfile(schema);
-        this.generateDependenciesImports(tsIndex, flatProfile);
-        this.comment("CanonicalURL:", schema.identifier.url);
-        this.generateProfileType(tsIndex, flatProfile);
-        this.generateAttachProfile(flatProfile);
-        this.generateExtractProfile(tsIndex, flatProfile);
-      } else throw new Error(`Profile generation not implemented for kind: ${schema.identifier.kind}`);
-    });
+      });
+    } else {
+      throw new Error(`Profile generation not implemented for kind: ${schema.identifier.kind}`);
+    }
   }
   async generate(tsIndex) {
     const typesToGenerate = [
       ...tsIndex.collectComplexTypes(),
       ...tsIndex.collectResources(),
       ...tsIndex.collectLogicalModels(),
-      ...this.opts.generateProfile ? tsIndex.collectProfiles().filter((p) => tsIndex.isWithMetaField(p)) : []
+      ...this.opts.generateProfile ? tsIndex.collectProfiles() : []
     ];
     const grouped = groupByPackages(typesToGenerate);
+    const hasProfiles = this.opts.generateProfile && typesToGenerate.some(isProfileTypeSchema);
     this.cd("/", () => {
+      if (hasProfiles) {
+        this.generateProfileHelpersModule();
+      }
       for (const [packageName, packageSchemas] of Object.entries(grouped)) {
         const tsPackageDir = tsFhirPackageDir(packageName);
         this.cd(tsPackageDir, () => {
           for (const schema of packageSchemas) {
             this.generateResourceModule(tsIndex, schema);
           }
+          this.generateProfileIndexFile(packageSchemas.filter(isProfileTypeSchema));
           this.generateFhirPackageIndexFile(packageSchemas);
         });
       }
@@ -3516,13 +4946,18 @@ var TypeScript = class extends Writer {
 };
 
 // src/api/builder.ts
+function countLinesByMatches(text) {
+  if (text === "") return 0;
+  const m = text.match(/\n/g);
+  return m ? m.length + 1 : 1;
+}
 var prettyReport = (report) => {
   const { success, filesGenerated, errors, warnings, duration } = report;
   const errorsStr = errors.length > 0 ? `Errors: ${errors.join(", ")}` : void 0;
   const warningsStr = warnings.length > 0 ? `Warnings: ${warnings.join(", ")}` : void 0;
   let allLoc = 0;
   const files = Object.entries(filesGenerated).map(([path, content]) => {
-    const loc = content.split("\n").length;
+    const loc = countLinesByMatches(content);
     allLoc += loc;
     return `  - ${path} (${loc} loc)`;
   }).join("\n");
@@ -3535,128 +4970,64 @@ var prettyReport = (report) => {
     `Status: ${success ? "\u{1F7E9} Success" : "\u{1F7E5} Failure"}`
   ].filter((e) => e).join("\n");
 };
-var normalizeFileName = (str) => {
-  const res = str.replace(/[^a-zA-Z0-9\-_.@#()]/g, "");
-  if (res.length === 0) return "unknown";
-  return res;
-};
 var cleanup = async (opts, logger) => {
   logger.info(`Cleaning outputs...`);
   try {
     logger.info(`Clean ${opts.outputDir}`);
     fs.rmSync(opts.outputDir, { recursive: true, force: true });
-    if (opts.typeSchemaOutputDir) {
-      logger.info(`Clean ${opts.typeSchemaOutputDir}`);
-      fs.rmSync(opts.typeSchemaOutputDir, {
-        recursive: true,
-        force: true
-      });
-    }
-    if (opts.exportTypeTree) {
-      logger.info(`Clean ${opts.exportTypeTree}`);
-      fs.rmSync(opts.exportTypeTree, {
-        recursive: true,
-        force: true
-      });
-    }
   } catch (error) {
     logger.warn(`Error cleaning output directory: ${error instanceof Error ? error.message : String(error)}`);
   }
 };
-var writeTypeSchemasToSeparateFiles = async (typeSchemas, outputDir, logger) => {
-  await afs2.mkdir(outputDir, { recursive: true });
-  logger.info(`Writing TypeSchema files to ${outputDir}/...`);
-  const files = {};
-  for (const ts of typeSchemas) {
-    const pkg = {
-      name: ts.identifier.package,
-      version: ts.identifier.version
-    };
-    const pkgPath = normalizeFileName(packageMetaToFhir(pkg));
-    const name = normalizeFileName(`${ts.identifier.name}(${extractNameFromCanonical(ts.identifier.url)})`);
-    const json = JSON.stringify(ts, null, 2);
-    const baseName = Path.join(outputDir, pkgPath, name);
-    if (!files[baseName]) files[baseName] = [];
-    if (!files[baseName]?.some((e) => e === json)) {
-      files[baseName].push(json);
-    }
-  }
-  for (const [baseName, jsons] of Object.entries(files)) {
-    await Promise.all(
-      jsons.map(async (json, index) => {
-        let fullName;
-        if (index === 0) {
-          fullName = `${baseName}.typeschema.json`;
-        } else {
-          fullName = `${baseName}-${index}.typeschema.json`;
-        }
-        await afs2.mkdir(Path.dirname(fullName), { recursive: true });
-        await afs2.writeFile(fullName, json);
-      })
-    );
-  }
-};
-var writeTypeSchemasToSingleFile = async (typeSchemas, outputFile, logger) => {
-  logger.info(`Writing TypeSchema files to: ${outputFile}`);
-  await afs2.mkdir(Path.dirname(outputFile), { recursive: true });
-  logger.info(`Writing TypeSchemas to one file ${outputFile}...`);
-  for (const ts of typeSchemas) {
-    const json = JSON.stringify(ts, null, 2);
-    await afs2.appendFile(outputFile, `${json}
-`);
-  }
-};
-var tryWriteTypeSchema = async (typeSchemas, opts, logger) => {
-  if (!opts.typeSchemaOutputDir) return;
-  try {
-    if (Path.extname(opts.typeSchemaOutputDir) === ".ndjson") {
-      await writeTypeSchemasToSingleFile(typeSchemas, opts.typeSchemaOutputDir, logger);
-    } else {
-      await writeTypeSchemasToSeparateFiles(typeSchemas, opts.typeSchemaOutputDir, logger);
-    }
-    logger.info(`Writing TypeSchema - DONE`);
-  } catch (error) {
-    logger.error("Failed to write TypeSchema output", error instanceof Error ? error : new Error(String(error)));
-    if (opts.throwException) throw error;
-  }
-};
 var APIBuilder = class {
-  schemas = [];
   options;
-  generators = /* @__PURE__ */ new Map();
+  manager;
+  prebuiltRegister;
+  managerInput;
   logger;
-  packages = [];
-  localStructurePackages = [];
-  localTgzArchives = [];
-  progressCallback;
-  typeSchemaConfig;
-  constructor(options = {}) {
-    this.options = {
-      outputDir: options.outputDir || "./generated",
-      overwrite: options.overwrite ?? true,
-      cache: options.cache ?? true,
-      cleanOutput: options.cleanOutput ?? true,
-      typeSchemaConfig: options.typeSchemaConfig,
-      manager: options.manager || null,
-      throwException: options.throwException || false,
-      typeSchemaOutputDir: options.typeSchemaOutputDir,
-      exportTypeTree: options.exportTypeTree,
-      treeShake: options.treeShake,
-      registry: options.registry
+  generators = [];
+  constructor(userOpts = {}) {
+    const defaultOpts = {
+      outputDir: "./generated",
+      cleanOutput: true,
+      throwException: false,
+      treeShake: void 0,
+      promoteLogical: void 0,
+      registry: void 0,
+      logLevel: parseLogLevel("INFO")
     };
-    this.typeSchemaConfig = options.typeSchemaConfig;
-    this.logger = options.logger || createLogger({
-      prefix: "API",
-      level: options.logLevel
+    const opts = {
+      ...defaultOpts,
+      ...Object.fromEntries(
+        Object.entries(userOpts).filter(
+          ([k, v]) => v !== void 0 && k !== "manager" && k !== "register" && k !== "logger"
+        )
+      )
+    };
+    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({
+      packages: [],
+      workingDir: ".codegen-cache/canonical-manager-cache",
+      registry: userOpts.registry
     });
+    this.logger = userOpts.logger ?? createLogger({ prefix: "API", level: opts.logLevel });
+    this.options = opts;
   }
   fromPackage(packageName, version) {
     const pkg = packageMetaToNpm({ name: packageName, version: version || "latest" });
-    this.packages.push(pkg);
+    this.managerInput.npmPackages.push(pkg);
     return this;
   }
   fromPackageRef(packageRef) {
-    this.packages.push(packageRef);
+    this.managerInput.npmPackages.push(packageRef);
     return this;
   }
   /**
@@ -3668,22 +5039,39 @@ var APIBuilder = class {
     return this;
   }
   localStructureDefinitions(config) {
-    this.localStructurePackages.push(config);
+    this.logger.info(`Registering local StructureDefinitions for ${config.package.name}@${config.package.version}`);
+    this.managerInput.localSDs.push({
+      name: config.package.name,
+      version: config.package.version,
+      path: config.path,
+      dependencies: config.dependencies?.map((dep) => packageMetaToNpm(dep))
+    });
     return this;
   }
   localTgzPackage(archivePath) {
-    this.localTgzArchives.push(Path.resolve(archivePath));
+    this.logger.info(`Registering local tgz package: ${archivePath}`);
+    this.managerInput.localTgzPackages.push({ archivePath: Path5.resolve(archivePath) });
     return this;
   }
-  fromSchemas(schemas) {
-    this.logger.debug(`Adding ${schemas.length} TypeSchemas to generation`);
-    this.schemas = [...this.schemas, ...schemas];
+  introspection(userOpts) {
+    const defaultWriterOpts = {
+      logger: this.logger,
+      outputDir: this.options.outputDir,
+      inMemoryOnly: false
+    };
+    const opts = {
+      ...defaultWriterOpts,
+      ...Object.fromEntries(Object.entries(userOpts ?? {}).filter(([_, v]) => v !== void 0))
+    };
+    const writer = new IntrospectionWriter(opts);
+    this.generators.push({ name: "introspection", writer });
+    this.logger.debug(`Configured introspection generator (${JSON.stringify(opts, void 0, 2)})`);
     return this;
   }
   typescript(userOpts) {
     const defaultWriterOpts = {
       logger: this.logger,
-      outputDir: Path.join(this.options.outputDir, "/types"),
+      outputDir: Path5.join(this.options.outputDir, "/types"),
       tabSize: 4,
       withDebugComment: false,
       commentLinePrefix: "//",
@@ -3699,7 +5087,7 @@ var APIBuilder = class {
       ...Object.fromEntries(Object.entries(userOpts).filter(([_, v]) => v !== void 0))
     };
     const generator = new TypeScript(opts);
-    this.generators.set("typescript", generator);
+    this.generators.push({ name: "typescript", writer: generator });
     this.logger.debug(`Configured TypeScript generator (${JSON.stringify(opts, void 0, 2)})`);
     return this;
   }
@@ -3721,7 +5109,7 @@ var APIBuilder = class {
       ...Object.fromEntries(Object.entries(userOptions).filter(([_, v]) => v !== void 0))
     };
     const generator = new Python(opts);
-    this.generators.set("python", generator);
+    this.generators.push({ name: "python", writer: generator });
     this.logger.debug(`Configured python generator`);
     return this;
   }
@@ -3742,14 +5130,14 @@ var APIBuilder = class {
       ...userOpts
     };
     const generator = createGenerator(templatePath, opts);
-    this.generators.set(`mustache[${templatePath}]`, generator);
+    this.generators.push({ name: `mustache[${templatePath}]`, writer: generator });
     this.logger.debug(`Configured TypeScript generator (${JSON.stringify(opts, void 0, 2)})`);
     return this;
   }
   csharp(userOptions) {
     const defaultWriterOpts = {
       logger: this.logger,
-      outputDir: Path.join(this.options.outputDir, "/types"),
+      outputDir: Path5.join(this.options.outputDir, "/types"),
       tabSize: 4,
       withDebugComment: false,
       commentLinePrefix: "//"
@@ -3763,25 +5151,18 @@ var APIBuilder = class {
       ...Object.fromEntries(Object.entries(userOptions).filter(([_, v]) => v !== void 0))
     };
     const generator = new CSharp(opts);
-    this.generators.set("csharp", generator);
+    this.generators.push({ name: "csharp", writer: generator });
     this.logger.debug(`Configured C# generator`);
     return this;
   }
-  /**
-   * Set a progress callback for monitoring generation
-   */
-  onProgress(callback) {
-    this.progressCallback = callback;
-    return this;
-  }
   /**
    * Set the output directory for all generators
    */
   outputTo(directory) {
     this.logger.debug(`Setting output directory: ${directory}`);
     this.options.outputDir = directory;
-    for (const generator of this.generators.values()) {
-      generator.setOutputDir(directory);
+    for (const gen of this.generators) {
+      gen.writer.setOutputDir(directory);
     }
     return this;
   }
@@ -3797,16 +5178,32 @@ var APIBuilder = class {
     this.options.cleanOutput = enabled;
     return this;
   }
-  writeTypeTree(filename) {
-    this.options.exportTypeTree = filename;
-    return this;
-  }
-  treeShake(tree) {
-    this.options.treeShake = tree;
+  typeSchema(cfg) {
+    if (cfg.treeShake) {
+      assert3(this.options.treeShake === void 0, "treeShake option is already set");
+      this.options.treeShake = cfg.treeShake;
+    }
+    if (cfg.promoteLogical) {
+      assert3(this.options.promoteLogical === void 0, "promoteLogical option is already set");
+      this.options.promoteLogical = cfg.promoteLogical;
+    }
+    this.irReport({});
     return this;
   }
-  writeTypeSchemas(target) {
-    this.options.typeSchemaOutputDir = target;
+  irReport(userOpts) {
+    const defaultWriterOpts = {
+      logger: this.logger,
+      outputDir: this.options.outputDir,
+      inMemoryOnly: false
+    };
+    const opts = {
+      ...defaultWriterOpts,
+      rootReadmeFileName: "README.md",
+      ...Object.fromEntries(Object.entries(userOpts ?? {}).filter(([_, v]) => v !== void 0))
+    };
+    const writer = new IrReportWriterWriter(opts);
+    this.generators.push({ name: "ir-report", writer });
+    this.logger.debug(`Configured ir-report generator (${JSON.stringify(opts, void 0, 2)})`);
     return this;
   }
   async generate() {
@@ -3819,48 +5216,40 @@ var APIBuilder = class {
       warnings: [],
       duration: 0
     };
-    this.logger.debug(`Starting generation with ${this.generators.size} generators`);
+    this.logger.debug(`Starting generation with ${this.generators.length} generators`);
     try {
       if (this.options.cleanOutput) cleanup(this.options, this.logger);
-      this.logger.info("Initialize Canonical Manager");
-      const manager = this.options.manager || CanonicalManager({
-        packages: this.packages,
-        workingDir: ".codegen-cache/canonical-manager-cache",
-        registry: this.options.registry || void 0
-      });
-      if (this.localStructurePackages.length > 0) {
-        for (const config of this.localStructurePackages) {
-          this.logger.info(
-            `Registering local StructureDefinitions for ${config.package.name}@${config.package.version}`
-          );
-          await manager.addLocalPackage({
-            name: config.package.name,
-            version: config.package.version,
-            path: config.path,
-            dependencies: config.dependencies?.map((dep) => packageMetaToNpm(dep))
-          });
+      let register;
+      if (this.prebuiltRegister) {
+        this.logger.info("Using prebuilt register");
+        register = this.prebuiltRegister;
+      } else {
+        this.logger.info("Initialize Canonical Manager");
+        if (this.managerInput.npmPackages.length > 0) {
+          await this.manager.addPackages(...this.managerInput.npmPackages.sort());
         }
+        for (const config of this.managerInput.localSDs) {
+          await this.manager.addLocalPackage(config);
+        }
+        for (const tgzArchive of this.managerInput.localTgzPackages) {
+          await this.manager.addTgzPackage(tgzArchive);
+        }
+        const ref2meta = await this.manager.init();
+        const packageMetas = Object.values(ref2meta);
+        register = await registerFromManager(this.manager, {
+          logger: this.logger,
+          focusedPackages: packageMetas
+        });
       }
-      for (const archivePath of this.localTgzArchives) {
-        this.logger.info(`Registering local tgz package: ${archivePath}`);
-        await manager.addTgzPackage({ archivePath });
-      }
-      const ref2meta = await manager.init();
-      const packageMetas = Object.values(ref2meta);
-      const register = await registerFromManager(manager, {
-        logger: this.logger,
-        focusedPackages: packageMetas
-      });
       const typeSchemas = await generateTypeSchemas(register, this.logger);
-      await tryWriteTypeSchema(typeSchemas, this.options, this.logger);
       const tsIndexOpts = {
-        resolutionTree: register.resolutionTree(),
+        register,
         logger: this.logger
       };
       let tsIndex = mkTypeSchemaIndex(typeSchemas, tsIndexOpts);
-      if (this.options.treeShake) tsIndex = treeShake(tsIndex, this.options.treeShake, tsIndexOpts);
-      if (this.options.exportTypeTree) await tsIndex.exportTree(this.options.exportTypeTree);
-      this.logger.debug(`Executing ${this.generators.size} generators`);
+      if (this.options.treeShake) tsIndex = treeShake(tsIndex, this.options.treeShake);
+      if (this.options.promoteLogical) tsIndex = promoteLogical(tsIndex, this.options.promoteLogical);
+      this.logger.debug(`Executing ${this.generators.length} generators`);
       await this.executeGenerators(result, tsIndex);
       this.logger.info("Generation completed successfully");
       result.success = result.errors.length === 0;
@@ -3880,559 +5269,35 @@ var APIBuilder = class {
    * Clear all configuration and start fresh
    */
   reset() {
-    this.schemas = [];
-    this.generators.clear();
-    this.progressCallback = void 0;
-    this.packages = [];
-    this.localStructurePackages = [];
-    this.localTgzArchives = [];
+    this.generators = [];
     return this;
   }
-  /**
-   * Get loaded schemas (for inspection)
-   */
-  getSchemas() {
-    return [...this.schemas];
-  }
   /**
    * Get configured generators (for inspection)
    */
   getGenerators() {
-    return Array.from(this.generators.keys());
+    return this.generators.map((g) => g.name);
   }
   async executeGenerators(result, tsIndex) {
-    for (const [type, generator] of this.generators.entries()) {
-      this.logger.info(`Generating ${type}...`);
+    for (const gen of this.generators) {
+      this.logger.info(`Generating ${gen.name}...`);
       try {
-        await generator.generate(tsIndex);
-        const fileBuffer = generator.writtenFiles();
+        await gen.writer.generateAsync(tsIndex);
+        const fileBuffer = gen.writer.writtenFiles();
         fileBuffer.forEach((buf) => {
           result.filesGenerated[buf.relPath] = buf.content;
         });
-        this.logger.info(`Generating ${type} finished successfully`);
+        this.logger.info(`Generating ${gen.name} finished successfully`);
       } catch (error) {
         result.errors.push(
-          `${type} generator failed: ${error instanceof Error ? error.message : String(error)}`
+          `${gen.name} generator failed: ${error instanceof Error ? error.message : String(error)}`
         );
         if (this.options.throwException) throw error;
       }
     }
   }
 };
-var DEFAULT_CONFIG = {
-  outputDir: "./generated",
-  verbose: false,
-  overwrite: true,
-  validate: true,
-  cache: true,
-  cleanOutput: true,
-  registry: "",
-  typescript: {
-    moduleFormat: "esm",
-    generateIndex: true,
-    includeDocuments: false,
-    namingConvention: "PascalCase",
-    strictMode: true,
-    includeProfiles: true,
-    includeExtensions: false,
-    includeCodeSystems: false,
-    includeOperations: false,
-    generateValueSets: false,
-    valueSetDirectory: "valuesets",
-    valueSetMode: "required-only",
-    valueSetStrengths: ["required"],
-    includeValueSetHelpers: false,
-    fhirVersion: "R4",
-    resourceTypes: [],
-    maxDepth: 10,
-    // Profile generation defaults
-    profileOptions: {
-      generateKind: "interface",
-      includeConstraints: true,
-      includeDocumentation: true,
-      strictMode: false,
-      subfolder: "profiles"
-    },
-    // Builder generation defaults
-    generateBuilders: false,
-    builderOptions: {
-      includeValidation: true,
-      includeFactoryMethods: true,
-      includeInterfaces: true,
-      generateNestedBuilders: true,
-      includeHelperMethods: true,
-      supportPartialBuild: true,
-      includeJSDoc: true,
-      generateFactories: true,
-      includeTypeGuards: true,
-      handleChoiceTypes: true,
-      generateArrayHelpers: true
-    },
-    // Validator generation defaults
-    validatorOptions: {
-      includeCardinality: true,
-      includeTypes: true,
-      includeConstraints: true,
-      includeInvariants: false,
-      validateRequired: true,
-      allowAdditional: false,
-      strictValidation: false,
-      collectMetrics: false,
-      generateAssertions: true,
-      generatePartialValidators: true,
-      optimizePerformance: true,
-      includeJSDoc: true,
-      generateCompositeValidators: true
-    },
-    // Type guard generation defaults
-    guardOptions: {
-      includeRuntimeValidation: true,
-      includeErrorMessages: true,
-      treeShakeable: true,
-      targetTSVersion: "5.0",
-      strictGuards: false,
-      includeNullChecks: true,
-      verbose: false
-    }
-  },
-  typeSchema: {
-    enablePersistence: true,
-    cacheDir: ".typeschema-cache",
-    maxAge: 24 * 60 * 60 * 1e3,
-    // 24 hours in milliseconds
-    validateCached: true,
-    forceRegenerate: false,
-    shareCache: true,
-    cacheKeyPrefix: "",
-    treeshake: [],
-    singleFile: false,
-    profiles: {
-      autoDetect: true
-    }
-  },
-  packages: [],
-  files: [],
-  $schema: ""
-};
-var CONFIG_FILE_NAMES = [
-  "atomic-codegen.config.ts",
-  "atomic-codegen.config",
-  "atomic-codegen.config.json",
-  ".atomic-codegenrc",
-  "atomic-codegen.json",
-  ".atomic-codegen.json",
-  "codegen.config.json",
-  "codegen.json"
-];
-var ConfigValidator = class {
-  /**
-   * Validate a configuration object
-   */
-  validate(config) {
-    const result = {
-      valid: true,
-      errors: [],
-      warnings: []
-    };
-    if (!config || typeof config !== "object") {
-      result.valid = false;
-      result.errors.push({
-        path: "root",
-        message: "Configuration must be an object",
-        value: config
-      });
-      return result;
-    }
-    const cfg = config;
-    if (cfg.outputDir !== void 0 && typeof cfg.outputDir !== "string") {
-      result.errors.push({
-        path: "outputDir",
-        message: "outputDir must be a string",
-        value: cfg.outputDir
-      });
-    }
-    const booleanFields = ["verbose", "overwrite", "validate", "cache"];
-    for (const field of booleanFields) {
-      if (cfg[field] !== void 0 && typeof cfg[field] !== "boolean") {
-        result.errors.push({
-          path: field,
-          message: `${field} must be a boolean`,
-          value: cfg[field]
-        });
-      }
-    }
-    if (cfg.typescript !== void 0) {
-      const tsErrors = this.validateTypeScriptConfig(cfg.typescript);
-      result.errors.push(...tsErrors);
-    }
-    if (cfg.typeSchema !== void 0) {
-      const tsErrors = this.validateTypeSchemaConfig(cfg.typeSchema);
-      result.errors.push(...tsErrors);
-    }
-    if (cfg.packages !== void 0) {
-      if (!Array.isArray(cfg.packages)) {
-        result.errors.push({
-          path: "packages",
-          message: "packages must be an array",
-          value: cfg.packages
-        });
-      } else {
-        cfg.packages.forEach((pkg, index) => {
-          if (typeof pkg !== "string") {
-            result.errors.push({
-              path: `packages[${index}]`,
-              message: "package name must be a string",
-              value: pkg
-            });
-          }
-        });
-      }
-    }
-    if (cfg.files !== void 0) {
-      if (!Array.isArray(cfg.files)) {
-        result.errors.push({
-          path: "files",
-          message: "files must be an array",
-          value: cfg.files
-        });
-      } else {
-        cfg.files.forEach((file, index) => {
-          if (typeof file !== "string") {
-            result.errors.push({
-              path: `files[${index}]`,
-              message: "file path must be a string",
-              value: file
-            });
-          }
-        });
-      }
-    }
-    result.valid = result.errors.length === 0;
-    if (result.valid) {
-      result.config = cfg;
-    }
-    return result;
-  }
-  validateTypeScriptConfig(config) {
-    const errors = [];
-    if (typeof config !== "object" || config === null) {
-      errors.push({
-        path: "typescript",
-        message: "typescript config must be an object",
-        value: config
-      });
-      return errors;
-    }
-    const cfg = config;
-    if (cfg.moduleFormat !== void 0) {
-      if (!["esm", "cjs"].includes(cfg.moduleFormat)) {
-        errors.push({
-          path: "typescript.moduleFormat",
-          message: 'moduleFormat must be "esm" or "cjs"',
-          value: cfg.moduleFormat
-        });
-      }
-    }
-    if (cfg.namingConvention !== void 0) {
-      if (!["PascalCase", "camelCase"].includes(cfg.namingConvention)) {
-        errors.push({
-          path: "typescript.namingConvention",
-          message: 'namingConvention must be "PascalCase" or "camelCase"',
-          value: cfg.namingConvention
-        });
-      }
-    }
-    const booleanFields = [
-      "generateIndex",
-      "includeDocuments",
-      "strictMode",
-      "includeProfiles",
-      "includeExtensions",
-      "includeCodeSystems",
-      "includeOperations",
-      "generateValueSets",
-      "includeValueSetHelpers"
-    ];
-    for (const field of booleanFields) {
-      if (cfg[field] !== void 0 && typeof cfg[field] !== "boolean") {
-        errors.push({
-          path: `typescript.${field}`,
-          message: `${field} must be a boolean`,
-          value: cfg[field]
-        });
-      }
-    }
-    if (cfg.validatorOptions !== void 0) {
-      const validatorErrors = this.validateValidatorOptions(cfg.validatorOptions);
-      errors.push(...validatorErrors);
-    }
-    if (cfg.guardOptions !== void 0) {
-      const guardErrors = this.validateGuardOptions(cfg.guardOptions);
-      errors.push(...guardErrors);
-    }
-    if (cfg.profileOptions !== void 0) {
-      const profileErrors = this.validateProfileOptions(cfg.profileOptions);
-      errors.push(...profileErrors);
-    }
-    return errors;
-  }
-  validateValidatorOptions(config) {
-    const errors = [];
-    if (typeof config !== "object" || config === null) {
-      errors.push({
-        path: "typescript.validatorOptions",
-        message: "validatorOptions must be an object",
-        value: config
-      });
-      return errors;
-    }
-    const cfg = config;
-    const booleanFields = [
-      "includeCardinality",
-      "includeTypes",
-      "includeConstraints",
-      "includeInvariants",
-      "validateRequired",
-      "allowAdditional",
-      "strictValidation",
-      "collectMetrics",
-      "generateAssertions",
-      "generatePartialValidators",
-      "optimizePerformance",
-      "includeJSDoc",
-      "generateCompositeValidators"
-    ];
-    for (const field of booleanFields) {
-      if (cfg[field] !== void 0 && typeof cfg[field] !== "boolean") {
-        errors.push({
-          path: `typescript.validatorOptions.${field}`,
-          message: `${field} must be a boolean`,
-          value: cfg[field]
-        });
-      }
-    }
-    return errors;
-  }
-  validateGuardOptions(config) {
-    const errors = [];
-    if (typeof config !== "object" || config === null) {
-      errors.push({
-        path: "typescript.guardOptions",
-        message: "guardOptions must be an object",
-        value: config
-      });
-      return errors;
-    }
-    const cfg = config;
-    if (cfg.targetTSVersion !== void 0) {
-      if (!["3.8", "4.0", "4.5", "5.0"].includes(cfg.targetTSVersion)) {
-        errors.push({
-          path: "typescript.guardOptions.targetTSVersion",
-          message: 'targetTSVersion must be one of: "3.8", "4.0", "4.5", "5.0"',
-          value: cfg.targetTSVersion
-        });
-      }
-    }
-    const booleanFields = [
-      "includeRuntimeValidation",
-      "includeErrorMessages",
-      "treeShakeable",
-      "strictGuards",
-      "includeNullChecks",
-      "verbose"
-    ];
-    for (const field of booleanFields) {
-      if (cfg[field] !== void 0 && typeof cfg[field] !== "boolean") {
-        errors.push({
-          path: `typescript.guardOptions.${field}`,
-          message: `${field} must be a boolean`,
-          value: cfg[field]
-        });
-      }
-    }
-    return errors;
-  }
-  validateProfileOptions(config) {
-    const errors = [];
-    if (typeof config !== "object" || config === null) {
-      errors.push({
-        path: "typescript.profileOptions",
-        message: "profileOptions must be an object",
-        value: config
-      });
-      return errors;
-    }
-    const cfg = config;
-    if (cfg.generateKind !== void 0) {
-      if (!["interface", "type", "both"].includes(cfg.generateKind)) {
-        errors.push({
-          path: "typescript.profileOptions.generateKind",
-          message: 'generateKind must be "interface", "type", or "both"',
-          value: cfg.generateKind
-        });
-      }
-    }
-    if (cfg.subfolder !== void 0 && typeof cfg.subfolder !== "string") {
-      errors.push({
-        path: "typescript.profileOptions.subfolder",
-        message: "subfolder must be a string",
-        value: cfg.subfolder
-      });
-    }
-    const booleanFields = ["includeConstraints", "includeDocumentation", "strictMode"];
-    for (const field of booleanFields) {
-      if (cfg[field] !== void 0 && typeof cfg[field] !== "boolean") {
-        errors.push({
-          path: `typescript.profileOptions.${field}`,
-          message: `${field} must be a boolean`,
-          value: cfg[field]
-        });
-      }
-    }
-    return errors;
-  }
-  validateTypeSchemaConfig(config) {
-    const errors = [];
-    if (typeof config !== "object" || config === null) {
-      errors.push({
-        path: "typeSchema",
-        message: "typeSchema config must be an object",
-        value: config
-      });
-      return errors;
-    }
-    const cfg = config;
-    const booleanFields = ["enablePersistence", "validateCached", "forceRegenerate", "shareCache"];
-    for (const field of booleanFields) {
-      if (cfg[field] !== void 0 && typeof cfg[field] !== "boolean") {
-        errors.push({
-          path: `typeSchema.${field}`,
-          message: `${field} must be a boolean`,
-          value: cfg[field]
-        });
-      }
-    }
-    const stringFields = ["cacheDir", "cacheKeyPrefix"];
-    for (const field of stringFields) {
-      if (cfg[field] !== void 0 && typeof cfg[field] !== "string") {
-        errors.push({
-          path: `typeSchema.${field}`,
-          message: `${field} must be a string`,
-          value: cfg[field]
-        });
-      }
-    }
-    if (cfg.maxAge !== void 0) {
-      if (typeof cfg.maxAge !== "number" || cfg.maxAge <= 0) {
-        errors.push({
-          path: "typeSchema.maxAge",
-          message: "maxAge must be a positive number",
-          value: cfg.maxAge
-        });
-      }
-    }
-    if (cfg.profiles !== void 0) {
-      if (typeof cfg.profiles !== "object" || cfg.profiles === null) {
-        errors.push({
-          path: "typeSchema.profiles",
-          message: "profiles must be an object",
-          value: cfg.profiles
-        });
-      } else {
-        const profiles = cfg.profiles;
-        if (profiles.autoDetect !== void 0 && typeof profiles.autoDetect !== "boolean") {
-          errors.push({
-            path: "typeSchema.profiles.autoDetect",
-            message: "autoDetect must be a boolean",
-            value: profiles.autoDetect
-          });
-        }
-      }
-    }
-    return errors;
-  }
-};
-var ConfigLoader = class {
-  validator = new ConfigValidator();
-  /**
-   * Auto-load configuration from the current working directory
-   */
-  async autoload(workingDir = process.cwd()) {
-    const configPath = await this.findConfigFile(workingDir);
-    if (configPath) {
-      return this.loadFromFile(configPath);
-    }
-    return { ...DEFAULT_CONFIG };
-  }
-  /**
-   * Load configuration from a specific file
-   */
-  async loadFromFile(filePath) {
-    try {
-      let config;
-      if (filePath.endsWith(".ts") || filePath.endsWith("")) {
-        const absolutePath = resolve(filePath);
-        const importResult = await import(absolutePath);
-        config = importResult.default || importResult;
-      } else {
-        const content = await readFile(filePath, "utf-8");
-        config = JSON.parse(content);
-      }
-      const validation = this.validator.validate(config);
-      if (!validation.valid) {
-        const errorMessages = validation.errors.map((e) => `${e.path}: ${e.message}`).join("\n");
-        throw new Error(`Configuration validation failed:
-${errorMessages}`);
-      }
-      if (!validation.config) throw new Error("Invalid configuration");
-      return this.mergeWithDefaults(validation.config);
-    } catch (error) {
-      if (error instanceof Error) {
-        throw new Error(`Failed to load config from ${filePath}: ${error.message}`);
-      }
-      throw error;
-    }
-  }
-  /**
-   * Find configuration file in the given directory
-   */
-  async findConfigFile(startDir) {
-    for (const fileName of CONFIG_FILE_NAMES) {
-      const configPath = resolve(startDir, fileName);
-      if (existsSync(configPath)) {
-        return configPath;
-      }
-    }
-    return null;
-  }
-  /**
-   * Merge user config with defaults
-   */
-  mergeWithDefaults(userConfig) {
-    const merged = {
-      ...DEFAULT_CONFIG,
-      ...userConfig,
-      typescript: {
-        ...DEFAULT_CONFIG.typescript,
-        ...userConfig.typescript
-      }
-    };
-    return merged;
-  }
-};
-var configLoader = new ConfigLoader();
-async function loadConfig(workingDir) {
-  return configLoader.autoload(workingDir);
-}
-function isConfig(obj) {
-  const validator = new ConfigValidator();
-  const result = validator.validate(obj);
-  return result.valid;
-}
-function defineConfig(config) {
-  return config;
-}
 
-export { APIBuilder, CONFIG_FILE_NAMES, ConfigLoader, ConfigValidator, DEFAULT_CONFIG, LogLevel, configLoader, defineConfig, isConfig, loadConfig, prettyReport };
+export { APIBuilder, LogLevel, prettyReport };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map