@atomic-ehr/codegen 0.0.1-canary.20251013100511.ff2ef29 → 0.0.1-canary.20251015064414.0fcee22

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import { CanonicalManager } from '@atomic-ehr/fhir-canonical-manager';
 import * as FS from '@atomic-ehr/fhirschema';
-import { FHIRSchema, StructureDefinition } from '@atomic-ehr/fhirschema';
+import { FHIRSchema, StructureDefinition, FHIRSchemaElement } from '@atomic-ehr/fhirschema';
 
 /**
  * CodeGen Logger
@@ -315,6 +315,8 @@ type Register = {
     resolveVs(canonicalUrl: CanonicalUrl): RichValueSet | undefined;
     complexTypeDict(): Record<string, RichFHIRSchema>;
     resolveAny(canonicalUrl: CanonicalUrl): any | undefined;
+    resolveElementSnapshot(fhirSchema: RichFHIRSchema, path: string[]): FHIRSchemaElement;
+    getAllElementKeys(elems: Record<string, FHIRSchemaElement>): string[];
 } & ReturnType<typeof CanonicalManager>;
 
 /**
@@ -828,6 +830,9 @@ declare class APIBuilder {
     throwException(enabled?: boolean): APIBuilder;
     cleanOutput(enabled?: boolean): APIBuilder;
     writeTypeSchemas(target: string): this;
+    private static isIdenticalTo;
+    private writeTypeSchemasToSeparateFiles;
+    private writeTypeSchemasToSingleFile;
     private tryWriteTypeSchema;
     generate(): Promise<GenerationResult>;
     /**

package/dist/index.js

@@ -1,11 +1,11 @@
-import { CanonicalManager } from '@atomic-ehr/fhir-canonical-manager';
-import * as fhirschema from '@atomic-ehr/fhirschema';
 import * as fs from 'fs';
 import { existsSync, mkdirSync } from 'fs';
 import * as afs from 'fs/promises';
 import { readdir, stat, unlink, readFile, writeFile, access, mkdir, rm } from 'fs/promises';
 import * as Path2 from 'path';
 import { join, resolve, dirname, relative } from 'path';
+import { CanonicalManager } from '@atomic-ehr/fhir-canonical-manager';
+import * as fhirschema from '@atomic-ehr/fhirschema';
 import pc from 'picocolors';
 
 var __defProp = Object.defineProperty;
@@ -1446,122 +1446,6 @@ var isChoiceDeclarationField = (field) => {
   return field.choices !== void 0;
 };
 
-// src/typeschema/register.ts
-var registerFromManager = async (manager, logger) => {
-  const packages = await manager.packages();
-  const flatRawIndex = {};
-  const indexByPackages = [];
-  for (const pkg of packages) {
-    const resources = await manager.search({ package: pkg });
-    const perPackageIndex = {};
-    for (const resource of resources) {
-      const url = resource.url;
-      if (!url) continue;
-      if (perPackageIndex[url]) throw new Error(`Duplicate resource URL: ${url}`);
-      perPackageIndex[url] = resource;
-      if (flatRawIndex[url]) throw new Error(`Duplicate resource URL: ${url}`);
-      flatRawIndex[url] = resource;
-    }
-    indexByPackages.push({
-      package_meta: pkg,
-      index: perPackageIndex
-    });
-  }
-  const sdIndex = {};
-  const vsIndex = {};
-  const fsIndex = {};
-  const specNameToCanonical = {};
-  for (const resourcesByPackage of indexByPackages) {
-    const packageMeta = resourcesByPackage.package_meta;
-    for (const [surl, resource] of Object.entries(resourcesByPackage.index)) {
-      const url = surl;
-      if (resource.resourceType === "StructureDefinition") {
-        const sd = resource;
-        sdIndex[url] = sd;
-        const rfs = enrichFHIRSchema(fhirschema.translate(sd), packageMeta);
-        fsIndex[rfs.url] = rfs;
-        if (rfs.derivation === void 0 || rfs.derivation === "specialization") {
-          if (specNameToCanonical[rfs.name]) {
-            const info = {
-              old: specNameToCanonical[rfs.name],
-              oldDerivation: flatRawIndex[specNameToCanonical[rfs.name]].derivation,
-              new: rfs.url,
-              newDerivation: rfs.derivation
-            };
-            throw new Error(`Duplicate name ${rfs.name} ${JSON.stringify(info, void 0, 2)}`);
-          }
-          specNameToCanonical[rfs.name] = rfs.url;
-        }
-      }
-      if (resource.resourceType === "ValueSet") {
-        if (!resource.package_meta) {
-          resource.package_meta = packageMeta;
-        }
-        vsIndex[resource.url] = resource;
-      }
-    }
-    logger?.success(
-      `FHIR Schema conversion for '${packageMetaToFhir(packageMeta)}' completed: ${Object.keys(fsIndex).length} successful`
-    );
-  }
-  const complexTypes = {};
-  for (const fs3 of Object.values(fsIndex)) {
-    if (fs3.kind === "complex-type") {
-      complexTypes[fs3.url] = fs3;
-    }
-  }
-  const resolveFsGenealogy = (canonicalUrl) => {
-    let fs3 = fsIndex[canonicalUrl];
-    if (fs3 === void 0) throw new Error(`Failed to resolve FHIR Schema genealogy for '${canonicalUrl}'`);
-    const genealogy = [fs3];
-    while (fs3?.base) {
-      fs3 = fsIndex[fs3.base] || fsIndex[specNameToCanonical[fs3.base]];
-      genealogy.push(fs3);
-      if (fs3 === void 0) throw new Error(`Failed to resolve FHIR Schema genealogy for '${canonicalUrl}'`);
-    }
-    return genealogy;
-  };
-  const resolveFsSpecializations = (canonicalUrl) => {
-    return resolveFsGenealogy(canonicalUrl).filter((fs3) => fs3.derivation === "specialization");
-  };
-  return {
-    ...manager,
-    appendFs(fs3) {
-      const rfs = enrichFHIRSchema(fs3);
-      fsIndex[rfs.url] = rfs;
-      specNameToCanonical[rfs.name] = rfs.url;
-    },
-    resolveFs: (canonicalUrl) => fsIndex[canonicalUrl],
-    resolveFsGenealogy,
-    resolveFsSpecializations,
-    ensureSpecializationCanonicalUrl: (name) => specNameToCanonical[name] || name,
-    allSd: () => Object.values(sdIndex),
-    resolveSd: (canonicalUrl) => sdIndex[canonicalUrl],
-    allFs: () => Object.values(fsIndex),
-    allVs: () => Object.values(vsIndex),
-    resolveVs: (canonicalUrl) => vsIndex[canonicalUrl],
-    complexTypeDict: () => complexTypes,
-    resolveAny: (canonicalUrl) => flatRawIndex[canonicalUrl]
-  };
-};
-var resolveFsElementGenealogy = (genealogy, path) => {
-  const [top, ...rest] = path;
-  if (top === void 0) return [];
-  return genealogy.map((fs3) => {
-    if (!fs3.elements) return void 0;
-    let elem = fs3.elements?.[top];
-    for (const k of rest) {
-      elem = elem?.elements?.[k];
-    }
-    return elem;
-  }).filter((elem) => elem !== void 0);
-};
-function fsElementSnapshot(genealogy) {
-  const snapshot = genealogy.reverse().reduce((snapshot2, elem) => ({ ...snapshot2, ...elem }), {});
-  snapshot.elements = void 0;
-  return snapshot;
-}
-
 // src/typeschema/core/identifier.ts
 function dropVersionFromUrl(url) {
   const baseUrl = url.split("|")[0];
@@ -1661,12 +1545,13 @@ function collectNestedElements(fhirSchema, parentPath, elements) {
 }
 function transformNestedElements(register, fhirSchema, parentPath, elements, logger) {
   const fields = {};
-  for (const [key, element] of Object.entries(elements)) {
+  for (const [key, _element] of Object.entries(elements)) {
     const path = [...parentPath, key];
-    if (isNestedElement(element)) {
-      fields[key] = mkNestedField(register, fhirSchema, path, element, logger);
+    const elemSnapshot = register.resolveElementSnapshot(fhirSchema, path);
+    if (isNestedElement(elemSnapshot)) {
+      fields[key] = mkNestedField(register, fhirSchema, path, elemSnapshot, logger);
     } else {
-      fields[key] = mkField(register, fhirSchema, path, element, logger);
+      fields[key] = mkField(register, fhirSchema, path, elemSnapshot, logger);
     }
   }
   return fields;
@@ -1759,7 +1644,7 @@ var buildReferences = (element, register, _packageInfo) => {
     return mkIdentifier(fs3);
   });
 };
-function buildFieldType(register, fhirSchema, element, logger) {
+function buildFieldType(register, fhirSchema, path, element, logger) {
   if (element.elementReference) {
     const refPath = element.elementReference.slice(1).filter((_, i) => i % 2 === 1);
     return mkNestedIdentifier(register, fhirSchema, refPath, logger);
@@ -1772,10 +1657,12 @@ function buildFieldType(register, fhirSchema, element, logger) {
     return void 0;
   } else if (fhirSchema.derivation === "constraint") {
     return void 0;
-  } else
-    throw new Error(
-      `Can't recognize element type '${fhirSchema.url}' (${fhirSchema.derivation}): ${JSON.stringify(element, void 0, 2)}`
+  } else {
+    logger?.error(
+      `Can't recognize element type '${fhirSchema.url}' (${fhirSchema.derivation}) at '${path.join(".")}': ${JSON.stringify(element, void 0, 2)}`
     );
+    throw new Error(`Unrecognized element type`);
+  }
 }
 var mkField = (register, fhirSchema, path, element, logger) => {
   let binding;
@@ -1787,7 +1674,7 @@ var mkField = (register, fhirSchema, path, element, logger) => {
     }
   }
   return {
-    type: buildFieldType(register, fhirSchema, element, logger),
+    type: buildFieldType(register, fhirSchema, path, element, logger),
     required: isRequired(register, fhirSchema, path),
     excluded: isExcluded(register, fhirSchema, path),
     reference: buildReferences(element, register, fhirSchema.package_meta),
@@ -1882,7 +1769,7 @@ function buildEnum(register, element, logger) {
 function generateBindingSchema(register, fhirSchema, path, element, logger) {
   if (!element.binding?.valueSet) return void 0;
   const identifier = mkBindingIdentifier(fhirSchema, path, element.binding.bindingName);
-  const fieldType = buildFieldType(register, fhirSchema, element, logger);
+  const fieldType = buildFieldType(register, fhirSchema, path, element, logger);
   const valueSetIdentifier = mkValueSetIdentifierByUrl(register, element.binding.valueSet);
   const dependencies = [];
   if (fieldType) {
@@ -1936,26 +1823,10 @@ function collectBindingSchemas(register, fhirSchema, logger) {
 // src/typeschema/core/transformer.ts
 function mkFields(register, fhirSchema, parentPath, elements, logger) {
   if (!elements) return void 0;
-  const geneology = register.resolveFsGenealogy(fhirSchema.url);
-  const elems = {};
-  for (const [key, elem] of Object.entries(elements)) {
-    const path = [...parentPath, key];
-    const elemGeneology = resolveFsElementGenealogy(geneology, path);
-    const elemSnapshot = fsElementSnapshot(elemGeneology);
-    elems[key] = { elem, elemSnapshot, path };
-  }
-  for (const [_key, { elem, elemSnapshot, path }] of Object.entries(elems)) {
-    for (const choiceKey of elem?.choices || []) {
-      if (!elems[choiceKey]) {
-        const path2 = [...parentPath, choiceKey];
-        const elemGeneology = resolveFsElementGenealogy(geneology, path2);
-        const elemSnapshot2 = fsElementSnapshot(elemGeneology);
-        elems[choiceKey] = { elem: void 0, elemSnapshot: elemSnapshot2, path: path2 };
-      }
-    }
-  }
   const fields = {};
-  for (const [key, { elem, elemSnapshot, path }] of Object.entries(elems)) {
+  for (const key of register.getAllElementKeys(elements)) {
+    const path = [...parentPath, key];
+    const elemSnapshot = register.resolveElementSnapshot(fhirSchema, path);
     if (isNestedElement(elemSnapshot)) {
       fields[key] = mkNestedField(register, fhirSchema, path, elemSnapshot, logger);
     } else {
@@ -2385,7 +2256,7 @@ var CodegenLogger = class _CodegenLogger {
    */
   error(message, error) {
     if (this.isSuppressed(3 /* ERROR */)) return;
-    console.error(this.formatMessage("", message, pc.red));
+    console.error(this.formatMessage("X", message, pc.red));
     if (error && this.options.verbose) {
       console.error(pc.red(`   ${error.message}`));
       if (error.stack) {
@@ -2465,6 +2336,175 @@ new CodegenLogger();
 function createLogger(options = {}) {
   return new CodegenLogger(options);
 }
+var registerFromManager = async (manager, conf) => {
+  const packageNameResolver = conf?.packageNameResolver ?? ["hl7.fhir.r5.core", "hl7.cda.uv.core"];
+  const logger = conf?.logger;
+  const flatRawIndex = {};
+  const canonicalToPackages = {};
+  const resourceTypes = /* @__PURE__ */ new Set(["StructureDefinition", "ValueSet", "CodeSystem"]);
+  for (const res of await manager.search({})) {
+    const rawUrl = res.url;
+    if (!rawUrl) continue;
+    if (!resourceTypes.has(res.resourceType)) continue;
+    const url = rawUrl;
+    const pkg = (await manager.resolveEntry(url)).package;
+    if (!pkg) throw new Error(`Can't resolve package for ${url}`);
+    if (!canonicalToPackages[url]) canonicalToPackages[url] = [];
+    canonicalToPackages[url].push(pkg);
+    flatRawIndex[url] = res;
+  }
+  const collisions = Object.entries(canonicalToPackages).filter(([_, e]) => e.length > 1).map(([url, pkgs]) => `${url}: ${pkgs.map((p) => `${p.name}@${p.version}`).join(", ")}`).join("\n");
+  logger?.warn(`Duplicated canonicals: ${collisions}`);
+  const packageToResources = {};
+  const packageToPackageMeta = {};
+  for (const [url, _pkgs] of Object.entries(canonicalToPackages)) {
+    const pkg = (await manager.resolveEntry(url)).package;
+    if (!pkg) throw new Error(`Can't find package for ${url}`);
+    const pkgId = packageMetaToFhir(pkg);
+    packageToPackageMeta[pkgId] = pkg;
+    const res = await manager.resolve(url);
+    if (!packageToResources[pkgId]) {
+      packageToResources[pkgId] = {};
+    }
+    const index = packageToResources[pkgId];
+    if (!index) throw new Error(`Can't find index for ${pkg.name}@${pkg.version}`);
+    index[url] = res;
+  }
+  const indexByPackages = [];
+  for (const [pkgId, index] of Object.entries(packageToResources)) {
+    indexByPackages.push({
+      package_meta: packageToPackageMeta[pkgId],
+      index
+    });
+  }
+  const sdIndex = {};
+  const vsIndex = {};
+  const fsIndex = {};
+  for (const resourcesByPackage of indexByPackages) {
+    const packageMeta = resourcesByPackage.package_meta;
+    let counter = 0;
+    logger?.info(`FHIR Schema conversion for '${packageMetaToFhir(packageMeta)}' begins...`);
+    for (const [surl, resource] of Object.entries(resourcesByPackage.index)) {
+      const url = surl;
+      if (resource.resourceType === "StructureDefinition") {
+        const sd = resource;
+        sdIndex[url] = sd;
+        const rfs = enrichFHIRSchema(fhirschema.translate(sd), packageMeta);
+        counter++;
+        fsIndex[rfs.url] = rfs;
+      }
+      if (resource.resourceType === "ValueSet") {
+        if (!resource.package_meta) {
+          resource.package_meta = packageMeta;
+        }
+        vsIndex[resource.url] = resource;
+      }
+    }
+    logger?.success(
+      `FHIR Schema conversion for '${packageMetaToFhir(packageMeta)}' completed: ${counter} successful`
+    );
+  }
+  const specNameToCanonicals = {};
+  for (const rfs of Object.values(fsIndex)) {
+    if (rfs.derivation === "constraint") continue;
+    const name = rfs.name;
+    if (!specNameToCanonicals[name]) specNameToCanonicals[name] = {};
+    specNameToCanonicals[name][rfs.package_meta.name] = rfs.url;
+  }
+  const specNameToCanonical = {};
+  for (const [sname, canonicals] of Object.entries(specNameToCanonicals)) {
+    const name = sname;
+    const canonicalValues = Object.values(canonicals);
+    if (canonicalValues.length === 1) {
+      const url = canonicalValues[0];
+      specNameToCanonical[name] = url;
+    } else {
+      for (const pname of packageNameResolver) {
+        if (canonicals[pname]) {
+          specNameToCanonical[name] = canonicals[pname];
+          break;
+        }
+      }
+      if (specNameToCanonical[name] === void 0) throw new Error(`No canonical URL found for ${name}`);
+    }
+  }
+  const complexTypes = {};
+  for (const fs3 of Object.values(fsIndex)) {
+    if (fs3.kind === "complex-type") {
+      complexTypes[fs3.url] = fs3;
+    }
+  }
+  const resolveFsGenealogy = (canonicalUrl) => {
+    let fs3 = fsIndex[canonicalUrl];
+    if (fs3 === void 0) throw new Error(`Failed to resolve FHIR Schema genealogy for '${canonicalUrl}'`);
+    const genealogy = [fs3];
+    while (fs3?.base) {
+      fs3 = fsIndex[fs3.base] || fsIndex[specNameToCanonical[fs3.base]];
+      genealogy.push(fs3);
+      if (fs3 === void 0) throw new Error(`Failed to resolve FHIR Schema genealogy for '${canonicalUrl}'`);
+    }
+    return genealogy;
+  };
+  const resolveFsSpecializations = (canonicalUrl) => {
+    return resolveFsGenealogy(canonicalUrl).filter((fs3) => fs3.derivation === "specialization");
+  };
+  const resolveElementSnapshot = (fhirSchema, path) => {
+    const geneology = resolveFsGenealogy(fhirSchema.url);
+    const elemGeneology = resolveFsElementGenealogy(geneology, path);
+    const elemSnapshot = fsElementSnapshot(elemGeneology);
+    return elemSnapshot;
+  };
+  const getAllElementKeys = (elems) => {
+    const keys = /* @__PURE__ */ new Set();
+    for (const [key, elem] of Object.entries(elems)) {
+      keys.add(key);
+      for (const choiceKey of elem?.choices || []) {
+        if (!elems[choiceKey]) {
+          keys.add(choiceKey);
+        }
+      }
+    }
+    return Array.from(keys);
+  };
+  return {
+    ...manager,
+    appendFs(fs3) {
+      const rfs = enrichFHIRSchema(fs3);
+      fsIndex[rfs.url] = rfs;
+      specNameToCanonical[rfs.name] = rfs.url;
+    },
+    resolveFs: (canonicalUrl) => fsIndex[canonicalUrl],
+    resolveFsGenealogy,
+    resolveFsSpecializations,
+    ensureSpecializationCanonicalUrl: (name) => specNameToCanonical[name] || name,
+    allSd: () => Object.values(sdIndex),
+    resolveSd: (canonicalUrl) => sdIndex[canonicalUrl],
+    allFs: () => Object.values(fsIndex),
+    allVs: () => Object.values(vsIndex),
+    resolveVs: (canonicalUrl) => vsIndex[canonicalUrl],
+    complexTypeDict: () => complexTypes,
+    resolveAny: (canonicalUrl) => flatRawIndex[canonicalUrl],
+    resolveElementSnapshot,
+    getAllElementKeys
+  };
+};
+var resolveFsElementGenealogy = (genealogy, path) => {
+  const [top, ...rest] = path;
+  if (top === void 0) return [];
+  return genealogy.map((fs3) => {
+    if (!fs3.elements) return void 0;
+    let elem = fs3.elements?.[top];
+    for (const k of rest) {
+      elem = elem?.elements?.[k];
+    }
+    return elem;
+  }).filter((elem) => elem !== void 0);
+};
+function fsElementSnapshot(genealogy) {
+  const snapshot = genealogy.reverse().reduce((snapshot2, elem) => ({ ...snapshot2, ...elem }), {});
+  snapshot.elements = void 0;
+  return snapshot;
+}
 
 // src/typeschema/generator.ts
 var TypeSchemaGenerator = class {
@@ -2522,7 +2562,7 @@ var TypeSchemaGenerator = class {
     if (valueSets.length > 0) {
       this.logger?.debug(`${valueSets.length} ValueSets available for enum extraction`);
     }
-    const register = await registerFromManager(this.manager, logger);
+    const register = await registerFromManager(this.manager, { logger: this.logger });
     const valueSetSchemas = [];
     if (valueSets.length > 0) {
       this.logger?.progress(`Converting ${valueSets.length} ValueSets to TypeSchema`);
@@ -2972,6 +3012,23 @@ 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]));
+}
 
 // src/typeschema/utils.ts
 var groupByPackages = (typeSchemas) => {
@@ -3015,7 +3072,7 @@ var resourceRelatives = (schemas) => {
   }
   return allPairs;
 };
-var mkTypeSchemaIndex = (schemas) => {
+var mkTypeSchemaIndex = (schemas, logger) => {
   const index = {};
   const append = (schema) => {
     const url = schema.identifier.url;
@@ -3036,7 +3093,7 @@ var mkTypeSchemaIndex = (schemas) => {
   const resourceChildren = (id) => {
     return relations.filter((relative2) => relative2.parent.name === id.name).map((relative2) => relative2.child);
   };
-  const hierarchy = (schema) => {
+  const tryHierarchy = (schema) => {
     const res = [];
     let cur = schema;
     while (cur) {
@@ -3045,18 +3102,23 @@ var mkTypeSchemaIndex = (schemas) => {
       if (base === void 0) break;
       const resolved = resolve2(base);
       if (!resolved) {
-        throw new Error(
-          `Failed to resolve base type: ${res.map((e) => `${e.identifier.url} (${e.identifier.kind})`).join(", ")}`
-        );
+        return void 0;
       }
       cur = resolved;
     }
     return res;
   };
+  const hierarchy = (schema) => {
+    const genealogy = tryHierarchy(schema);
+    if (genealogy === void 0) {
+      throw new Error(`Failed to resolve base type: ${schema.identifier.url} (${schema.identifier.kind})`);
+    }
+    return genealogy;
+  };
   const findLastSpecialization = (schema) => {
     const nonConstraintSchema = hierarchy(schema).find((s) => s.identifier.kind !== "profile");
     if (!nonConstraintSchema) {
-      throw new Error(`No non-constraint schema found in hierarchy for ${schema.identifier.name}`);
+      throw new Error(`No non-constraint schema found in hierarchy for: ${schema.identifier.name}`);
     }
     return nonConstraintSchema;
   };
@@ -3096,7 +3158,9 @@ var mkTypeSchemaIndex = (schemas) => {
     };
   };
   const isWithMetaField = (profile) => {
-    return hierarchy(profile).filter(isSpecializationTypeSchema).some((schema) => {
+    const genealogy = tryHierarchy(profile);
+    if (!genealogy) return false;
+    return genealogy.filter(isSpecializationTypeSchema).some((schema) => {
       return schema.fields?.meta !== void 0;
     });
   };
@@ -3109,6 +3173,7 @@ var mkTypeSchemaIndex = (schemas) => {
     collectProfiles: () => schemas.filter(isProfileTypeSchema),
     resolve: resolve2,
     resourceChildren,
+    tryHierarchy,
     hierarchy,
     findLastSpecialization,
     findLastSpecializationByIdentifier,
@@ -5676,7 +5741,7 @@ var writerToGenerator = (writerGen) => {
   };
 };
 var normalizeFileName = (str) => str.replace(/[^a-zA-Z0-9]/g, "");
-var APIBuilder = class {
+var APIBuilder = class _APIBuilder {
   schemas = [];
   options;
   generators = /* @__PURE__ */ new Map();
@@ -5804,33 +5869,53 @@ var APIBuilder = class {
     this.options.typeSchemaOutputDir = target;
     return this;
   }
+  static async isIdenticalTo(path, tsJSON) {
+    if (!await afs.exists(path)) return false;
+    const json = await afs.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 afs.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 = Path2.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 afs.mkdir(Path2.dirname(fullName), { recursive: true });
+      await afs.writeFile(fullName, json);
+    }
+  }
+  async writeTypeSchemasToSingleFile(typeSchemas, outputFile) {
+    if (this.options.cleanOutput && fs.existsSync(outputFile)) fs.rmSync(outputFile);
+    await afs.mkdir(Path2.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 afs.appendFile(outputFile, json + "\n");
+    }
+  }
   async tryWriteTypeSchema(typeSchemas) {
     if (!this.options.typeSchemaOutputDir) return;
     try {
-      if (this.options.cleanOutput) fs.rmSync(this.options.typeSchemaOutputDir, { recursive: true, force: true });
-      await afs.mkdir(this.options.typeSchemaOutputDir, { recursive: true });
-      let writtenCount = 0;
-      let overrideCount = 0;
-      const usedNames = {};
-      this.logger.info(`Writing TypeSchema files to ${this.options.typeSchemaOutputDir}...`);
-      for (const ts of typeSchemas) {
-        const package_name = camelCase(ts.identifier.package.replaceAll("/", "-"));
-        const name = normalizeFileName(ts.identifier.name.toString());
-        const baseName = Path2.join(this.options.typeSchemaOutputDir, 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`;
-        }
-        await afs.mkdir(Path2.dirname(fullName), { recursive: true });
-        afs.writeFile(fullName, JSON.stringify(ts, null, 2));
-        if (await afs.exists(fullName)) overrideCount++;
-        else writtenCount++;
-      }
-      this.logger.info(`Created ${writtenCount} new TypeSchema files, overrode ${overrideCount} files`);
+      this.logger.info(`Starting writing TypeSchema files.`);
+      if (Path2.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(
@@ -5868,7 +5953,7 @@ var APIBuilder = class {
         workingDir: "tmp/fhir"
       });
       await manager.init();
-      const register = await registerFromManager(manager, this.logger);
+      const register = await registerFromManager(manager, { logger: this.logger });
       const typeSchemas = await generateTypeSchemas(register, this.logger);
       await this.tryWriteTypeSchema(typeSchemas);
       this.logger.debug(`Executing ${this.generators.size} generators`);