@atomic-ehr/codegen 0.0.1 → 0.0.2-canary.20251114125643.cb2d5e2

package/dist/index.js

@@ -8,6 +8,7 @@ import { CanonicalManager } from '@atomic-ehr/fhir-canonical-manager';
 import * as fhirschema from '@atomic-ehr/fhirschema';
 import { isStructureDefinition } from '@atomic-ehr/fhirschema';
 import pc from 'picocolors';
+import * as YAML from 'yaml';
 
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -1397,6 +1398,18 @@ var init_IndexBuilder = __esm({
 });
 
 // src/typeschema/types.ts
+var extractNameFromCanonical = (canonical, dropFragment = true) => {
+  let localName = canonical.split("/").pop();
+  if (!localName) return void 0;
+  if (dropFragment && localName.includes("#")) {
+    localName = localName.split("#")[0];
+  }
+  if (!localName) return void 0;
+  if (/^\d/.test(localName)) {
+    localName = `number_${localName}`;
+  }
+  return localName;
+};
 var packageMetaToFhir = (packageMeta) => `${packageMeta.name}#${packageMeta.version}`;
 var packageMetaToNpm = (packageMeta) => `${packageMeta.name}@${packageMeta.version}`;
 var enrichFHIRSchema = (schema, packageMeta) => {
@@ -1429,6 +1442,9 @@ var isComplexTypeTypeSchema = (schema) => {
 var isResourceTypeSchema = (schema) => {
   return schema?.identifier.kind === "resource";
 };
+var isPrimitiveTypeSchema = (schema) => {
+  return schema?.identifier.kind === "primitive-type";
+};
 var isLogicalTypeSchema = (schema) => {
   return schema?.identifier.kind === "logical";
 };
@@ -1438,6 +1454,9 @@ var isProfileTypeSchema = (schema) => {
 function isBindingSchema(schema) {
   return schema?.identifier.kind === "binding";
 }
+function isValueSetTypeSchema(schema) {
+  return schema?.identifier.kind === "value-set";
+}
 var isNotChoiceDeclarationField = (field) => {
   if (!field) return false;
   return field.choices === void 0;
@@ -1447,10 +1466,10 @@ var isChoiceDeclarationField = (field) => {
   return field.choices !== void 0;
 };
 var isValueSet = (res) => {
-  return res.resourceType === "ValueSet";
+  return res?.resourceType === "ValueSet";
 };
 var isCodeSystem = (res) => {
-  return res.resourceType === "CodeSystem";
+  return res?.resourceType === "CodeSystem";
 };
 var enrichValueSet = (vs, packageMeta) => {
   if (!vs.url) throw new Error("ValueSet must have a URL");
@@ -1587,12 +1606,15 @@ function mkNestedTypes(register, fhirSchema, logger) {
     } else {
       baseName = element.type;
     }
+    const baseUrl = register.ensureSpecializationCanonicalUrl(baseName);
+    const baseFs = register.resolveFs(fhirSchema.package_meta, baseUrl);
+    if (!baseFs) throw new Error(`Could not resolve base type ${baseName}`);
     const base = {
       kind: "complex-type",
-      package: fhirSchema.package_meta.name,
-      version: fhirSchema.package_meta.version,
+      package: baseFs.package_meta.name,
+      version: baseFs.package_meta.version,
       name: baseName,
-      url: register.ensureSpecializationCanonicalUrl(fhirSchema.package_meta, baseName)
+      url: baseUrl
     };
     const fields = transformNestedElements(register, fhirSchema, path, element.elements, logger);
     const nestedType = {
@@ -1656,8 +1678,9 @@ function isExcluded(register, fhirSchema, path) {
 var buildReferences = (register, fhirSchema, element) => {
   if (!element.refers) return void 0;
   return element.refers.map((ref) => {
-    const curl = register.ensureSpecializationCanonicalUrl(fhirSchema.package_meta, ref);
+    const curl = register.ensureSpecializationCanonicalUrl(ref);
     const fs4 = register.resolveFs(fhirSchema.package_meta, curl);
+    if (!fs4) throw new Error(`Failed to resolve fs for ${curl}`);
     return mkIdentifier(fs4);
   });
 };
@@ -1666,9 +1689,12 @@ function buildFieldType(register, fhirSchema, path, element, logger) {
     const refPath = element.elementReference.slice(1).filter((_, i) => i % 2 === 1);
     return mkNestedIdentifier(register, fhirSchema, refPath, logger);
   } else if (element.type) {
-    const url = register.ensureSpecializationCanonicalUrl(fhirSchema.package_meta, element.type);
+    const url = register.ensureSpecializationCanonicalUrl(element.type);
     const fieldFs = register.resolveFs(fhirSchema.package_meta, url);
-    if (!fieldFs) throw new Error(`Could not resolve field type: '${element.type}'`);
+    if (!fieldFs)
+      throw new Error(
+        `Could not resolve field type: '${element.type}' (from '${fhirSchema.url}' in '${packageMetaToFhir(fhirSchema.package_meta)}')`
+      );
     return mkIdentifier(fieldFs);
   } else if (element.choices) {
     return void 0;
@@ -1690,8 +1716,11 @@ var mkField = (register, fhirSchema, path, element, logger) => {
       enumValues = buildEnum(register, fhirSchema, 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})`);
   return {
-    type: buildFieldType(register, fhirSchema, path, element, logger),
+    type: fieldType,
     required: isRequired(register, fhirSchema, path),
     excluded: isExcluded(register, fhirSchema, path),
     reference: buildReferences(register, fhirSchema, element),
@@ -1711,8 +1740,9 @@ function isNestedElement(element) {
   return isBackbone || isElement || elementsWithoutType;
 }
 function mkNestedField(register, fhirSchema, path, element, logger) {
+  const nestedIdentifier = mkNestedIdentifier(register, fhirSchema, path, logger);
   return {
-    type: mkNestedIdentifier(register, fhirSchema, path, logger),
+    type: nestedIdentifier,
     array: element.array || false,
     required: isRequired(register, fhirSchema, path),
     excluded: isExcluded(register, fhirSchema, path)
@@ -1868,19 +1898,6 @@ function extractFieldDependencies(fields) {
   }
   return deps;
 }
-function deduplicateDependencies(deps) {
-  const seen = /* @__PURE__ */ new Set();
-  const unique = [];
-  for (const dep of deps) {
-    const key = dep.url;
-    if (!seen.has(key)) {
-      seen.add(key);
-      unique.push(dep);
-    }
-  }
-  unique.sort((a, b) => a.name.localeCompare(b.name));
-  return unique;
-}
 function isExtensionSchema(fhirSchema, _identifier) {
   if (fhirSchema.base === "Extension" || fhirSchema.base === "http://hl7.org/fhir/StructureDefinition/Extension") {
     return true;
@@ -1907,62 +1924,6 @@ async function transformValueSet(register, valueSet, logger) {
     compose: !concept ? valueSet.compose : void 0
   };
 }
-async function transformExtension(fhirSchema, register, logger) {
-  try {
-    const identifier = mkIdentifier(fhirSchema);
-    let base;
-    if (fhirSchema.base && fhirSchema.base !== "Extension") {
-      const baseUrl = fhirSchema.base.includes("/") ? fhirSchema.base : `http://hl7.org/fhir/StructureDefinition/${fhirSchema.base}`;
-      const baseName = fhirSchema.base.split("/").pop() || fhirSchema.base;
-      base = {
-        kind: "complex-type",
-        package: "hl7.fhir.r4.core",
-        version: "4.0.1",
-        name: baseName,
-        url: baseUrl
-      };
-    } else {
-      base = {
-        kind: "complex-type",
-        package: "hl7.fhir.r4.core",
-        version: "4.0.1",
-        name: "Extension",
-        url: "http://hl7.org/fhir/StructureDefinition/Extension"
-      };
-    }
-    const extensionSchema = {
-      identifier,
-      base,
-      description: fhirSchema.description,
-      dependencies: [],
-      metadata: {
-        isExtension: true
-        // Mark as extension for file organization
-      }
-    };
-    if (base) {
-      extensionSchema.dependencies.push(base);
-    }
-    if (fhirSchema.elements) {
-      const fields = mkFields(register, fhirSchema, [], fhirSchema.elements, logger);
-      if (fields && Object.keys(fields).length > 0) {
-        extensionSchema.fields = fields;
-        extensionSchema.dependencies.push(...extractFieldDependencies(fields));
-      }
-    }
-    const nestedTypes = mkNestedTypes(register, fhirSchema, logger);
-    if (nestedTypes && nestedTypes.length > 0) {
-      extensionSchema.nested = nestedTypes;
-      extensionSchema.dependencies.push(...extractNestedDependencies(nestedTypes));
-    }
-    extensionSchema.dependencies = deduplicateDependencies(extensionSchema.dependencies);
-    extensionSchema.dependencies = extensionSchema.dependencies.filter((dep) => dep.url !== identifier.url);
-    return extensionSchema;
-  } catch (error) {
-    console.warn(`Failed to transform extension ${fhirSchema.name}: ${error}`);
-    return null;
-  }
-}
 function extractDependencies(identifier, base, fields, nestedTypes) {
   const deps = [];
   if (base) deps.push(base);
@@ -1987,10 +1948,12 @@ function transformFhirSchemaResource(register, fhirSchema, logger) {
   if (fhirSchema.base && fhirSchema.type !== "Element") {
     const baseFs = register.resolveFs(
       fhirSchema.package_meta,
-      register.ensureSpecializationCanonicalUrl(fhirSchema.package_meta, fhirSchema.base)
+      register.ensureSpecializationCanonicalUrl(fhirSchema.base)
     );
     if (!baseFs) {
-      throw new Error(`Base resource not found '${fhirSchema.base}' for '${fhirSchema.url}'`);
+      throw new Error(
+        `Base resource not found '${fhirSchema.base}' for <${fhirSchema.url}> from ${packageMetaToFhir(fhirSchema.package_meta)}`
+      );
     }
     base = mkIdentifier(baseFs);
   }
@@ -2009,16 +1972,16 @@ function transformFhirSchemaResource(register, fhirSchema, logger) {
   return [typeSchema, ...bindingSchemas];
 }
 async function transformFhirSchema(register, fhirSchema, logger) {
-  const results = [];
-  mkIdentifier(fhirSchema);
-  if (isExtensionSchema(fhirSchema)) {
-    const extensionSchema = await transformExtension(fhirSchema, register, logger);
-    if (extensionSchema) {
-      results.push(extensionSchema);
-    }
-    return results;
+  const schemas = transformFhirSchemaResource(register, fhirSchema, logger);
+  if (isExtensionSchema(fhirSchema, mkIdentifier(fhirSchema))) {
+    const schema = schemas[0];
+    if (!schema) throw new Error(`Expected schema to be defined`);
+    schema.metadata = {
+      isExtension: true
+      // Mark as extension for file organization
+    };
   }
-  return transformFhirSchemaResource(register, fhirSchema, logger);
+  return schemas;
 }
 var TypeSchemaCache = class {
   cache = /* @__PURE__ */ new Map();
@@ -2360,13 +2323,8 @@ new CodegenLogger();
 function createLogger(options = {}) {
   return new CodegenLogger(options);
 }
-var readPackageJSON = async (workDir, packageMeta) => {
-  const packageJSONFileName = Path4.join(workDir, "node_modules", packageMeta.name, "package.json");
-  const packageJSON = JSON.parse(await afs2.readFile(packageJSONFileName, "utf8"));
-  return packageJSON;
-};
-var readPackageDependencies = async (workDir, packageMeta) => {
-  const packageJSON = await readPackageJSON(workDir, packageMeta);
+var readPackageDependencies = async (manager, packageMeta) => {
+  const packageJSON = await manager.packageJson(packageMeta.name);
   const dependencies = packageJSON.dependencies;
   if (dependencies !== void 0) {
     return Object.entries(dependencies).map(([name, version]) => {
@@ -2376,69 +2334,50 @@ var readPackageDependencies = async (workDir, packageMeta) => {
   return [];
 };
 var mkEmptyPkgIndex = (pkg) => {
-  return { pkg, nameResolution: {}, canonicalResolution: {}, fhirSchemas: {}, valueSets: {} };
+  return {
+    pkg,
+    canonicalResolution: {},
+    fhirSchemas: {},
+    valueSets: {}
+  };
 };
-var mkPackageAwareResolver = async (manager, pkg, deep = 0, _logger) => {
-  const options = {};
-  const deps = await readPackageDependencies("tmp/fhir", pkg);
-  for (const dep of deps) {
-    const depOptions = mkPackageAwareResolver(manager, dep, deep);
-    Object.assign(options, depOptions);
-  }
+var mkPackageAwareResolver = async (manager, pkg, deep, acc, logger) => {
   const pkgId = packageMetaToFhir(pkg);
-  if (!options[pkgId]) options[pkgId] = mkEmptyPkgIndex(pkg);
+  logger?.info(`${" ".repeat(deep * 2)}+ ${pkgId}`);
+  if (acc[pkgId]) return acc[pkgId];
+  const index = mkEmptyPkgIndex(pkg);
   for (const resource of await manager.search({ package: pkg })) {
     const rawUrl = resource.url;
     if (!rawUrl) continue;
     if (!(isStructureDefinition(resource) || isValueSet(resource) || isCodeSystem(resource))) continue;
     const url = rawUrl;
-    if (!options[pkgId].canonicalResolution[url]) {
-      options[pkgId].canonicalResolution[url] = [];
-      for (const [depPkgId, { canonicalResolution }] of Object.entries(options)) {
-        if (pkgId === depPkgId) continue;
-        if (!canonicalResolution[url]) continue;
-        for (const deepRes of canonicalResolution[url]) {
-          options[pkgId].canonicalResolution[url].push({
-            deep: deepRes.deep + 1,
-            resource: deepRes.resource,
-            packageMeta: deepRes.packageMeta
-          });
-        }
-      }
-    }
-    options[pkgId].canonicalResolution[url].push({ deep, packageMeta: pkg, resource });
-    options[pkgId].canonicalResolution[url].sort((a, b) => a.deep - b.deep);
-    const name = resource.name;
-    if (name && isStructureDefinition(resource) && (resource.derivation === "specialization" || resource.derivation === void 0)) {
-      if (!options[pkgId].nameResolution[name]) {
-        options[pkgId].nameResolution[name] = resource.url;
-      } else {
-        throw new Error(`Duplicate name ${name} in package ${pkgId}`);
-      }
+    if (index.canonicalResolution[url]) logger?.dry_warn(`Duplicate canonical URL: ${url} at ${pkgId}.`);
+    index.canonicalResolution[url] = [{ deep, pkg, pkgId, resource }];
+  }
+  const deps = await readPackageDependencies(manager, pkg);
+  for (const depPkg of deps) {
+    const { canonicalResolution } = await mkPackageAwareResolver(manager, depPkg, deep + 1, acc, logger);
+    for (const [surl, resolutions] of Object.entries(canonicalResolution)) {
+      const url = surl;
+      index.canonicalResolution[url] = [...index.canonicalResolution[url] || [], ...resolutions];
     }
   }
-  return options;
-};
-var packageAwareResolveName = (resolver, pkg, name) => {
-  const pkgId = packageMetaToFhir(pkg);
-  if (!resolver[pkgId]) throw new Error(`Package ${pkgId} not found`);
-  const resource = resolver[pkgId].nameResolution[name];
-  return resource;
+  for (const resolutionOptions of Object.values(index.canonicalResolution)) {
+    resolutionOptions.sort((a, b) => a.deep - b.deep);
+  }
+  acc[pkgId] = index;
+  return index;
 };
-var packageAgnosticResolveCanonical = (resolver, url, logger) => {
+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`);
-  if (options.length > 1)
-    logger?.dry_warn(
-      `Multiple canonical resolutions found for ${url} in: ${JSON.stringify(options, void 0, 2)}`
-    );
   return options[0]?.resource;
 };
-var registerFromManager = async (manager, { logger, fallbackPackageForNameResolution }) => {
-  const packages = await manager.packages();
+var registerFromManager = async (manager, { logger, fallbackPackageForNameResolution, focusedPackages }) => {
+  const packages = focusedPackages ?? await manager.packages();
   const resolver = {};
   for (const pkg of packages) {
-    Object.assign(resolver, await mkPackageAwareResolver(manager, pkg));
+    await mkPackageAwareResolver(manager, pkg, 0, resolver, logger);
   }
   for (const { pkg, canonicalResolution } of Object.values(resolver)) {
     const pkgId = packageMetaToFhir(pkg);
@@ -2446,19 +2385,24 @@ var registerFromManager = async (manager, { logger, fallbackPackageForNameResolu
     let counter = 0;
     logger?.info(`FHIR Schema conversion for '${packageMetaToFhir(pkg)}' begins...`);
     for (const [_url, options] of Object.entries(canonicalResolution)) {
-      const resource = options[0]?.resource;
-      if (!resource) throw new Error(`Resource not found`);
+      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), pkg);
+        const rfs = enrichFHIRSchema(
+          fhirschema.translate(resource),
+          resourcePkg
+        );
         counter++;
         resolver[pkgId].fhirSchemas[rfs.url] = rfs;
       }
       if (isValueSet(resource)) {
-        const rvs = enrichValueSet(resource, pkg);
+        const rvs = enrichValueSet(resource, resourcePkg);
         resolver[pkgId].valueSets[rvs.url] = rvs;
       }
     }
-    logger?.success(`FHIR Schema conversion for '${packageMetaToFhir(pkg)}' completed: ${counter} successful`);
+    logger?.info(`FHIR Schema conversion for '${packageMetaToFhir(pkg)}' completed: ${counter} successful`);
   }
   const resolveFs = (pkg, canonicalUrl) => {
     return resolver[packageMetaToFhir(pkg)]?.fhirSchemas[canonicalUrl] || fallbackPackageForNameResolution && resolver[packageMetaToFhir(fallbackPackageForNameResolution)]?.fhirSchemas[canonicalUrl];
@@ -2466,14 +2410,19 @@ var registerFromManager = async (manager, { logger, fallbackPackageForNameResolu
   const resolveVs = (pkg, canonicalUrl) => {
     return resolver[packageMetaToFhir(pkg)]?.valueSets[canonicalUrl] || fallbackPackageForNameResolution && resolver[packageMetaToFhir(fallbackPackageForNameResolution)]?.valueSets[canonicalUrl];
   };
-  const ensureSpecializationCanonicalUrl = (pkg, name) => packageAwareResolveName(resolver, pkg, name) || fallbackPackageForNameResolution && packageAwareResolveName(resolver, fallbackPackageForNameResolution, name) || name;
+  const ensureSpecializationCanonicalUrl = (name) => name.match(/^[a-zA-Z0-9]+$/) && `http://hl7.org/fhir/StructureDefinition/${name}` || name;
   const resolveFsGenealogy = (pkg, canonicalUrl) => {
     let fs4 = resolveFs(pkg, canonicalUrl);
-    if (fs4 === void 0) throw new Error(`Failed to resolve FHIR Schema genealogy for '${canonicalUrl}'`);
+    if (fs4 === void 0) throw new Error(`Failed to resolve FHIR Schema: '${canonicalUrl}'`);
     const genealogy = [fs4];
     while (fs4?.base) {
-      fs4 = resolveFs(fs4.package_meta, fs4.base) || resolveFs(fs4.package_meta, ensureSpecializationCanonicalUrl(fs4.package_meta, fs4.base));
-      if (fs4 === void 0) throw new Error(`Failed to resolve FHIR Schema genealogy for '${canonicalUrl}'`);
+      const pkg2 = fs4.package_meta;
+      const baseUrl = ensureSpecializationCanonicalUrl(fs4.base);
+      fs4 = resolveFs(pkg2, baseUrl);
+      if (fs4 === void 0)
+        throw new Error(
+          `Failed to resolve FHIR Schema base for '${canonicalUrl}'. Problem: '${baseUrl}' from '${packageMetaToFhir(pkg2)}'`
+        );
       genealogy.push(fs4);
     }
     return genealogy;
@@ -2501,11 +2450,10 @@ var registerFromManager = async (manager, { logger, fallbackPackageForNameResolu
   };
   return {
     ...manager,
-    unsafeAppendFs(fs4) {
+    testAppendFs(fs4) {
       const rfs = enrichFHIRSchema(fs4);
       const pkgId = packageMetaToFhir(rfs.package_meta);
       if (!resolver[pkgId]) resolver[pkgId] = mkEmptyPkgIndex(rfs.package_meta);
-      resolver[pkgId].nameResolution[rfs.name] = rfs.url;
       resolver[pkgId].fhirSchemas[rfs.url] = rfs;
     },
     resolveFs,
@@ -2513,16 +2461,17 @@ var registerFromManager = async (manager, { logger, fallbackPackageForNameResolu
     resolveFsSpecializations,
     ensureSpecializationCanonicalUrl,
     resolveSd: (_pkg, canonicalUrl) => {
-      const res = packageAgnosticResolveCanonical(resolver, canonicalUrl, logger);
+      const res = packageAgnosticResolveCanonical(resolver, canonicalUrl);
       if (isStructureDefinition(res)) return res;
       return void 0;
     },
     allFs: () => Object.values(resolver).flatMap((pkgIndex) => Object.values(pkgIndex.fhirSchemas)),
     allVs: () => Object.values(resolver).flatMap((pkgIndex) => Object.values(pkgIndex.valueSets)),
     resolveVs,
-    resolveAny: (canonicalUrl) => packageAgnosticResolveCanonical(resolver, canonicalUrl, logger),
+    resolveAny: (canonicalUrl) => packageAgnosticResolveCanonical(resolver, canonicalUrl),
     resolveElementSnapshot,
-    getAllElementKeys
+    getAllElementKeys,
+    resolver
   };
 };
 var resolveFsElementGenealogy = (genealogy, path) => {
@@ -2567,10 +2516,10 @@ var TypeSchemaGenerator = class {
     }
   }
   async registerFromPackageMetas(packageMetas) {
-    const packageNames = packageMetas.map((meta) => `${meta.name}${meta.version}`);
+    const packageNames = packageMetas.map(packageMetaToFhir);
     this.logger?.step(`Loading FHIR packages: ${packageNames.join(", ")}`);
     await this.manager.init();
-    return registerFromManager(this.manager, {});
+    return registerFromManager(this.manager, { focusedPackages: packageMetas });
   }
   generateFhirSchemas(structureDefinitions) {
     this.logger?.progress(`Converting ${structureDefinitions.length} StructureDefinitions to FHIRSchemas`);
@@ -3013,9 +2962,29 @@ var TypeSchemaParser = class {
 };
 
 // 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]}`);
+      continue;
+    }
     fhirSchemas.push(...await transformFhirSchema(register, fhirSchema, logger));
   }
   for (const vsSchema of register.allVs()) {
@@ -3050,23 +3019,9 @@ var uppercaseFirstLetter = (str) => {
 var uppercaseFirstLetterOfEach = (strings) => {
   return strings.map((str) => uppercaseFirstLetter(str));
 };
-function deepEqual(obj1, obj2) {
-  if (obj1 === obj2) return true;
-  if (obj1 === null || obj2 === null || typeof obj1 !== "object" || typeof obj2 !== "object") {
-    return false;
-  }
-  if (Array.isArray(obj1) && Array.isArray(obj2)) {
-    if (obj1.length !== obj2.length) return false;
-    return obj1.every((item, index) => deepEqual(item, obj2[index]));
-  }
-  if (Array.isArray(obj1) || Array.isArray(obj2)) {
-    return false;
-  }
-  const keys1 = Object.keys(obj1);
-  const keys2 = Object.keys(obj2);
-  if (keys1.length !== keys2.length) return false;
-  return keys1.every((key) => keys2.includes(key) && deepEqual(obj1[key], obj2[key]));
-}
+var typeSchemaInfo = (schema) => {
+  return `<${schema.identifier.url}> from ${schema.identifier.package}#${schema.identifier.version}`;
+};
 var FileSystemWriter = class {
   opts;
   currentDir;
@@ -3080,12 +3035,14 @@ var FileSystemWriter = class {
     return this.opts.logger;
   }
   cd(path, gen) {
+    const prev = this.currentDir;
     this.currentDir = path.startsWith("/") ? Path4.join(this.opts.outputDir, path) : Path4.join(this.currentDir, path);
     if (!fs.existsSync(this.currentDir)) {
       fs.mkdirSync(this.currentDir, { recursive: true });
     }
     this.logger()?.debug(`cd '${this.currentDir}'`);
     gen();
+    this.currentDir = prev;
   }
   cat(fn, gen) {
     if (this.currentFileDescriptor) throw new Error("Can't open file in file");
@@ -3098,6 +3055,7 @@ var FileSystemWriter = class {
       gen();
     } finally {
       if (this.currentFileDescriptor) {
+        fs.fsyncSync(this.currentFileDescriptor);
         fs.closeSync(this.currentFileDescriptor);
       }
       this.currentFileDescriptor = void 0;
@@ -3512,22 +3470,75 @@ var CSharp = class extends Writer {
     fs__default.copyFileSync(sourceFile, destFile);
   }
 };
-
-// src/typeschema/utils.ts
 var groupByPackages = (typeSchemas) => {
   const grouped = {};
   for (const ts of typeSchemas) {
-    const packageName = ts.identifier.package;
-    if (!grouped[packageName]) {
-      grouped[packageName] = [];
-    }
-    grouped[packageName].push(ts);
+    const pkgName = ts.identifier.package;
+    if (!grouped[pkgName]) grouped[pkgName] = [];
+    grouped[pkgName].push(ts);
   }
-  for (const [_packageName, typeSchemas2] of Object.entries(grouped)) {
-    typeSchemas2.sort((a, b) => a.identifier.name.localeCompare(b.identifier.name));
+  for (const [packageName, typeSchemas2] of Object.entries(grouped)) {
+    const dict = {};
+    for (const ts of typeSchemas2) {
+      dict[JSON.stringify(ts.identifier)] = ts;
+    }
+    const tmp = Object.values(dict);
+    tmp.sort((a, b) => a.identifier.name.localeCompare(b.identifier.name));
+    grouped[packageName] = tmp;
   }
   return grouped;
 };
+var treeShakeTypeSchema = (schema, rule, _logger) => {
+  schema = structuredClone(schema);
+  if (isPrimitiveTypeSchema(schema) || isValueSetTypeSchema(schema) || isBindingSchema(schema)) return schema;
+  for (const fieldName of rule.ignoreFields ?? []) {
+    if (schema.fields && !schema.fields[fieldName]) throw new Error(`Field ${fieldName} not found`);
+    if (schema.fields) {
+      delete schema.fields[fieldName];
+    }
+  }
+  schema.dependencies = extractDependencies(schema.identifier, schema.base, schema.fields, schema.nested);
+  return schema;
+};
+var treeShake = (tsIndex, treeShake2, logger) => {
+  const focusedSchemas = [];
+  for (const [pkgId, requires] of Object.entries(treeShake2)) {
+    for (const [url, rule] of Object.entries(requires)) {
+      const schema = tsIndex.resolveByUrl(pkgId, url);
+      if (!schema) throw new Error(`Schema not found for ${pkgId} ${url}`);
+      const shaked2 = treeShakeTypeSchema(schema, rule);
+      focusedSchemas.push(shaked2);
+    }
+  }
+  const collectDeps = (schemas, acc) => {
+    if (schemas.length === 0) return Object.values(acc);
+    for (const schema of schemas) {
+      acc[JSON.stringify(schema.identifier)] = schema;
+    }
+    const newSchemas = [];
+    for (const schema of schemas) {
+      if (isSpecializationTypeSchema(schema)) {
+        if (!schema.dependencies) continue;
+        schema.dependencies.forEach((dep) => {
+          const depSchema = tsIndex.resolve(dep);
+          if (!depSchema) throw new Error(`Schema not found for ${dep}`);
+          const id = JSON.stringify(depSchema.identifier);
+          if (!acc[id]) newSchemas.push(depSchema);
+        });
+        if (schema.nested) {
+          for (const nest of schema.nested) {
+            if (isNestedIdentifier(nest.identifier)) continue;
+            const id = JSON.stringify(nest.identifier);
+            if (!acc[id]) newSchemas.push(nest);
+          }
+        }
+      }
+    }
+    return collectDeps(newSchemas, acc);
+  };
+  const shaked = collectDeps(focusedSchemas, {});
+  return mkTypeSchemaIndex(shaked, logger);
+};
 var resourceRelatives = (schemas) => {
   const regularSchemas = schemas.filter(isResourceTypeSchema);
   const directPairs = [];
@@ -3564,7 +3575,8 @@ var mkTypeSchemaIndex = (schemas, logger) => {
     if (index[url][schema.identifier.package] && pkg !== "shared") {
       const r1 = JSON.stringify(schema.identifier, void 0, 2);
       const r2 = JSON.stringify(index[url][pkg]?.identifier, void 0, 2);
-      throw new Error(`Duplicate schema: ${r1} and ${r2}`);
+      if (r1 !== r2) throw new Error(`Duplicate schema: ${r1} and ${r2}`);
+      return;
     }
     index[url][pkg] = schema;
   };
@@ -3573,6 +3585,7 @@ var mkTypeSchemaIndex = (schemas, logger) => {
   }
   const relations = resourceRelatives(schemas);
   const resolve2 = (id) => index[id.url]?.[id.package];
+  const resolveByUrl = (pkgName, url) => index[url]?.[pkgName];
   const resourceChildren = (id) => {
     return relations.filter((relative2) => relative2.parent.name === id.name).map((relative2) => relative2.child);
   };
@@ -3585,6 +3598,9 @@ var mkTypeSchemaIndex = (schemas, logger) => {
       if (base === void 0) break;
       const resolved = resolve2(base);
       if (!resolved) {
+        logger?.warn(
+          `Failed to resolve base type: ${res.map((e) => `${e.identifier.url} (${e.identifier.kind})`).join(", ")}`
+        );
         return void 0;
       }
       cur = resolved;
@@ -3622,7 +3638,10 @@ var mkTypeSchemaIndex = (schemas, logger) => {
       if (!schema2.fields) continue;
       for (const [fieldName, fieldConstraints] of Object.entries(schema2.fields)) {
         if (mergedFields[fieldName]) {
-          mergedFields[fieldName] = { ...mergedFields[fieldName], ...fieldConstraints };
+          mergedFields[fieldName] = {
+            ...mergedFields[fieldName],
+            ...fieldConstraints
+          };
         } else {
           mergedFields[fieldName] = { ...fieldConstraints };
         }
@@ -3647,6 +3666,28 @@ var mkTypeSchemaIndex = (schemas, logger) => {
       return schema.fields?.meta !== void 0;
     });
   };
+  const exportTree = async (filename) => {
+    const tree = {};
+    for (const [pkgId, shemas] of Object.entries(groupByPackages(schemas))) {
+      tree[pkgId] = {
+        "primitive-type": {},
+        "complex-type": {},
+        resource: {},
+        "value-set": {},
+        nested: {},
+        binding: {},
+        profile: {},
+        logical: {}
+      };
+      for (const schema of shemas) {
+        schema.identifier;
+        tree[pkgId][schema.identifier.kind][schema.identifier.url] = {};
+      }
+    }
+    const raw = filename.endsWith(".yaml") ? YAML.stringify(tree) : JSON.stringify(tree, void 0, 2);
+    await afs2.mkdir(Path4.dirname(filename), { recursive: true });
+    await afs2.writeFile(filename, raw);
+  };
   return {
     _schemaIndex: index,
     _relations: relations,
@@ -3655,13 +3696,15 @@ var mkTypeSchemaIndex = (schemas, logger) => {
     collectLogicalModels: () => schemas.filter(isLogicalTypeSchema),
     collectProfiles: () => schemas.filter(isProfileTypeSchema),
     resolve: resolve2,
+    resolveByUrl,
     resourceChildren,
     tryHierarchy,
     hierarchy,
     findLastSpecialization,
     findLastSpecializationByIdentifier,
     flatProfile,
-    isWithMetaField
+    isWithMetaField,
+    exportTree
   };
 };
 
@@ -4179,7 +4222,7 @@ var BaseGenerator = class {
    * This is the main method that orchestrates the entire generation process
    * @param schemas - Array of TypeSchema documents
    */
-  async generate(schemas) {
+  async generate({ schemas }) {
     return this.errorBoundary.withErrorBoundary(
       async () => {
         this.generationStartTime = performance.now();
@@ -4219,7 +4262,7 @@ var BaseGenerator = class {
       return result;
     };
     try {
-      const result = await this.generate(schemas);
+      const result = await this.generate({ schemas, index: null });
       result.forEach((file) => {
         const mockResult = mockWriteResults.get(file.filename);
         if (mockResult) {
@@ -5527,10 +5570,10 @@ ${nestedInterfaces}`;
   /**
    * Override generate to clean directory first
    */
-  async generate(schemas) {
+  async generate(input) {
     await this.fileManager.cleanDirectory();
     this.logger.debug("Cleaned output directory before generation");
-    return super.generate(schemas);
+    return super.generate(input);
   }
   /**
    * Run post-generation hooks - generate utility files
@@ -5730,15 +5773,8 @@ var tsModuleFileName = (id) => {
 };
 var canonicalToName2 = (canonical, dropFragment = true) => {
   if (!canonical) return void 0;
-  let localName = canonical.split("/").pop();
-  if (!localName) return void 0;
-  if (dropFragment && localName.includes("#")) {
-    localName = localName.split("#")[0];
-  }
+  const localName = extractNameFromCanonical(canonical, dropFragment);
   if (!localName) return void 0;
-  if (/^\d/.test(localName)) {
-    localName = `number_${localName}`;
-  }
   return normalizeTsName(localName);
 };
 var tsResourceName = (id) => {
@@ -5794,12 +5830,14 @@ var TypeScript = class extends Writer {
         if (["complex-type", "resource", "logical"].includes(dep.kind)) {
           imports.push({
             tsPackage: `../${kebabCase(dep.package)}/${pascalCase(dep.name)}`,
-            name: uppercaseFirstLetter(dep.name)
+            name: uppercaseFirstLetter(dep.name),
+            dep
           });
         } else if (isNestedIdentifier(dep)) {
           imports.push({
             tsPackage: `../${kebabCase(dep.package)}/${pascalCase(canonicalToName2(dep.url) ?? "")}`,
-            name: tsResourceName(dep)
+            name: tsResourceName(dep),
+            dep
           });
         } else {
           skipped.push(dep);
@@ -5807,6 +5845,7 @@ var TypeScript = class extends Writer {
       }
       imports.sort((a, b) => a.name.localeCompare(b.name));
       for (const dep of imports) {
+        this.debugComment(dep.dep);
         this.tsImportType(dep.tsPackage, dep.name);
       }
       for (const dep of skipped) {
@@ -5849,7 +5888,9 @@ var TypeScript = class extends Writer {
       if (isResourceTypeSchema(schema)) {
         const possibleResourceTypes = [schema.identifier];
         possibleResourceTypes.push(...tsIndex.resourceChildren(schema.identifier));
-        this.lineSM(`resourceType: ${possibleResourceTypes.map((e) => `"${e.name}"`).join(" | ")}`);
+        this.lineSM(
+          `resourceType: ${possibleResourceTypes.sort((a, b) => a.name.localeCompare(b.name)).map((e) => `"${e.name}"`).join(" | ")}`
+        );
         this.line();
       }
       if (!schema.fields) return;
@@ -5891,6 +5932,7 @@ var TypeScript = class extends Writer {
     }
   }
   generateProfileType(tsIndex, flatProfile) {
+    this.debugComment("flatProfile", flatProfile);
     const tsName = tsResourceName(flatProfile.identifier);
     this.debugComment("identifier", flatProfile.identifier);
     this.debugComment("base", flatProfile.base);
@@ -5903,7 +5945,7 @@ var TypeScript = class extends Writer {
         const tsName2 = tsFieldName(fieldName);
         let tsType;
         if (field.enum) {
-          tsType = field.enum.map((e) => `'${e}'`).join(" | ");
+          tsType = `(${field.enum.map((e) => `'${e}'`).join(" | ")})`;
         } else if (field.reference && field.reference.length > 0) {
           const specialization = tsIndex.findLastSpecialization(flatProfile);
           if (!isSpecializationTypeSchema(specialization))
@@ -5928,6 +5970,8 @@ var TypeScript = class extends Writer {
           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;
         }
@@ -6061,7 +6105,7 @@ var TypeScript = class extends Writer {
       ...tsIndex.collectComplexTypes(),
       ...tsIndex.collectResources(),
       // ...tsIndex.collectLogicalModels(),
-      ...tsIndex.collectProfiles().filter((p) => tsIndex.isWithMetaField(p))
+      ...this.opts.generateProfile ? tsIndex.collectProfiles().filter((p) => tsIndex.isWithMetaField(p)) : []
     ];
     const grouped = groupByPackages(typesToGenerate);
     this.cd("/", () => {
@@ -6093,17 +6137,100 @@ var writerToGenerator = (writerGen) => {
     });
   };
   return {
-    generate: async (schemas) => {
-      const tsIndex = mkTypeSchemaIndex(schemas);
+    generate: async ({ index: tsIndex }) => {
       writerGen.generate(tsIndex);
       return getGeneratedFiles();
     },
     setOutputDir: (outputDir) => writerGen.opts.outputDir = outputDir,
-    build: async (_schemas) => getGeneratedFiles()
+    build: async (_input) => getGeneratedFiles()
   };
 };
-var normalizeFileName = (str) => str.replace(/[^a-zA-Z0-9]/g, "");
-var APIBuilder = class _APIBuilder {
+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 = Path4.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(Path4.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(Path4.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 (Path4.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();
@@ -6124,7 +6251,9 @@ var APIBuilder = class _APIBuilder {
       typeSchemaConfig: options.typeSchemaConfig,
       manager: options.manager || null,
       throwException: options.throwException || false,
-      typeSchemaOutputDir: options.typeSchemaOutputDir
+      typeSchemaOutputDir: options.typeSchemaOutputDir,
+      exportTypeTree: options.exportTypeTree,
+      treeShake: options.treeShake
     };
     this.typeSchemaConfig = options.typeSchemaConfig;
     this.logger = options.logger || createLogger({
@@ -6136,27 +6265,26 @@ var APIBuilder = class _APIBuilder {
     }
   }
   fromPackage(packageName, version) {
-    this.packages.push(packageMetaToNpm({ name: packageName, version: version || "latest" }));
+    const pkg = packageMetaToNpm({ name: packageName, version: version || "latest" });
+    this.packages.push(pkg);
+    return this;
+  }
+  fromPackageRef(packageRef) {
+    this.packages.push(packageRef);
     return this;
   }
-  /**
-   * Load TypeSchema from files
-   */
   fromFiles(...filePaths) {
     this.logger.debug(`Loading from ${filePaths.length} TypeSchema files`);
     const operation = this.loadFromFiles(filePaths);
     this.pendingOperations.push(operation);
     return this;
   }
-  /**
-   * Load TypeSchema from TypeSchema objects
-   */
   fromSchemas(schemas) {
     this.logger.debug(`Adding ${schemas.length} TypeSchemas to generation`);
     this.schemas = [...this.schemas, ...schemas];
     return this;
   }
-  typescript(options = {}) {
+  typescriptDepricated(options = {}) {
     const typesOutputDir = `${this.options.outputDir}/types`;
     const generator = new TypeScriptGenerator({
       outputDir: typesOutputDir,
@@ -6181,17 +6309,19 @@ var APIBuilder = class _APIBuilder {
     this.logger.debug(`Configured TypeScript generator (${options.moduleFormat || "esm"})`);
     return this;
   }
-  typescript2(opts) {
+  typescript(opts) {
     const writerOpts = {
       outputDir: Path4.join(this.options.outputDir, "/types"),
       tabSize: 4,
       withDebugComment: false,
-      commentLinePrefix: "//"
+      commentLinePrefix: "//",
+      generateProfile: true,
+      exportTypeTree: this.options.exportTypeTree
     };
     const effectiveOpts = { logger: this.logger, ...writerOpts, ...opts };
     const generator = writerToGenerator(new TypeScript(effectiveOpts));
-    this.generators.set("typescript2", generator);
-    this.logger.debug(`Configured TypeScript2 generator (${JSON.stringify(effectiveOpts, void 0, 2)})`);
+    this.generators.set("typescript", generator);
+    this.logger.debug(`Configured TypeScript generator (${JSON.stringify(effectiveOpts, void 0, 2)})`);
     return this;
   }
   csharp(namespace, staticSourceDir) {
@@ -6245,64 +6375,17 @@ var APIBuilder = class _APIBuilder {
     this.options.cleanOutput = enabled;
     return this;
   }
-  writeTypeSchemas(target) {
-    this.options.typeSchemaOutputDir = target;
+  writeTypeTree(filename) {
+    this.options.exportTypeTree = filename;
     return this;
   }
-  static async isIdenticalTo(path, tsJSON) {
-    if (!await afs2.exists(path)) return false;
-    const json = await afs2.readFile(path);
-    const ts1 = JSON.parse(json.toString());
-    const ts2 = JSON.parse(tsJSON);
-    return deepEqual(ts1, ts2);
-  }
-  async writeTypeSchemasToSeparateFiles(typeSchemas, outputDir) {
-    if (this.options.cleanOutput) fs.rmSync(outputDir, { recursive: true, force: true });
-    await afs2.mkdir(outputDir, { recursive: true });
-    const usedNames = {};
-    this.logger.info(`Writing TypeSchema files to ${outputDir}...`);
-    for (const ts of typeSchemas) {
-      const package_name = camelCase(ts.identifier.package.replaceAll("/", "-"));
-      const name = normalizeFileName(ts.identifier.name.toString());
-      const json = JSON.stringify(ts, null, 2);
-      const baseName = Path4.join(outputDir, package_name, name);
-      let fullName;
-      if (usedNames[baseName] !== void 0) {
-        usedNames[baseName]++;
-        fullName = `${baseName}-${usedNames[baseName]}.typeschema.json`;
-      } else {
-        usedNames[baseName] = 0;
-        fullName = `${baseName}.typeschema.json`;
-      }
-      if (await _APIBuilder.isIdenticalTo(fullName, json)) continue;
-      await afs2.mkdir(Path4.dirname(fullName), { recursive: true });
-      await afs2.writeFile(fullName, json);
-    }
-  }
-  async writeTypeSchemasToSingleFile(typeSchemas, outputFile) {
-    if (this.options.cleanOutput && fs.existsSync(outputFile)) fs.rmSync(outputFile);
-    await afs2.mkdir(Path4.dirname(outputFile), { recursive: true });
-    this.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 + "\n");
-    }
+  treeShake(tree) {
+    this.options.treeShake = tree;
+    return this;
   }
-  async tryWriteTypeSchema(typeSchemas) {
-    if (!this.options.typeSchemaOutputDir) return;
-    try {
-      this.logger.info(`Starting writing TypeSchema files.`);
-      if (Path4.extname(this.options.typeSchemaOutputDir) === ".ndjson")
-        await this.writeTypeSchemasToSingleFile(typeSchemas, this.options.typeSchemaOutputDir);
-      else await this.writeTypeSchemasToSeparateFiles(typeSchemas, this.options.typeSchemaOutputDir);
-      this.logger.info(`Finished writing TypeSchema files.`);
-    } catch (error) {
-      if (this.options.throwException) throw error;
-      this.logger.error(
-        "Failed to write TypeSchema output",
-        error instanceof Error ? error : new Error(String(error))
-      );
-    }
+  writeTypeSchemas(target) {
+    this.options.typeSchemaOutputDir = target;
+    return this;
   }
   async generate() {
     const startTime = performance.now();
@@ -6315,35 +6398,36 @@ var APIBuilder = class _APIBuilder {
       duration: 0
     };
     this.logger.debug(`Starting generation with ${this.generators.size} generators`);
-    if (this.options.cleanOutput) {
-      this.logger.info(`Cleaning output directory: ${this.options.outputDir}`);
-      try {
-        fs.rmSync(this.options.outputDir, { recursive: true, force: true });
-        fs.mkdirSync(this.options.outputDir, { recursive: true });
-      } catch (error) {
-        this.logger.warn(
-          `Error cleaning output directory: ${error instanceof Error ? error.message : String(error)}`
-        );
-      }
-    }
     try {
+      if (this.options.cleanOutput) cleanup(this.options, this.logger);
       this.logger.info("Initialize Canonical Manager");
       const manager = CanonicalManager({
         packages: this.packages,
-        workingDir: "tmp/fhir"
+        workingDir: ".codegen-cache/canonical-manager-cache"
+      });
+      const ref2meta = await manager.init();
+      const packageMetas = Object.values(ref2meta);
+      const register = await registerFromManager(manager, {
+        logger: this.logger,
+        focusedPackages: packageMetas
       });
-      await manager.init();
-      const register = await registerFromManager(manager, { logger: this.logger });
       const typeSchemas = await generateTypeSchemas(register, this.logger);
-      await this.tryWriteTypeSchema(typeSchemas);
+      await tryWriteTypeSchema(typeSchemas, this.options, this.logger);
+      let tsIndex = mkTypeSchemaIndex(typeSchemas, this.logger);
+      if (this.options.treeShake) tsIndex = treeShake(tsIndex, this.options.treeShake, this.logger);
+      if (this.options.exportTypeTree) await tsIndex.exportTree(this.options.exportTypeTree);
       this.logger.debug(`Executing ${this.generators.size} generators`);
-      await this.executeGenerators(result, typeSchemas);
+      await this.executeGenerators(result, {
+        schemas: typeSchemas,
+        index: tsIndex
+      });
       this.logger.info("Generation completed successfully");
       result.success = result.errors.length === 0;
       this.logger.debug(`Generation completed: ${result.filesGenerated.length} files`);
     } catch (error) {
       this.logger.error("Code generation failed", error instanceof Error ? error : new Error(String(error)));
       result.errors.push(error instanceof Error ? error.message : String(error));
+      if (this.options.throwException) throw error;
     }
     return {
       ...result,
@@ -6404,11 +6488,11 @@ var APIBuilder = class _APIBuilder {
       this.cache.setMany(schemas);
     }
   }
-  async executeGenerators(result, typeSchemas) {
+  async executeGenerators(result, input) {
     for (const [type, generator] of this.generators.entries()) {
       this.logger.info(`Generating ${type}...`);
       try {
-        const files = await generator.generate(typeSchemas);
+        const files = await generator.generate(input);
         result.filesGenerated.push(...files.map((f) => f.path || f.filename));
         this.logger.info(`Generating ${type} finished successfully`);
       } catch (error) {
@@ -6420,9 +6504,6 @@ var APIBuilder = class _APIBuilder {
     }
   }
 };
-function createAPI(options) {
-  return new APIBuilder(options);
-}
 function createAPIFromConfig(config) {
   const builder = new APIBuilder({
     outputDir: config.outputDir,
@@ -6441,22 +6522,10 @@ function createAPIFromConfig(config) {
     builder.fromFiles(...config.files);
   }
   if (config.typescript) {
-    builder.typescript(config.typescript);
+    builder.typescriptDepricated(config.typescript);
   }
   return builder;
 }
-async function generateTypesFromPackage(packageName, outputDir, options = {}) {
-  return createAPI({
-    outputDir,
-    verbose: options.verbose
-  }).fromPackage(packageName, options.version).typescript().generate();
-}
-async function generateTypesFromFiles(inputFiles, outputDir, options = {}) {
-  return createAPI({
-    outputDir,
-    verbose: options.verbose
-  }).fromFiles(...inputFiles).typescript().generate();
-}
 var DEFAULT_CONFIG = {
   outputDir: "./generated",
   verbose: false,
@@ -6969,6 +7038,6 @@ function defineConfig(config) {
   return config;
 }
 
-export { APIBuilder, CONFIG_FILE_NAMES, ConfigLoader, ConfigValidator, DEFAULT_CONFIG, TypeSchemaCache, TypeSchemaGenerator, TypeSchemaParser, TypeScriptGenerator, configLoader, createAPI, createAPIFromConfig, defineConfig, generateTypesFromFiles, generateTypesFromPackage, isConfig, loadConfig };
+export { APIBuilder, CONFIG_FILE_NAMES, ConfigLoader, ConfigValidator, DEFAULT_CONFIG, TypeSchemaCache, TypeSchemaGenerator, TypeSchemaParser, TypeScriptGenerator, configLoader, createAPIFromConfig, defineConfig, isConfig, loadConfig };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map