@atomic-ehr/codegen 0.0.1-canary.20251006094042.7f0be72 → 0.0.1-canary.20251007094146.5297616

package/dist/index.js

@@ -1,8 +1,10 @@
+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 { 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;
@@ -1391,424 +1393,127 @@ var init_IndexBuilder = __esm({
     };
   }
 });
-var TypeSchemaCache = class {
-  cache = /* @__PURE__ */ new Map();
-  config;
-  cacheDir;
-  constructor(config) {
-    this.config = {
-      enablePersistence: true,
-      cacheDir: ".typeschema-cache",
-      maxAge: 24 * 60 * 60 * 1e3,
-      // 24 hours
-      validateCached: true,
-      ...config
-    };
-    if (this.config.enablePersistence && this.config.cacheDir) {
-      this.cacheDir = this.config.cacheDir;
-    }
-  }
-  /**
-   * Store a schema in the cache
-   */
-  async set(schema) {
-    const key = this.generateKey(schema.identifier);
-    this.cache.set(key, schema);
-    if (this.config.enablePersistence && this.cacheDir) {
-      await this.persistSchema(schema);
-    }
-  }
-  /**
-   * Retrieve a schema by identifier
-   */
-  get(identifier) {
-    const key = this.generateKey(identifier);
-    return this.cache.get(key) || null;
-  }
-  /**
-   * Retrieve a schema by URL
-   */
-  getByUrl(url) {
-    for (const schema of this.cache.values()) {
-      if (schema.identifier.url === url) {
-        return schema;
-      }
-    }
-    return null;
-  }
-  /**
-   * Check if a schema exists in cache
-   */
-  has(identifier) {
-    const key = this.generateKey(identifier);
-    return this.cache.has(key);
-  }
-  /**
-   * Check if a schema exists by URL
-   */
-  hasByUrl(url) {
-    for (const schema of this.cache.values()) {
-      if (schema.identifier.url === url) {
-        return true;
-      }
-    }
-    return false;
-  }
-  /**
-   * Delete a schema from cache
-   */
-  delete(identifier) {
-    const key = this.generateKey(identifier);
-    return this.cache.delete(key);
-  }
-  /**
-   * Delete a schema by URL
-   */
-  deleteByUrl(url) {
-    for (const [key, schema] of this.cache.entries()) {
-      if (schema.identifier.url === url) {
-        return this.cache.delete(key);
-      }
-    }
-    return false;
-  }
-  /**
-   * Get schemas by package
-   */
-  getByPackage(packageName) {
-    const results = [];
-    for (const schema of this.cache.values()) {
-      if (schema.identifier.package === packageName) {
-        results.push(schema);
-      }
-    }
-    return results;
-  }
-  /**
-   * Get schemas by kind
-   */
-  getByKind(kind) {
-    const results = [];
-    for (const schema of this.cache.values()) {
-      if (schema.identifier.kind === kind) {
-        results.push(schema);
-      }
-    }
-    return results;
-  }
-  /**
-   * Store multiple schemas
-   */
-  setMany(schemas) {
-    for (const schema of schemas) {
-      this.set(schema);
-    }
-  }
-  /**
-   * Clear all cached schemas
-   */
-  clear() {
-    this.cache.clear();
-  }
-  /**
-   * Generate cache key for identifier
-   */
-  generateKey(identifier) {
-    return `${identifier.package}:${identifier.version}:${identifier.kind}:${identifier.name}`;
+
+// src/typeschema/types.ts
+var packageMetaToFhir = (packageMeta) => `${packageMeta.name}#${packageMeta.version}`;
+var packageMetaToNpm = (packageMeta) => `${packageMeta.name}@${packageMeta.version}`;
+var enrichFHIRSchema = (schema, packageMeta) => {
+  if (!packageMeta) {
+    packageMeta = { name: "undefined", version: "undefined" };
   }
-  /**
-   * Initialize cache directory if persistence is enabled
-   */
-  async initialize() {
-    if (this.config.enablePersistence && this.cacheDir) {
-      if (!existsSync(this.cacheDir)) {
-        mkdirSync(this.cacheDir, { recursive: true });
-      }
-      await this.loadFromDisk();
+  return {
+    ...schema,
+    package_meta: schema.package_meta || packageMeta,
+    name: schema.name,
+    url: schema.url,
+    base: schema.base
+  };
+};
+function isBindingSchema(schema) {
+  return schema.identifier.kind === "binding";
+}
+
+// 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 index = {};
+    for (const resource of resources) {
+      const url = resource.url;
+      if (!url) continue;
+      index[url] = resource;
+      flatRawIndex[url] = resource;
     }
+    indexByPackages.push({
+      package_meta: pkg,
+      index
+    });
   }
-  /**
-   * Load all cached schemas from disk
-   */
-  async loadFromDisk() {
-    if (!this.cacheDir || !existsSync(this.cacheDir)) {
-      return;
-    }
-    try {
-      const files = await readdir(this.cacheDir);
-      const schemaFiles = files.filter((f) => f.endsWith(".typeschema.json"));
-      for (const file of schemaFiles) {
-        const filePath = join(this.cacheDir, file);
-        const stats = await stat(filePath);
-        if (this.config.maxAge) {
-          const age = Date.now() - stats.mtimeMs;
-          if (age > this.config.maxAge) {
-            await unlink(filePath);
-            continue;
-          }
-        }
+  const sdIndex = {};
+  const vsIndex = {};
+  const fsIndex = {};
+  const nameToCanonical = {};
+  let [fsSuccess, fsFailed] = [0, 0];
+  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;
         try {
-          const content = await readFile(filePath, "utf-8");
-          const metadata = JSON.parse(content);
-          if (this.config.validateCached) {
-            if (!metadata.schema?.identifier) {
-              continue;
-            }
-          }
-          const key = this.generateKey(metadata.schema.identifier);
-          this.cache.set(key, metadata.schema);
+          const rfs = enrichFHIRSchema(fhirschema.translate(sd), packageMeta);
+          fsIndex[rfs.url] = rfs;
+          nameToCanonical[rfs.name] = rfs.url;
+          fsSuccess++;
         } catch (error) {
-          console.warn(`Failed to load cached schema from ${file}:`, error);
+          logger?.warn(
+            `Failed to convert StructureDefinition ${sd.name || sd.id}: ${error instanceof Error ? error.message : String(error)}`
+          );
+          fsFailed++;
         }
       }
-    } catch (error) {
-      console.warn("Failed to load cached schemas from disk:", error);
-    }
-  }
-  /**
-   * Persist a schema to disk
-   */
-  async persistSchema(schema) {
-    if (!this.cacheDir) {
-      return;
-    }
-    if (!existsSync(this.cacheDir)) {
-      mkdirSync(this.cacheDir, { recursive: true });
+      if (resource.resourceType === "ValueSet") {
+        if (!resource.package_meta) {
+          resource.package_meta = packageMeta;
+        }
+        vsIndex[resource.url] = resource;
+      }
     }
-    const metadata = {
-      schema,
-      timestamp: Date.now(),
-      version: schema.identifier.version
-    };
-    const fileName = `${schema.identifier.package}-${schema.identifier.version}-${schema.identifier.kind}-${schema.identifier.name}.typeschema.json`.replace(
-      /[^a-zA-Z0-9.-]/g,
-      "_"
+    logger?.success(
+      `FHIR Schema conversion for '${packageMetaToFhir(packageMeta)}' completed: ${fsSuccess} successful, ${fsFailed} failed`
     );
-    const filePath = join(this.cacheDir, fileName);
-    try {
-      await writeFile(filePath, JSON.stringify(metadata, null, 2), "utf-8");
-    } catch (error) {
-      console.warn(`Failed to persist schema to ${filePath}:`, error);
+  }
+  const complexTypes = {};
+  for (const fs2 of Object.values(fsIndex)) {
+    if (fs2.kind === "complex-type") {
+      complexTypes[fs2.url] = fs2;
     }
   }
-  /**
-   * Clear cache directory
-   */
-  async clearDisk() {
-    if (!this.cacheDir || !existsSync(this.cacheDir)) {
-      return;
+  const resolveFsGenealogy = (canonicalUrl) => {
+    let fs2 = fsIndex[canonicalUrl];
+    if (fs2 === void 0) throw new Error(`Failed to resolve FHIR Schema genealogy for '${canonicalUrl}'`);
+    const genealogy = [fs2];
+    while (fs2?.base) {
+      fs2 = fsIndex[fs2.base] || fsIndex[nameToCanonical[fs2.base]];
+      genealogy.push(fs2);
+      if (fs2 === void 0) throw new Error(`Failed to resolve FHIR Schema genealogy for '${canonicalUrl}'`);
     }
-    try {
-      const files = await readdir(this.cacheDir);
-      const schemaFiles = files.filter((f) => f.endsWith(".typeschema.json"));
-      for (const file of schemaFiles) {
-        await unlink(join(this.cacheDir, file));
-      }
-    } catch (error) {
-      console.warn("Failed to clear cache directory:", error);
+    return genealogy;
+  };
+  return {
+    ...manager,
+    appendFs(fs2) {
+      const rfs = enrichFHIRSchema(fs2);
+      fsIndex[rfs.url] = rfs;
+      nameToCanonical[rfs.name] = rfs.url;
+    },
+    resolveFs: (canonicalUrl) => fsIndex[canonicalUrl],
+    resolveFsGenealogy,
+    ensureCanonicalUrl: (name) => nameToCanonical[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((fs2) => {
+    if (!fs2.elements) return void 0;
+    let elem = fs2.elements?.[top];
+    for (const k of rest) {
+      elem = elem?.elements?.[k];
     }
-  }
-};
-var CodegenLogger = class _CodegenLogger {
-  options;
-  constructor(options = {}) {
-    this.options = {
-      timestamp: false,
-      verbose: false,
-      ...options
-    };
-  }
-  formatMessage(level, message, color) {
-    const timestamp = this.options.timestamp ? `${pc.gray((/* @__PURE__ */ new Date()).toLocaleTimeString())} ` : "";
-    const prefix = this.options.prefix ? `${pc.cyan(`[${this.options.prefix}]`)} ` : "";
-    return `${timestamp}${color(level)} ${prefix}${message}`;
-  }
-  /**
-   * Success message with checkmark
-   */
-  success(message) {
-    console.log(this.formatMessage("\u2705", message, pc.green));
-  }
-  /**
-   * Error message with X mark
-   */
-  error(message, error) {
-    console.error(this.formatMessage("\u274C", message, pc.red));
-    if (error && this.options.verbose) {
-      console.error(pc.red(`   ${error.message}`));
-      if (error.stack) {
-        console.error(pc.gray(error.stack));
-      }
-    }
-  }
-  /**
-   * Warning message with warning sign
-   */
-  warn(message) {
-    console.warn(this.formatMessage("\u26A0\uFE0F", message, pc.yellow));
-  }
-  /**
-   * Info message with info icon
-   */
-  info(message) {
-    console.log(this.formatMessage("\u2139\uFE0F", message, pc.blue));
-  }
-  /**
-   * Debug message (only shows in verbose mode)
-   */
-  debug(message) {
-    if (this.options.verbose) {
-      console.log(this.formatMessage("\u{1F41B}", message, pc.magenta));
-    }
-  }
-  /**
-   * Step message with rocket
-   */
-  step(message) {
-    console.log(this.formatMessage("\u{1F680}", message, pc.cyan));
-  }
-  /**
-   * Progress message with clock
-   */
-  progress(message) {
-    console.log(this.formatMessage("\u23F3", message, pc.blue));
-  }
-  /**
-   * Plain message (no icon, just colored text)
-   */
-  plain(message, color = (s) => s) {
-    const timestamp = this.options.timestamp ? `${pc.gray((/* @__PURE__ */ new Date()).toLocaleTimeString())} ` : "";
-    const prefix = this.options.prefix ? `${pc.cyan(`[${this.options.prefix}]`)} ` : "";
-    console.log(`${timestamp}${prefix}${color(message)}`);
-  }
-  /**
-   * Dimmed/gray text for less important info
-   */
-  dim(message) {
-    this.plain(message, pc.gray);
-  }
-  /**
-   * Create a child logger with a prefix
-   */
-  child(prefix) {
-    return new _CodegenLogger({
-      ...this.options,
-      prefix: this.options.prefix ? `${this.options.prefix}:${prefix}` : prefix
-    });
-  }
-  /**
-   * Update options
-   */
-  configure(options) {
-    this.options = { ...this.options, ...options };
-  }
-};
-new CodegenLogger();
-function createLogger(options = {}) {
-  return new CodegenLogger(options);
-}
-
-// src/typeschema/types.ts
-var enrichFHIRSchema = (schema, packageMeta) => {
-  if (!packageMeta) {
-    packageMeta = { name: "undefined", version: "undefined" };
-  }
-  return {
-    ...schema,
-    package_meta: schema.package_meta || packageMeta,
-    name: schema.name,
-    url: schema.url,
-    base: schema.base
-  };
-};
-function isBindingSchema(schema) {
-  return schema.identifier.kind === "binding";
-}
-
-// src/typeschema/register.ts
-var registerFromManager = async (manager, logger, packageInfo) => {
-  const resources = await manager.search({});
-  const any = {};
-  for (const resource of resources) {
-    const url = resource.url;
-    if (!url) continue;
-    any[url] = resource;
-  }
-  const structureDefinitions = {};
-  for (const resource of resources) {
-    if (resource.resourceType === "StructureDefinition") {
-      const url = resource.url;
-      structureDefinitions[url] = resource;
-    }
-  }
-  const fhirSchemas = {};
-  const nameDict = {};
-  let [success] = [0, 0];
-  for (const sd of Object.values(structureDefinitions)) {
-    try {
-      const rfs = enrichFHIRSchema(fhirschema.translate(sd), packageInfo);
-      fhirSchemas[rfs.url] = rfs;
-      nameDict[rfs.name] = rfs.url;
-      success++;
-    } catch (error) {
-    }
-  }
-  const valueSets = {};
-  for (const resource of resources) {
-    if (resource.resourceType === "ValueSet") {
-      if (!resource.package_meta) {
-        resource.package_meta = packageInfo;
-      }
-      valueSets[resource.url] = resource;
-    }
-  }
-  const complexTypes = {};
-  for (const fs of Object.values(fhirSchemas)) {
-    if (fs.kind === "complex-type") {
-      complexTypes[fs.url] = fs;
-    }
-  }
-  const resolveFsGenealogy = (canonicalUrl) => {
-    let fs = fhirSchemas[canonicalUrl];
-    if (fs === void 0) throw new Error(`Failed to resolve FHIR Schema genealogy for '${canonicalUrl}'`);
-    const genealogy = [fs];
-    while (fs?.base) {
-      fs = fhirSchemas[fs.base] || fhirSchemas[nameDict[fs.base]];
-      genealogy.push(fs);
-      if (fs === void 0) throw new Error(`Failed to resolve FHIR Schema genealogy for '${canonicalUrl}'`);
-    }
-    return genealogy;
-  };
-  return {
-    ...manager,
-    appendFs(fs) {
-      const rfs = enrichFHIRSchema(fs);
-      fhirSchemas[rfs.url] = rfs;
-      nameDict[rfs.name] = rfs.url;
-    },
-    resolveFs: (canonicalUrl) => fhirSchemas[canonicalUrl],
-    resolveFsGenealogy,
-    ensureCanonicalUrl: (name) => nameDict[name] || name,
-    allSd: () => Object.values(structureDefinitions),
-    resolveSd: (canonicalUrl) => structureDefinitions[canonicalUrl],
-    allFs: () => Object.values(fhirSchemas),
-    allVs: () => Object.values(valueSets),
-    resolveVs: (canonicalUrl) => valueSets[canonicalUrl],
-    complexTypeDict: () => complexTypes,
-    resolveAny: (canonicalUrl) => any[canonicalUrl]
-  };
-};
-var resolveFsElementGenealogy = (genealogy, path) => {
-  const [top, ...rest] = path;
-  if (top === void 0) return [];
-  return genealogy.map((fs) => {
-    if (!fs.elements) return void 0;
-    let elem = fs.elements?.[top];
-    for (const k of rest) {
-      elem = elem?.elements?.[k];
-    }
-    return elem;
-  }).filter((elem) => elem !== void 0);
+    return elem;
+  }).filter((elem) => elem !== void 0);
 };
 function fsElementSnapshot(genealogy) {
   const snapshot = genealogy.reverse().reduce((snapshot2, elem) => ({ ...snapshot2, ...elem }), {});
@@ -1872,8 +1577,8 @@ function mkValueSetIdentifierByUrl(register, fullValueSetUrl) {
   const valueSetName = valueSet?.id && !/^[a-zA-Z0-9_-]{20,}$/.test(valueSet.id) ? valueSet.id : valueSetNameFallback;
   return {
     kind: "value-set",
-    package: valueSet?.package_meta.name,
-    version: valueSet?.package_meta.version,
+    package: valueSet.package_meta.name,
+    version: valueSet.package_meta.version,
     name: valueSetName,
     url: valueSetUrl
   };
@@ -2062,10 +1767,10 @@ function extractValidationRules(fhirSchema) {
 function isRequired(register, fhirSchema, path) {
   const fieldName = path[path.length - 1];
   const parentPath = path.slice(0, -1);
-  const requires = register.resolveFsGenealogy(fhirSchema.url).flatMap((fs) => {
-    if (parentPath.length === 0) return fs.required || [];
-    if (!fs.elements) return [];
-    let elem = fs;
+  const requires = register.resolveFsGenealogy(fhirSchema.url).flatMap((fs2) => {
+    if (parentPath.length === 0) return fs2.required || [];
+    if (!fs2.elements) return [];
+    let elem = fs2;
     for (const k of parentPath) {
       elem = elem?.elements?.[k];
     }
@@ -2077,10 +1782,10 @@ function isExcluded(register, fhirSchema, path) {
   const fieldName = path[path.length - 1];
   if (!fieldName) throw new Error(`Internal error: fieldName is missing for path ${path.join("/")}`);
   const parentPath = path.slice(0, -1);
-  const requires = register.resolveFsGenealogy(fhirSchema.url).flatMap((fs) => {
-    if (parentPath.length === 0) return fs.excluded || [];
-    if (!fs.elements) return [];
-    let elem = fs;
+  const requires = register.resolveFsGenealogy(fhirSchema.url).flatMap((fs2) => {
+    if (parentPath.length === 0) return fs2.excluded || [];
+    if (!fs2.elements) return [];
+    let elem = fs2;
     for (const k of parentPath) {
       elem = elem?.elements?.[k];
     }
@@ -2092,8 +1797,8 @@ var buildReferences = (element, register, _packageInfo) => {
   if (!element.refers) return void 0;
   return element.refers.map((ref) => {
     const curl = register.ensureCanonicalUrl(ref);
-    const fs = register.resolveFs(curl);
-    return mkIdentifier(fs);
+    const fs2 = register.resolveFs(curl);
+    return mkIdentifier(fs2);
   });
 };
 function buildFieldType(register, fhirSchema, element) {
@@ -2216,7 +1921,7 @@ function buildEnum(register, element) {
   const codes = concepts.map((c) => c.code).filter((code) => code && typeof code === "string" && code.trim().length > 0);
   if (codes.length > MAX_ENUM_LENGTH) {
     console.warn(
-      `Value set ${valueSetUrl} has more than ${MAX_ENUM_LENGTH} codes, which may cause issues with code generation.`
+      `Value set ${valueSetUrl} has ${codes.length} which is more than ${MAX_ENUM_LENGTH} codes, which may cause issues with code generation.`
     );
     return void 0;
   }
@@ -2483,75 +2188,391 @@ async function transformExtension(fhirSchema, register, _packageInfo) {
         extensionSchema.dependencies.push(...extractFieldDependencies(fields));
       }
     }
-    const nestedTypes = mkNestedTypes(register, fhirSchema);
-    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;
+    const nestedTypes = mkNestedTypes(register, fhirSchema);
+    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);
+  if (fields) deps.push(...extractFieldDependencies(fields));
+  if (nestedTypes) deps.push(...extractNestedDependencies(nestedTypes));
+  const uniqDeps = {};
+  for (const dep of deps) {
+    if (dep.url === identifier.url) continue;
+    uniqDeps[dep.url] = dep;
+  }
+  const localNestedTypeUrls = new Set(nestedTypes?.map((nt) => nt.identifier.url));
+  const result = Object.values(uniqDeps).filter((e) => !(e.kind === "nested" && localNestedTypeUrls.has(e.url))).sort((a, b) => a.url.localeCompare(b.url));
+  return result.length > 0 ? result : void 0;
+}
+function transformFhirSchemaResource(register, fhirSchema) {
+  const identifier = mkIdentifier(fhirSchema);
+  let base;
+  if (fhirSchema.base && fhirSchema.type !== "Element") {
+    const baseFs = register.resolveFs(register.ensureCanonicalUrl(fhirSchema.base));
+    if (!baseFs) {
+      throw new Error(`Base resource not found '${fhirSchema.base}' for '${fhirSchema.url}'`);
+    }
+    base = mkIdentifier(baseFs);
+  }
+  const fields = mkFields(register, fhirSchema, [], fhirSchema.elements);
+  const nested = mkNestedTypes(register, fhirSchema);
+  const dependencies = extractDependencies(identifier, base, fields, nested);
+  const typeSchema = {
+    identifier,
+    base,
+    fields,
+    nested,
+    description: fhirSchema.description,
+    dependencies
+  };
+  const bindingSchemas = collectBindingSchemas(register, fhirSchema);
+  return [typeSchema, ...bindingSchemas];
+}
+async function transformFhirSchema(register, fhirSchema) {
+  const results = [];
+  const identifier = mkIdentifier(fhirSchema);
+  if (identifier.kind === "profile") {
+    const profileSchema = await transformProfile(register, fhirSchema);
+    results.push(profileSchema);
+    const bindingSchemas = collectBindingSchemas(register, fhirSchema);
+    results.push(...bindingSchemas);
+    return results;
+  }
+  if (isExtensionSchema(fhirSchema)) {
+    const extensionSchema = await transformExtension(fhirSchema, register, fhirSchema.package_meta);
+    if (extensionSchema) {
+      results.push(extensionSchema);
+    }
+    return results;
+  }
+  return transformFhirSchemaResource(register, fhirSchema);
+}
+var TypeSchemaCache = class {
+  cache = /* @__PURE__ */ new Map();
+  config;
+  cacheDir;
+  constructor(config) {
+    this.config = {
+      enablePersistence: true,
+      cacheDir: ".typeschema-cache",
+      maxAge: 24 * 60 * 60 * 1e3,
+      // 24 hours
+      validateCached: true,
+      ...config
+    };
+    if (this.config.enablePersistence && this.config.cacheDir) {
+      this.cacheDir = this.config.cacheDir;
+    }
+  }
+  /**
+   * Store a schema in the cache
+   */
+  async set(schema) {
+    const key = this.generateKey(schema.identifier);
+    this.cache.set(key, schema);
+    if (this.config.enablePersistence && this.cacheDir) {
+      await this.persistSchema(schema);
+    }
+  }
+  /**
+   * Retrieve a schema by identifier
+   */
+  get(identifier) {
+    const key = this.generateKey(identifier);
+    return this.cache.get(key) || null;
+  }
+  /**
+   * Retrieve a schema by URL
+   */
+  getByUrl(url) {
+    for (const schema of this.cache.values()) {
+      if (schema.identifier.url === url) {
+        return schema;
+      }
+    }
+    return null;
+  }
+  /**
+   * Check if a schema exists in cache
+   */
+  has(identifier) {
+    const key = this.generateKey(identifier);
+    return this.cache.has(key);
+  }
+  /**
+   * Check if a schema exists by URL
+   */
+  hasByUrl(url) {
+    for (const schema of this.cache.values()) {
+      if (schema.identifier.url === url) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Delete a schema from cache
+   */
+  delete(identifier) {
+    const key = this.generateKey(identifier);
+    return this.cache.delete(key);
+  }
+  /**
+   * Delete a schema by URL
+   */
+  deleteByUrl(url) {
+    for (const [key, schema] of this.cache.entries()) {
+      if (schema.identifier.url === url) {
+        return this.cache.delete(key);
+      }
+    }
+    return false;
+  }
+  /**
+   * Get schemas by package
+   */
+  getByPackage(packageName) {
+    const results = [];
+    for (const schema of this.cache.values()) {
+      if (schema.identifier.package === packageName) {
+        results.push(schema);
+      }
+    }
+    return results;
+  }
+  /**
+   * Get schemas by kind
+   */
+  getByKind(kind) {
+    const results = [];
+    for (const schema of this.cache.values()) {
+      if (schema.identifier.kind === kind) {
+        results.push(schema);
+      }
+    }
+    return results;
+  }
+  /**
+   * Store multiple schemas
+   */
+  setMany(schemas) {
+    for (const schema of schemas) {
+      this.set(schema);
+    }
+  }
+  /**
+   * Clear all cached schemas
+   */
+  clear() {
+    this.cache.clear();
+  }
+  /**
+   * Generate cache key for identifier
+   */
+  generateKey(identifier) {
+    return `${identifier.package}:${identifier.version}:${identifier.kind}:${identifier.name}`;
+  }
+  /**
+   * Initialize cache directory if persistence is enabled
+   */
+  async initialize() {
+    if (this.config.enablePersistence && this.cacheDir) {
+      if (!existsSync(this.cacheDir)) {
+        mkdirSync(this.cacheDir, { recursive: true });
+      }
+      await this.loadFromDisk();
+    }
+  }
+  /**
+   * Load all cached schemas from disk
+   */
+  async loadFromDisk() {
+    if (!this.cacheDir || !existsSync(this.cacheDir)) {
+      return;
+    }
+    try {
+      const files = await readdir(this.cacheDir);
+      const schemaFiles = files.filter((f) => f.endsWith(".typeschema.json"));
+      for (const file of schemaFiles) {
+        const filePath = join(this.cacheDir, file);
+        const stats = await stat(filePath);
+        if (this.config.maxAge) {
+          const age = Date.now() - stats.mtimeMs;
+          if (age > this.config.maxAge) {
+            await unlink(filePath);
+            continue;
+          }
+        }
+        try {
+          const content = await readFile(filePath, "utf-8");
+          const metadata = JSON.parse(content);
+          if (this.config.validateCached) {
+            if (!metadata.schema?.identifier) {
+              continue;
+            }
+          }
+          const key = this.generateKey(metadata.schema.identifier);
+          this.cache.set(key, metadata.schema);
+        } catch (error) {
+          console.warn(`Failed to load cached schema from ${file}:`, error);
+        }
+      }
+    } catch (error) {
+      console.warn("Failed to load cached schemas from disk:", error);
+    }
+  }
+  /**
+   * Persist a schema to disk
+   */
+  async persistSchema(schema) {
+    if (!this.cacheDir) {
+      return;
+    }
+    if (!existsSync(this.cacheDir)) {
+      mkdirSync(this.cacheDir, { recursive: true });
+    }
+    const metadata = {
+      schema,
+      timestamp: Date.now(),
+      version: schema.identifier.version
+    };
+    const fileName = `${schema.identifier.package}-${schema.identifier.version}-${schema.identifier.kind}-${schema.identifier.name}.typeschema.json`.replace(
+      /[^a-zA-Z0-9.-]/g,
+      "_"
+    );
+    const filePath = join(this.cacheDir, fileName);
+    try {
+      await writeFile(filePath, JSON.stringify(metadata, null, 2), "utf-8");
+    } catch (error) {
+      console.warn(`Failed to persist schema to ${filePath}:`, error);
+    }
+  }
+  /**
+   * Clear cache directory
+   */
+  async clearDisk() {
+    if (!this.cacheDir || !existsSync(this.cacheDir)) {
+      return;
+    }
+    try {
+      const files = await readdir(this.cacheDir);
+      const schemaFiles = files.filter((f) => f.endsWith(".typeschema.json"));
+      for (const file of schemaFiles) {
+        await unlink(join(this.cacheDir, file));
+      }
+    } catch (error) {
+      console.warn("Failed to clear cache directory:", error);
+    }
   }
-}
-function extractDependencies(identifier, base, fields, nestedTypes) {
-  const deps = [];
-  if (base) deps.push(base);
-  if (fields) deps.push(...extractFieldDependencies(fields));
-  if (nestedTypes) deps.push(...extractNestedDependencies(nestedTypes));
-  const uniqDeps = {};
-  for (const dep of deps) {
-    if (dep.url === identifier.url) continue;
-    uniqDeps[dep.url] = dep;
+};
+var CodegenLogger = class _CodegenLogger {
+  options;
+  constructor(options = {}) {
+    this.options = {
+      timestamp: false,
+      verbose: false,
+      ...options
+    };
   }
-  const localNestedTypeUrls = new Set(nestedTypes?.map((nt) => nt.identifier.url));
-  const result = Object.values(uniqDeps).filter((e) => !(e.kind === "nested" && localNestedTypeUrls.has(e.url))).sort((a, b) => a.url.localeCompare(b.url));
-  return result.length > 0 ? result : void 0;
-}
-function transformFhirSchemaResource(register, fhirSchema) {
-  const identifier = mkIdentifier(fhirSchema);
-  let base;
-  if (fhirSchema.base && fhirSchema.type !== "Element") {
-    const baseFs = register.resolveFs(register.ensureCanonicalUrl(fhirSchema.base));
-    if (!baseFs) {
-      throw new Error(`Base resource not found '${fhirSchema.base}' for '${fhirSchema.url}'`);
+  formatMessage(level, message, color) {
+    const timestamp = this.options.timestamp ? `${pc.gray((/* @__PURE__ */ new Date()).toLocaleTimeString())} ` : "";
+    const prefix = this.options.prefix ? `${pc.cyan(`[${this.options.prefix}]`)} ` : "";
+    return `${timestamp}${color(level)} ${prefix}${message}`;
+  }
+  /**
+   * Success message with checkmark
+   */
+  success(message) {
+    console.log(this.formatMessage("\u2705", message, pc.green));
+  }
+  /**
+   * Error message with X mark
+   */
+  error(message, error) {
+    console.error(this.formatMessage("\u274C", message, pc.red));
+    if (error && this.options.verbose) {
+      console.error(pc.red(`   ${error.message}`));
+      if (error.stack) {
+        console.error(pc.gray(error.stack));
+      }
     }
-    base = mkIdentifier(baseFs);
   }
-  const fields = mkFields(register, fhirSchema, [], fhirSchema.elements);
-  const nested = mkNestedTypes(register, fhirSchema);
-  const dependencies = extractDependencies(identifier, base, fields, nested);
-  const typeSchema = {
-    identifier,
-    base,
-    fields,
-    nested,
-    description: fhirSchema.description,
-    dependencies
-  };
-  const bindingSchemas = collectBindingSchemas(register, fhirSchema);
-  return [typeSchema, ...bindingSchemas];
-}
-async function transformFhirSchema(register, fhirSchema) {
-  const results = [];
-  const identifier = mkIdentifier(fhirSchema);
-  if (identifier.kind === "profile") {
-    const profileSchema = await transformProfile(register, fhirSchema);
-    results.push(profileSchema);
-    const bindingSchemas = collectBindingSchemas(register, fhirSchema);
-    results.push(...bindingSchemas);
-    return results;
+  /**
+   * Warning message with warning sign
+   */
+  warn(message) {
+    console.warn(this.formatMessage("\u26A0\uFE0F", message, pc.yellow));
   }
-  if (isExtensionSchema(fhirSchema)) {
-    const extensionSchema = await transformExtension(fhirSchema, register, fhirSchema.package_meta);
-    if (extensionSchema) {
-      results.push(extensionSchema);
+  /**
+   * Info message with info icon
+   */
+  info(message) {
+    console.log(this.formatMessage("\u2139\uFE0F", message, pc.blue));
+  }
+  /**
+   * Debug message (only shows in verbose mode)
+   */
+  debug(message) {
+    if (this.options.verbose) {
+      console.log(this.formatMessage("\u{1F41B}", message, pc.magenta));
     }
-    return results;
   }
-  return transformFhirSchemaResource(register, fhirSchema);
+  /**
+   * Step message with rocket
+   */
+  step(message) {
+    console.log(this.formatMessage("\u{1F680}", message, pc.cyan));
+  }
+  /**
+   * Progress message with clock
+   */
+  progress(message) {
+    console.log(this.formatMessage("\u23F3", message, pc.blue));
+  }
+  /**
+   * Plain message (no icon, just colored text)
+   */
+  plain(message, color = (s) => s) {
+    const timestamp = this.options.timestamp ? `${pc.gray((/* @__PURE__ */ new Date()).toLocaleTimeString())} ` : "";
+    const prefix = this.options.prefix ? `${pc.cyan(`[${this.options.prefix}]`)} ` : "";
+    console.log(`${timestamp}${prefix}${color(message)}`);
+  }
+  /**
+   * Dimmed/gray text for less important info
+   */
+  dim(message) {
+    this.plain(message, pc.gray);
+  }
+  /**
+   * Create a child logger with a prefix
+   */
+  child(prefix) {
+    return new _CodegenLogger({
+      ...this.options,
+      prefix: this.options.prefix ? `${this.options.prefix}:${prefix}` : prefix
+    });
+  }
+  /**
+   * Update options
+   */
+  configure(options) {
+    this.options = { ...this.options, ...options };
+  }
+};
+new CodegenLogger();
+function createLogger(options = {}) {
+  return new CodegenLogger(options);
 }
 
 // src/typeschema/generator.ts
@@ -2606,10 +2627,11 @@ var TypeSchemaGenerator = class {
     );
     return fhirSchemas;
   }
-  async generateValueSetSchemas(valueSets, _packageInfo) {
+  async generateValueSetSchemas(valueSets) {
     if (valueSets.length > 0) {
       this.logger.debug(`${valueSets.length} ValueSets available for enum extraction`);
     }
+    const register = await registerFromManager(this.manager);
     const valueSetSchemas = [];
     if (valueSets.length > 0) {
       this.logger.progress(`Converting ${valueSets.length} ValueSets to TypeSchema`);
@@ -2617,7 +2639,7 @@ var TypeSchemaGenerator = class {
       let valueSetFailedCount = 0;
       for (const vs of valueSets) {
         try {
-          const valueSetSchema = await transformValueSet(await registerFromManager(this.manager), vs);
+          const valueSetSchema = await transformValueSet(register, vs);
           if (valueSetSchema) {
             valueSetSchemas.push(valueSetSchema);
             valueSetConvertedCount++;
@@ -2652,10 +2674,10 @@ var TypeSchemaGenerator = class {
       version: packageVersion || "latest"
     };
     const register = await this.registerFromPackageMetas([packageInfo]);
-    const allSchemas = [
-      ...(await Promise.all(register.allFs().map(async (fs) => await transformFhirSchema(register, fs)))).flat(),
-      ...await this.generateValueSetSchemas(register.allVs(), packageInfo)
-    ];
+    const valueSets = await this.generateValueSetSchemas(register.allVs());
+    const fhirSchemas = (await Promise.all(register.allFs().map(async (fs2) => await transformFhirSchema(register, fs2)))).flat();
+    const allSchemas = [...fhirSchemas, ...valueSets];
+    console.debug(111);
     if (this.cache) {
       for (const schema of allSchemas) {
         await this.cache.set(schema);
@@ -3022,6 +3044,18 @@ var TypeSchemaParser = class {
   }
 };
 
+// src/typeschema/index.ts
+var generateTypeSchemas = async (register) => {
+  const fhirSchemas = [];
+  for (const fhirSchema of register.allFs()) {
+    fhirSchemas.push(...await transformFhirSchema(register, fhirSchema));
+  }
+  for (const vsSchema of register.allVs()) {
+    fhirSchemas.push(await transformValueSet(register, vsSchema));
+  }
+  return fhirSchemas;
+};
+
 // src/api/generators/base/error-handler.ts
 init_errors();
 var ErrorHandler = class {
@@ -5046,26 +5080,249 @@ ${nestedInterfaces}`;
   }
 };
 
+// src/api/writer-generator/utils.ts
+var words = (s) => {
+  return s.split(/(?<=[a-z])(?=[A-Z])|[-_.\s]/).filter(Boolean);
+};
+var kebabCase = (s) => {
+  return words(s).map((s2) => s2.toLowerCase()).join("-");
+};
+var capitalCase = (s) => {
+  if (s.length === 0) throw new Error("Empty string");
+  return s[0]?.toUpperCase() + s.substring(1).toLowerCase();
+};
+var pascalCase = (s) => {
+  return words(s).map(capitalCase).join("");
+};
+var FileSystemWriter = class {
+  opts;
+  currentDir;
+  currentFileDescriptor;
+  writtenFilesSet = /* @__PURE__ */ new Set();
+  constructor(opts) {
+    this.opts = opts;
+    this.currentDir = opts.outputDir;
+  }
+  logger() {
+    return this.opts.logger;
+  }
+  cd(path, gen) {
+    this.currentDir = path.startsWith("/") ? Path2.join(this.opts.outputDir, path) : Path2.join(this.currentDir, path);
+    if (!fs.existsSync(this.currentDir)) {
+      fs.mkdirSync(this.currentDir, { recursive: true });
+    }
+    this.logger()?.debug(`cd '${this.currentDir}'`);
+    gen();
+  }
+  cat(fn, gen) {
+    if (this.currentFileDescriptor) throw new Error("Can't open file in file");
+    if (fn.includes("/")) throw new Error(`Change file path separatly: ${fn}`);
+    const fullFn = `${this.currentDir}/${fn}`;
+    try {
+      this.currentFileDescriptor = fs.openSync(fn, "w");
+      this.writtenFilesSet.add(fn);
+      this.logger()?.debug(`cat > '${fullFn}'`);
+      gen();
+    } finally {
+      if (this.currentFileDescriptor) {
+        fs.closeSync(this.currentFileDescriptor);
+      }
+      this.currentFileDescriptor = void 0;
+    }
+  }
+  write(str) {
+    if (!this.currentFileDescriptor) throw new Error("No file opened");
+    fs.writeSync(this.currentFileDescriptor, str);
+  }
+  generate(_schemas) {
+    throw new Error("Not implemented");
+  }
+  writtenFiles() {
+    return Array.from(this.writtenFilesSet);
+  }
+};
+var Writer = class extends FileSystemWriter {
+  currentIndent = 0;
+  indent() {
+    this.currentIndent += this.opts.tabSize;
+  }
+  deindent() {
+    this.currentIndent -= this.opts.tabSize;
+  }
+  writeIndent() {
+    this.write(" ".repeat(this.currentIndent));
+  }
+  line(...tokens) {
+    this.writeIndent();
+    this.write(`${tokens.join(" ")}
+`);
+  }
+  lineSM(...tokens) {
+    this.writeIndent();
+    this.write(`${tokens.join(" ")};
+`);
+  }
+  comment(...tokens) {
+    const lines = tokens.join(" ").split("\n");
+    for (const line of lines) {
+      this.line(this.opts.commentLinePrefix, line);
+    }
+  }
+  debugComment(...tokens) {
+    if (this.opts.withDebugComment) {
+      tokens = tokens.map((token) => {
+        if (typeof token === "string") {
+          return token;
+        } else {
+          return JSON.stringify(token, null, 2);
+        }
+      });
+      this.comment(...tokens);
+    }
+  }
+  curlyBlock(tokens, gencontent, endTokens) {
+    this.line(`${tokens.filter(Boolean).join(" ")} {`);
+    this.indent();
+    gencontent();
+    this.deindent();
+    this.line(`}${endTokens?.filter(Boolean).join(" ") ?? ""}`);
+  }
+  squareBlock(tokens, gencontent, endTokens) {
+    this.line(`${tokens.filter(Boolean).join(" ")} [`);
+    this.indent();
+    gencontent();
+    this.deindent();
+    this.line(`]${endTokens?.filter(Boolean).join(" ") ?? ""}`);
+  }
+};
+
+// src/api/writer-generator/typescript.ts
+var collectComplexTypes = (tss) => tss.filter((t) => t.identifier.kind === "complex-type");
+var collectResources = (tss) => tss.filter((t) => t.identifier.kind === "resource");
+var groupByPackages = (typeSchemas) => {
+  const grouped = {};
+  for (const ts of typeSchemas) {
+    const packageName = ts.identifier.package;
+    if (!grouped[packageName]) {
+      grouped[packageName] = [];
+    }
+    grouped[packageName].push(ts);
+  }
+  for (const [_packageName, typeSchemas2] of Object.entries(grouped)) {
+    typeSchemas2.sort((a, b) => a.identifier.name.localeCompare(b.identifier.name));
+  }
+  return grouped;
+};
+var fileNameStem = (id) => {
+  return pascalCase(id.name);
+};
+var normalizeName = (n) => {
+  if (n === "extends") {
+    return "extends_";
+  }
+  return n.replace(/[- ]/g, "_");
+};
+var resourceName = (id) => {
+  return normalizeName(id.name);
+};
+var TypeScript = class extends Writer {
+  tsImportFrom(tsPackage, ...entities) {
+    this.lineSM(`import { ${entities.join(", ")} } from '${tsPackage}'`);
+  }
+  generatePackageIndexFile(schemas) {
+    this.cat("index.ts", () => {
+      let exports = schemas.map((schema) => ({
+        identifier: schema.identifier,
+        fileName: fileNameStem(schema.identifier),
+        name: resourceName(schema.identifier)
+      })).sort((a, b) => a.name.localeCompare(b.name));
+      exports = Array.from(new Map(exports.map((exp) => [exp.name.toLowerCase(), exp])).values()).sort(
+        (a, b) => a.name.localeCompare(b.name)
+      );
+      for (const exp of exports) {
+        this.debugComment(exp.identifier);
+        this.tsImportFrom(`./${exp.fileName}`, exp.name);
+      }
+      this.lineSM(`export { ${exports.map((e) => e.name).join(", ")} }`);
+      this.line("");
+      this.curlyBlock(["export type ResourceTypeMap = "], () => {
+        this.lineSM("User: Record<string, any>");
+        exports.forEach((exp) => {
+          this.debugComment(exp.identifier);
+          this.lineSM(`${exp.name}: ${exp.name}`);
+        });
+      });
+      this.lineSM("export type ResourceType = keyof ResourceTypeMap");
+      this.squareBlock(["export const resourceList: readonly ResourceType[] = "], () => {
+        exports.forEach((exp) => {
+          this.debugComment(exp.identifier);
+          this.line(`'${exp.name}', `);
+        });
+      });
+    });
+  }
+  generate(schemas) {
+    const typesToGenerate = [
+      ...collectComplexTypes(schemas),
+      ...collectResources(schemas)
+      // ...collectLogicalModels(typeSchemas),
+      // ...collectProfiles(typeSchemas),
+    ];
+    const grouped = groupByPackages(typesToGenerate);
+    this.cd("/", () => {
+      for (const [packageName, packageSchemas] of Object.entries(grouped)) {
+        const tsPackageName = kebabCase(packageName);
+        this.cd(tsPackageName, () => {
+          this.generatePackageIndexFile(packageSchemas);
+        });
+      }
+    });
+  }
+};
+
 // src/api/builder.ts
+var writerToGenerator = (writerGen) => {
+  const getGeneratedFiles = () => {
+    return writerGen.writtenFiles().map((fn) => {
+      return {
+        path: Path2.normalize(Path2.join(writerGen.opts.outputDir, fn)),
+        filename: fn.replace(/^.*[\\/]/, ""),
+        content: "",
+        exports: [],
+        size: 0,
+        timestamp: /* @__PURE__ */ new Date()
+      };
+    });
+  };
+  return {
+    generate: async (schemas) => {
+      writerGen.generate(schemas);
+      return getGeneratedFiles();
+    },
+    setOutputDir: (outputDir) => writerGen.opts.outputDir = outputDir,
+    build: async (_schemas) => getGeneratedFiles()
+  };
+};
 var APIBuilder = class {
   schemas = [];
   options;
   generators = /* @__PURE__ */ new Map();
-  progressCallback;
   cache;
   pendingOperations = [];
   typeSchemaGenerator;
   logger;
+  packages = [];
+  progressCallback;
   typeSchemaConfig;
   constructor(options = {}) {
     this.options = {
       outputDir: options.outputDir || "./generated",
       verbose: options.verbose ?? false,
       overwrite: options.overwrite ?? true,
-      validate: options.validate ?? true,
       cache: options.cache ?? true,
       typeSchemaConfig: options.typeSchemaConfig,
-      manager: options.manager || null
+      manager: options.manager || null,
+      throwException: options.throwException || false
     };
     this.typeSchemaConfig = options.typeSchemaConfig;
     this.logger = options.logger || createLogger({
@@ -5076,13 +5333,8 @@ var APIBuilder = class {
       this.cache = new TypeSchemaCache(this.typeSchemaConfig);
     }
   }
-  /**
-   * Load TypeSchema from a FHIR package
-   */
   fromPackage(packageName, version) {
-    this.logger.debug(`Loading from FHIR package: ${packageName}@${version || "latest"}`);
-    const operation = this.loadFromPackage(packageName, version);
-    this.pendingOperations.push(operation);
+    this.packages.push(packageMetaToNpm({ name: packageName, version: version || "latest" }));
     return this;
   }
   /**
@@ -5102,9 +5354,6 @@ var APIBuilder = class {
     this.schemas = [...this.schemas, ...schemas];
     return this;
   }
-  /**
-   * Configure TypeScript generation
-   */
   typescript(options = {}) {
     const typesOutputDir = `${this.options.outputDir}/types`;
     const generator = new TypeScriptGenerator({
@@ -5130,6 +5379,19 @@ var APIBuilder = class {
     this.logger.debug(`Configured TypeScript generator (${options.moduleFormat || "esm"})`);
     return this;
   }
+  typescript2(opts) {
+    const writerOpts = {
+      outputDir: Path2.join(this.options.outputDir, "/types"),
+      tabSize: 2,
+      withDebugComment: true,
+      commentLinePrefix: "//"
+    };
+    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)})`);
+    return this;
+  }
   /**
    * Set a progress callback for monitoring generation
    */
@@ -5150,23 +5412,15 @@ var APIBuilder = class {
     }
     return this;
   }
-  /**
-   * Enable/disable verbose logging
-   */
   verbose(enabled = true) {
     this.options.verbose = enabled;
+    this.logger?.configure({ verbose: enabled });
     return this;
   }
-  /**
-   * Enable/disable validation
-   */
-  validate(enabled = true) {
-    this.options.validate = enabled;
+  throwException(enabled = true) {
+    this.options.throwException = enabled;
     return this;
   }
-  /**
-   * Execute the generation process
-   */
   async generate() {
     const startTime = performance.now();
     const result = {
@@ -5179,35 +5433,33 @@ var APIBuilder = class {
     };
     this.logger.debug(`Starting generation with ${this.generators.size} generators`);
     try {
-      this.reportProgress("Loading", 0, 4, "Loading TypeSchema data...");
-      await this.resolveSchemas();
-      this.logger.debug(`Resolved ${this.schemas.length} schemas`);
-      this.reportProgress("Validating", 1, 4, "Validating TypeSchema documents...");
-      if (this.options.validate) {
-        this.logger.debug("Starting schema validation");
-        await this.validateSchemas(result);
-        this.logger.debug("Schema validation completed");
-      }
-      this.reportProgress("Generating", 2, 4, "Generating code...");
+      this.logger.info("Initialize Canonical Manager");
+      const manager = CanonicalManager({
+        packages: this.packages,
+        workingDir: "tmp/fhir"
+      });
+      await manager.init();
+      const register = await registerFromManager(manager, this.logger);
+      const typeSchemas = await generateTypeSchemas(register);
       this.logger.debug(`Executing ${this.generators.size} generators`);
-      await this.executeGenerators(result);
-      this.reportProgress("Complete", 4, 4, "Generation completed successfully");
+      await this.executeGenerators(result, typeSchemas);
+      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));
-      result.success = false;
-    } finally {
-      result.duration = performance.now() - startTime;
     }
-    return result;
+    return {
+      ...result,
+      success: result.errors.length === 0,
+      duration: performance.now() - startTime
+    };
   }
   /**
    * Generate and return the results without writing to files
    */
   async build() {
-    await this.resolveSchemas();
     const results = {};
     for (const [type, generator] of this.generators.entries()) {
       if (generator.build) {
@@ -5237,24 +5489,6 @@ var APIBuilder = class {
   getGenerators() {
     return Array.from(this.generators.keys());
   }
-  // Private implementation methods
-  async loadFromPackage(packageName, version) {
-    const generator = new TypeSchemaGenerator(
-      {
-        verbose: this.options.verbose,
-        logger: this.logger.child("Schema"),
-        treeshake: this.typeSchemaConfig?.treeshake,
-        manager: this.options.manager
-      },
-      this.typeSchemaConfig
-    );
-    this.typeSchemaGenerator = generator;
-    const schemas = await generator.generateFromPackage(packageName, version);
-    this.schemas = [...this.schemas, ...schemas];
-    if (this.cache) {
-      this.cache.setMany(schemas);
-    }
-  }
   async loadFromFiles(filePaths) {
     if (!this.typeSchemaGenerator) {
       this.typeSchemaGenerator = new TypeSchemaGenerator(
@@ -5267,8 +5501,7 @@ var APIBuilder = class {
       );
     }
     const parser = new TypeSchemaParser({
-      format: "auto",
-      validate: this.options.validate
+      format: "auto"
     });
     const schemas = await parser.parseFromFiles(filePaths);
     this.schemas = [...this.schemas, ...schemas];
@@ -5276,37 +5509,18 @@ var APIBuilder = class {
       this.cache.setMany(schemas);
     }
   }
-  async resolveSchemas() {
-    if (this.pendingOperations.length > 0) {
-      await Promise.all(this.pendingOperations);
-      this.pendingOperations = [];
-    }
-  }
-  async validateSchemas(_result) {
-    return;
-  }
-  async executeGenerators(result) {
-    const generatorCount = this.generators.size;
-    let current = 0;
+  async executeGenerators(result, typeSchemas) {
     for (const [type, generator] of this.generators.entries()) {
-      this.reportProgress("Generating", 2 + current / generatorCount, 4, `Generating ${type}...`);
+      this.logger.info(`Generating ${type}...`);
       try {
-        const files = await generator.generate(this.schemas);
+        const files = await generator.generate(typeSchemas);
         result.filesGenerated.push(...files.map((f) => f.path || f.filename));
+        this.logger.info(`Generating ${type} finished successfully`);
       } catch (error) {
         result.errors.push(
           `${type} generator failed: ${error instanceof Error ? error.message : String(error)}`
         );
       }
-      current++;
-    }
-  }
-  reportProgress(phase, current, total, message) {
-    if (this.progressCallback) {
-      this.progressCallback(phase, current, total, message);
-    }
-    if (this.options.verbose && message) {
-      this.logger.debug(`[${phase}] ${message}`);
     }
   }
 };
@@ -5318,7 +5532,6 @@ function createAPIFromConfig(config) {
     outputDir: config.outputDir,
     verbose: config.verbose,
     overwrite: config.overwrite,
-    validate: config.validate,
     cache: config.cache,
     typeSchemaConfig: config.typeSchema
   });
@@ -5338,15 +5551,13 @@ function createAPIFromConfig(config) {
 async function generateTypesFromPackage(packageName, outputDir, options = {}) {
   return createAPI({
     outputDir,
-    verbose: options.verbose,
-    validate: options.validate
+    verbose: options.verbose
   }).fromPackage(packageName, options.version).typescript().generate();
 }
 async function generateTypesFromFiles(inputFiles, outputDir, options = {}) {
   return createAPI({
     outputDir,
-    verbose: options.verbose,
-    validate: options.validate
+    verbose: options.verbose
   }).fromFiles(...inputFiles).typescript().generate();
 }
 var DEFAULT_CONFIG = {