@atomic-ehr/codegen 0.0.1-canary.20251106145509.e3b1f82 → 0.0.1-canary.20251107091824.7605d36

package/dist/index.js

@@ -1,6 +1,6 @@
 import * as fs from 'fs';
 import fs__default, { existsSync, mkdirSync } from 'fs';
-import * as afs2 from 'fs/promises';
+import * as afs3 from 'fs/promises';
 import { readdir, stat, unlink, readFile, writeFile, access, mkdir, rm } from 'fs/promises';
 import * as Path4 from 'path';
 import Path4__default, { join, resolve, dirname, relative } from 'path';
@@ -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,7 +1398,24 @@ 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 npmToPackageMeta = (fhir) => {
+  const [name, version] = fhir.split("@");
+  if (!name) throw new Error(`Invalid FHIR package meta: ${fhir}`);
+  return { name, version: version ?? "latest" };
+};
 var packageMetaToNpm = (packageMeta) => `${packageMeta.name}@${packageMeta.version}`;
 var enrichFHIRSchema = (schema, packageMeta) => {
   if (!packageMeta) {
@@ -1447,10 +1465,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 +1605,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 +1677,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 +1688,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 +1715,10 @@ 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 ${path.join(".")}`);
   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 +1738,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 +1896,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 +1922,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 +1946,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 +1970,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();
@@ -2362,7 +2323,7 @@ function createLogger(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"));
+  const packageJSON = JSON.parse(await afs3.readFile(packageJSONFileName, "utf8"));
   return packageJSON;
 };
 var readPackageDependencies = async (workDir, packageMeta) => {
@@ -2376,69 +2337,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("tmp/fhir", 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 +2388,21 @@ 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,19 +3470,21 @@ 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;
 };
@@ -3564,7 +3524,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;
   };
@@ -3622,7 +3583,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 +3611,26 @@ 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] = { complexTypes: {}, resources: {}, profiles: {} };
+      for (const schema of shemas) {
+        schema.identifier;
+        if (isResourceTypeSchema(schema)) {
+          tree[pkgId].resources[schema.identifier.url] = {};
+        }
+        if (isProfileTypeSchema(schema)) {
+          tree[pkgId].profiles[schema.identifier.url] = {};
+        }
+        if (isComplexTypeTypeSchema(schema)) {
+          tree[pkgId].complexTypes[schema.identifier.url] = {};
+        }
+      }
+    }
+    const raw = filename.endsWith(".yaml") ? YAML.stringify(tree) : JSON.stringify(tree, void 0, 2);
+    await afs3.writeFile(filename, raw);
+  };
   return {
     _schemaIndex: index,
     _relations: relations,
@@ -3661,7 +3645,8 @@ var mkTypeSchemaIndex = (schemas, logger) => {
     findLastSpecialization,
     findLastSpecializationByIdentifier,
     flatProfile,
-    isWithMetaField
+    isWithMetaField,
+    exportTree
   };
 };
 
@@ -4179,7 +4164,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 +4204,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 +5512,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 +5715,8 @@ var tsModuleFileName = (id) => {
 };
 var canonicalToName2 = (canonical, dropFragment = true) => {
   if (!canonical) return void 0;
-  let localName = canonical.split("/").pop();
+  const localName = extractNameFromCanonical(canonical, dropFragment);
   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 normalizeTsName(localName);
 };
 var tsResourceName = (id) => {
@@ -5794,12 +5772,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 +5787,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 +5830,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 +5874,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);
@@ -5928,6 +5912,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;
         }
@@ -6093,17 +6079,20 @@ 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 APIBuilder = class {
   schemas = [];
   options;
   generators = /* @__PURE__ */ new Map();
@@ -6124,7 +6113,8 @@ var APIBuilder = class _APIBuilder {
       typeSchemaConfig: options.typeSchemaConfig,
       manager: options.manager || null,
       throwException: options.throwException || false,
-      typeSchemaOutputDir: options.typeSchemaOutputDir
+      typeSchemaOutputDir: options.typeSchemaOutputDir,
+      exportTypeTree: options.exportTypeTree
     };
     this.typeSchemaConfig = options.typeSchemaConfig;
     this.logger = options.logger || createLogger({
@@ -6139,24 +6129,18 @@ var APIBuilder = class _APIBuilder {
     this.packages.push(packageMetaToNpm({ name: packageName, version: version || "latest" }));
     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,12 +6165,13 @@ 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: "//",
+      exportTypeTree: this.options.exportTypeTree
     };
     const effectiveOpts = { logger: this.logger, ...writerOpts, ...opts };
     const generator = writerToGenerator(new TypeScript(effectiveOpts));
@@ -6245,63 +6230,70 @@ var APIBuilder = class _APIBuilder {
     this.options.cleanOutput = enabled;
     return this;
   }
+  writeTypeTree(filename) {
+    this.options.exportTypeTree = filename;
+    return this;
+  }
   writeTypeSchemas(target) {
     this.options.typeSchemaOutputDir = target;
     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}...`);
+    await afs3.mkdir(outputDir, { recursive: true });
+    this.logger.info(`Writing TypeSchema files to ${outputDir}/...`);
+    const files = {};
     for (const ts of typeSchemas) {
-      const package_name = camelCase(ts.identifier.package.replaceAll("/", "-"));
-      const name = normalizeFileName(ts.identifier.name.toString());
+      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, 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);
+      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 afs3.mkdir(Path4.dirname(fullName), { recursive: true });
+          await afs3.writeFile(fullName, json);
+        })
+      );
     }
   }
   async writeTypeSchemasToSingleFile(typeSchemas, outputFile) {
+    this.logger.info(`Writing TypeSchema files to: ${outputFile}`);
     if (this.options.cleanOutput && fs.existsSync(outputFile)) fs.rmSync(outputFile);
-    await afs2.mkdir(Path4.dirname(outputFile), { recursive: true });
+    await afs3.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");
+      await afs3.appendFile(outputFile, `${json}
+`);
     }
   }
   async tryWriteTypeSchema(typeSchemas) {
     if (!this.options.typeSchemaOutputDir) return;
     try {
-      this.logger.info(`Starting writing TypeSchema files.`);
-      if (Path4.extname(this.options.typeSchemaOutputDir) === ".ndjson")
+      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.`);
+      } else {
+        await this.writeTypeSchemasToSeparateFiles(typeSchemas, this.options.typeSchemaOutputDir);
+      }
+      this.logger.info(`Writing TypeSchema - DONE`);
     } catch (error) {
-      if (this.options.throwException) throw error;
       this.logger.error(
         "Failed to write TypeSchema output",
         error instanceof Error ? error : new Error(String(error))
       );
+      if (this.options.throwException) throw error;
     }
   }
   async generate() {
@@ -6316,10 +6308,18 @@ var APIBuilder = class _APIBuilder {
     };
     this.logger.debug(`Starting generation with ${this.generators.size} generators`);
     if (this.options.cleanOutput) {
-      this.logger.info(`Cleaning output directory: ${this.options.outputDir}`);
+      this.logger.info(`Cleaning outputs...`);
       try {
+        this.logger.info(`Clean ${this.options.outputDir}`);
         fs.rmSync(this.options.outputDir, { recursive: true, force: true });
-        fs.mkdirSync(this.options.outputDir, { recursive: true });
+        if (this.options.typeSchemaOutputDir) {
+          this.logger.info(`Clean ${this.options.typeSchemaOutputDir}`);
+          fs.rmSync(this.options.typeSchemaOutputDir, { recursive: true, force: true });
+        }
+        if (this.options.exportTypeTree) {
+          this.logger.info(`Clean ${this.options.exportTypeTree}`);
+          fs.rmSync(this.options.exportTypeTree, { recursive: true, force: true });
+        }
       } catch (error) {
         this.logger.warn(
           `Error cleaning output directory: ${error instanceof Error ? error.message : String(error)}`
@@ -6333,11 +6333,16 @@ var APIBuilder = class _APIBuilder {
         workingDir: "tmp/fhir"
       });
       await manager.init();
-      const register = await registerFromManager(manager, { logger: this.logger });
+      const register = await registerFromManager(manager, {
+        logger: this.logger,
+        focusedPackages: this.packages.map(npmToPackageMeta)
+      });
       const typeSchemas = await generateTypeSchemas(register, this.logger);
       await this.tryWriteTypeSchema(typeSchemas);
+      const tsIndex = mkTypeSchemaIndex(typeSchemas);
+      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`);
@@ -6404,11 +6409,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) {
@@ -6441,7 +6446,7 @@ function createAPIFromConfig(config) {
     builder.fromFiles(...config.files);
   }
   if (config.typescript) {
-    builder.typescript(config.typescript);
+    builder.typescriptDepricated(config.typescript);
   }
   return builder;
 }
@@ -6449,13 +6454,13 @@ async function generateTypesFromPackage(packageName, outputDir, options = {}) {
   return createAPI({
     outputDir,
     verbose: options.verbose
-  }).fromPackage(packageName, options.version).typescript().generate();
+  }).fromPackage(packageName, options.version).typescriptDepricated().generate();
 }
 async function generateTypesFromFiles(inputFiles, outputDir, options = {}) {
   return createAPI({
     outputDir,
     verbose: options.verbose
-  }).fromFiles(...inputFiles).typescript().generate();
+  }).fromFiles(...inputFiles).typescriptDepricated().generate();
 }
 var DEFAULT_CONFIG = {
   outputDir: "./generated",